nlm-memory 0.5.0 → 0.5.1

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);
-  });
-});

package/tests/integration/hook-claude-settings.test.ts

@@ -1,218 +0,0 @@
-import { mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { spawnSync } from "node:child_process";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import {
-  addHook,
-  buildHookCommand,
-  removeHook,
-  shellQuote,
-  smokeTestHookCommand,
-} from "../../src/core/hook/claude-settings.js";
-
-interface Settings {
-  hooks?: {
-    UserPromptSubmit?: Array<{ hooks: Array<{ type: string; command: string }> }>;
-    PostToolUse?: Array<{ hooks: Array<{ type: string; command: string }> }>;
-    SessionEnd?: Array<{ hooks: Array<{ type: string; command: string }> }>;
-    [event: string]: Array<{ hooks: Array<{ type: string; command: string }> }> | undefined;
-  };
-}
-
-describe("claude-settings hook editor", () => {
-  let tmp: string;
-  let settingsPath: string;
-  const CMD = "NLM_HOOK_MODE=shadow node /abs/dist/hook/prompt-recall-hook.js";
-
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), "nlm-settings-"));
-    settingsPath = join(tmp, "settings.json");
-  });
-
-  afterEach(() => rmSync(tmp, { recursive: true, force: true }));
-
-  it("creates settings.json with the hook entry when the file is absent", () => {
-    addHook(settingsPath, CMD);
-    const s = JSON.parse(readFileSync(settingsPath, "utf8")) as Settings;
-    const entries = s.hooks?.UserPromptSubmit ?? [];
-    expect(entries).toHaveLength(1);
-    expect(entries[0]?.hooks[0]?.command).toBe(CMD);
-  });
-
-  it("preserves unrelated existing settings and hooks", () => {
-    writeFileSync(
-      settingsPath,
-      JSON.stringify({
-        model: "sonnet",
-        hooks: { UserPromptSubmit: [{ hooks: [{ type: "command", command: "other-tool" }] }] },
-      }),
-      "utf8",
-    );
-    addHook(settingsPath, CMD);
-    const s = JSON.parse(readFileSync(settingsPath, "utf8")) as Settings & { model?: string };
-    expect(s.model).toBe("sonnet");
-    const cmds = (s.hooks?.UserPromptSubmit ?? []).flatMap((e) => e.hooks.map((h) => h.command));
-    expect(cmds).toContain("other-tool");
-    expect(cmds).toContain(CMD);
-  });
-
-  it("is idempotent — re-adding does not duplicate the nlm entry", () => {
-    addHook(settingsPath, CMD);
-    addHook(settingsPath, "NLM_HOOK_MODE=live node /abs/dist/hook/prompt-recall-hook.js");
-    const s = JSON.parse(readFileSync(settingsPath, "utf8")) as Settings;
-    const cmds = (s.hooks?.UserPromptSubmit ?? []).flatMap((e) => e.hooks.map((h) => h.command));
-    const nlmCmds = cmds.filter((c) => c.includes("prompt-recall-hook.js"));
-    expect(nlmCmds).toHaveLength(1);
-    expect(nlmCmds[0]).toContain("NLM_HOOK_MODE=live");
-  });
-
-  it("removeHook removes only the nlm entry and leaves others intact", () => {
-    writeFileSync(
-      settingsPath,
-      JSON.stringify({
-        hooks: { UserPromptSubmit: [{ hooks: [{ type: "command", command: "other-tool" }] }] },
-      }),
-      "utf8",
-    );
-    addHook(settingsPath, CMD);
-    removeHook(settingsPath);
-    const s = JSON.parse(readFileSync(settingsPath, "utf8")) as Settings;
-    const cmds = (s.hooks?.UserPromptSubmit ?? []).flatMap((e) => e.hooks.map((h) => h.command));
-    expect(cmds).toEqual(["other-tool"]);
-  });
-
-  it("removeHook is a no-op when settings.json does not exist", () => {
-    expect(() => removeHook(settingsPath)).not.toThrow();
-  });
-
-  it("removeHook of the only nlm entry leaves no empty UserPromptSubmit litter", () => {
-    addHook(settingsPath, CMD);
-    removeHook(settingsPath);
-    const s = JSON.parse(readFileSync(settingsPath, "utf8")) as Settings;
-    expect(s.hooks?.UserPromptSubmit).toBeUndefined();
-  });
-
-  function shEcho(s: string): string {
-    return spawnSync("sh", ["-c", `echo ${s}`], { encoding: "utf8" }).stdout.trim();
-  }
-
-  it("shellQuote wraps paths with spaces so sh -c keeps them as one arg", () => {
-    const pathWithSpace = "/Users/echalupa/Documents/Coding Projects/foo/bar.js";
-    expect(shEcho(shellQuote(pathWithSpace))).toBe(pathWithSpace);
-  });
-
-  it("shellQuote escapes embedded single quotes", () => {
-    const tricky = "/path/with'quote/file.js";
-    expect(shEcho(shellQuote(tricky))).toBe(tricky);
-  });
-
-  it("buildHookCommand quotes both paths (POSIX)", () => {
-    const cmd = buildHookCommand(
-      "/usr/local/bin/node",
-      "/Users/echalupa/Documents/Coding Projects/nlm/dist/hook/prompt-recall-hook.js",
-      "shadow",
-      "darwin",
-    );
-    expect(cmd).toBe(
-      "NLM_HOOK_MODE=shadow '/usr/local/bin/node' '/Users/echalupa/Documents/Coding Projects/nlm/dist/hook/prompt-recall-hook.js'",
-    );
-  });
-
-  it("buildHookCommand emits cmd.exe format on Windows", () => {
-    const cmd = buildHookCommand(
-      "C:\\Program Files\\nodejs\\node.exe",
-      "C:\\Users\\Test\\AppData\\Roaming\\npm\\node_modules\\nlm-memory\\dist\\hook\\prompt-recall-hook.js",
-      "live",
-      "win32",
-    );
-    expect(cmd).toBe(
-      'set NLM_HOOK_MODE=live && "C:\\Program Files\\nodejs\\node.exe" "C:\\Users\\Test\\AppData\\Roaming\\npm\\node_modules\\nlm-memory\\dist\\hook\\prompt-recall-hook.js"',
-    );
-  });
-
-  it("smokeTestHookCommand reports failure when command exits nonzero", () => {
-    const logPath = join(tmp, "hook-log.jsonl");
-    const result = smokeTestHookCommand("exit 1", logPath);
-    expect(result.ok).toBe(false);
-    expect(result.reason).toContain("exit code 1");
-  });
-
-  it("smokeTestHookCommand reports failure when log does not gain an entry", () => {
-    const logPath = join(tmp, "hook-log.jsonl");
-    const result = smokeTestHookCommand("true", logPath);
-    expect(result.ok).toBe(false);
-    expect(result.reason).toContain("no entry appended");
-  });
-
-  it("smokeTestHookCommand passes when command writes to the log", () => {
-    const logPath = join(tmp, "hook-log.jsonl");
-    const result = smokeTestHookCommand(
-      `printf '{"ts":"x"}\\n' >> ${shellQuote(logPath)}`,
-      logPath,
-    );
-    expect(result.ok).toBe(true);
-    expect(statSync(logPath).size).toBeGreaterThan(0);
-  });
-
-  it("addHook preserves an unrelated hook event key", () => {
-    writeFileSync(
-      settingsPath,
-      JSON.stringify({
-        hooks: { PostToolUse: [{ hooks: [{ type: "command", command: "other-event" }] }] },
-      }),
-      "utf8",
-    );
-    addHook(settingsPath, CMD);
-    const s = JSON.parse(readFileSync(settingsPath, "utf8")) as Settings;
-    expect(s.hooks?.PostToolUse).toHaveLength(1);
-    const ups = s.hooks?.UserPromptSubmit ?? [];
-    const cmds = ups.flatMap((e) => e.hooks.map((h) => h.command));
-    expect(cmds).toContain(CMD);
-  });
-
-  it("addHook installs under a non-default event when specified", () => {
-    const sessionEndCmd = "node /abs/dist/hook/session-end-hook.js";
-    addHook(settingsPath, sessionEndCmd, "SessionEnd");
-    const s = JSON.parse(readFileSync(settingsPath, "utf8")) as Settings & {
-      hooks?: { SessionEnd?: Array<{ hooks: Array<{ command: string }> }> };
-    };
-    expect(s.hooks?.UserPromptSubmit).toBeUndefined();
-    expect(s.hooks?.SessionEnd).toHaveLength(1);
-    expect(s.hooks?.SessionEnd?.[0]?.hooks[0]?.command).toBe(sessionEndCmd);
-  });
-
-  it("addHook can hold separate NLM entries on two event keys without collision", () => {
-    addHook(settingsPath, CMD, "UserPromptSubmit");
-    const sessionEndCmd = "node /abs/dist/hook/session-end-hook.js";
-    addHook(settingsPath, sessionEndCmd, "SessionEnd");
-    const s = JSON.parse(readFileSync(settingsPath, "utf8")) as Settings & {
-      hooks?: { SessionEnd?: Array<{ hooks: Array<{ command: string }> }> };
-    };
-    expect(s.hooks?.UserPromptSubmit).toHaveLength(1);
-    expect(s.hooks?.SessionEnd).toHaveLength(1);
-  });
-
-  it("removeHook with event='*' clears the NLM entry from every event", () => {
-    addHook(settingsPath, CMD, "UserPromptSubmit");
-    const sessionEndCmd = "node /abs/dist/hook/session-end-hook.js";
-    addHook(settingsPath, sessionEndCmd, "SessionEnd");
-    // Also add an unrelated PostToolUse entry to confirm we don't touch it.
-    writeFileSync(
-      settingsPath,
-      JSON.stringify({
-        hooks: {
-          UserPromptSubmit: [{ hooks: [{ type: "command", command: CMD }] }],
-          SessionEnd: [{ hooks: [{ type: "command", command: sessionEndCmd }] }],
-          PostToolUse: [{ hooks: [{ type: "command", command: "other-tool" }] }],
-        },
-      }),
-      "utf8",
-    );
-    removeHook(settingsPath, "*");
-    const s = JSON.parse(readFileSync(settingsPath, "utf8")) as Settings;
-    expect(s.hooks?.UserPromptSubmit).toBeUndefined();
-    expect(s.hooks?.SessionEnd).toBeUndefined();
-    expect(s.hooks?.PostToolUse).toHaveLength(1);
-  });
-});

package/tests/integration/hook-log.test.ts

@@ -1,54 +0,0 @@
-import { 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 { appendHookLog, type HookLogEntry } from "../../src/core/hook/hook-log.js";
-
-const entry = (over: Partial<HookLogEntry> = {}): HookLogEntry => ({
-  ts: "2026-05-20T12:00:00.000Z",
-  conversationId: "conv-1",
-  promptPreview: "what did we decide about pgvector",
-  gate: "evaluate",
-  hits: [{ id: "sess_a", score: 0.9 }],
-  wouldInject: ["sess_a"],
-  estTokens: 42,
-  mode: "shadow",
-  ...over,
-});
-
-describe("appendHookLog", () => {
-  let tmp: string;
-  let logPath: string;
-
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), "nlm-hooklog-"));
-    logPath = join(tmp, "hook-log.jsonl");
-    process.env["NLM_HOOK_LOG"] = logPath;
-  });
-
-  afterEach(() => {
-    delete process.env["NLM_HOOK_LOG"];
-    rmSync(tmp, { recursive: true, force: true });
-  });
-
-  it("appends one JSON line per call", () => {
-    appendHookLog(entry());
-    appendHookLog(entry({ conversationId: "conv-2" }));
-    const lines = readFileSync(logPath, "utf8").trim().split("\n");
-    expect(lines).toHaveLength(2);
-    const first = JSON.parse(lines[0] ?? "");
-    expect(first.conversationId).toBe("conv-1");
-    expect(first.wouldInject).toEqual(["sess_a"]);
-    expect(first.estTokens).toBe(42);
-  });
-
-  it("creates the parent directory if missing", () => {
-    process.env["NLM_HOOK_LOG"] = join(tmp, "nested", "deep", "hook-log.jsonl");
-    appendHookLog(entry());
-    const lines = readFileSync(
-      join(tmp, "nested", "deep", "hook-log.jsonl"),
-      "utf8",
-    ).trim().split("\n");
-    expect(lines).toHaveLength(1);
-  });
-});

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

@@ -1,68 +0,0 @@
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { clearSurfaced, loadSurfaced, recordSurfaced } from "../../src/core/hook/memo.js";
-
-describe("hook memo", () => {
-  let tmp: string;
-
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), "nlm-memo-"));
-    process.env["NLM_HOOK_STATE_DIR"] = tmp;
-  });
-
-  afterEach(() => {
-    delete process.env["NLM_HOOK_STATE_DIR"];
-    rmSync(tmp, { recursive: true, force: true });
-  });
-
-  it("returns an empty set for an unknown conversation", () => {
-    expect(loadSurfaced("conv-1").size).toBe(0);
-  });
-
-  it("records and reloads surfaced ids", () => {
-    recordSurfaced("conv-1", ["sess_a", "sess_b"]);
-    const got = loadSurfaced("conv-1");
-    expect([...got].sort()).toEqual(["sess_a", "sess_b"]);
-  });
-
-  it("accumulates across multiple records and dedups", () => {
-    recordSurfaced("conv-1", ["sess_a"]);
-    recordSurfaced("conv-1", ["sess_a", "sess_c"]);
-    expect([...loadSurfaced("conv-1")].sort()).toEqual(["sess_a", "sess_c"]);
-  });
-
-  it("isolates conversations from each other", () => {
-    recordSurfaced("conv-1", ["sess_a"]);
-    recordSurfaced("conv-2", ["sess_z"]);
-    expect([...loadSurfaced("conv-1")]).toEqual(["sess_a"]);
-    expect([...loadSurfaced("conv-2")]).toEqual(["sess_z"]);
-  });
-
-  it("loadSurfaced returns empty on a corrupt memo file rather than throwing", () => {
-    recordSurfaced("conv-1", ["sess_a"]);
-    // overwrite with garbage
-    writeFileSync(join(tmp, "conv-1.json"), "{not json", "utf8");
-    expect(loadSurfaced("conv-1").size).toBe(0);
-  });
-
-  it("clearSurfaced deletes the memo file and returns true", () => {
-    recordSurfaced("conv-1", ["sess_a"]);
-    expect(loadSurfaced("conv-1").size).toBe(1);
-    expect(clearSurfaced("conv-1")).toBe(true);
-    expect(loadSurfaced("conv-1").size).toBe(0);
-  });
-
-  it("clearSurfaced returns false when no memo file exists", () => {
-    expect(clearSurfaced("never-existed")).toBe(false);
-  });
-
-  it("clearSurfaced isolates conversations — only deletes the targeted one", () => {
-    recordSurfaced("conv-1", ["sess_a"]);
-    recordSurfaced("conv-2", ["sess_b"]);
-    clearSurfaced("conv-1");
-    expect(loadSurfaced("conv-1").size).toBe(0);
-    expect([...loadSurfaced("conv-2")]).toEqual(["sess_b"]);
-  });
-});