@lightupai/polaris 0.0.77 → 0.0.78

package/tests/pagination.test.ts

@@ -0,0 +1,165 @@
+import { describe, expect, test, beforeAll, afterAll } from "bun:test";
+import {
+  createDb,
+  createOrg,
+  createProject,
+  createSession,
+  pushEvent,
+  getSessionEventsPage,
+  type Sql,
+} from "../src/service/db";
+import type { PolarisEvent } from "../src/types";
+
+const DATABASE_URL = process.env.DATABASE_URL ?? "postgres://polaris:polaris@localhost:5432/polaris_test";
+
+// Unique ids so this file is self-contained against a live Postgres.
+const RUN = crypto.randomUUID().slice(0, 8);
+const ORG = `pag-org-${RUN}`;
+const PROJECT = `pj-pagination-${RUN}`;
+const SESSION = "fx-page";
+const TIE_SESSION = "fx-ties";
+const TOTAL = 25;
+
+let sql: Sql;
+const insertedIds: string[] = [];
+const tieIds: string[] = [];
+
+function makeEvent(session: string, timestamp: string, prompt: string): PolarisEvent {
+  return {
+    id: crypto.randomUUID(),
+    project: PROJECT,
+    session,
+    timestamp,
+    source: "hook",
+    sender: "user:manu",
+    payload: {
+      hook_event_name: "UserPromptSubmit",
+      session_id: "cc-page",
+      prompt,
+    },
+  };
+}
+
+beforeAll(async () => {
+  // Drop and recreate via createDb (mirrors tests/db.test.ts) so the schema —
+  // including the additive migrations — matches src/service/db.ts exactly.
+  sql = await createDb(DATABASE_URL);
+  await sql`DROP TABLE IF EXISTS plan_changes`;
+  await sql`DROP TABLE IF EXISTS events`;
+  await sql`DROP TABLE IF EXISTS sessions`;
+  await sql`DROP TABLE IF EXISTS projects`;
+  await sql`DROP TABLE IF EXISTS users`;
+  await sql`DROP TABLE IF EXISTS orgs`;
+  await sql.end();
+  sql = await createDb(DATABASE_URL);
+  await createOrg(sql, ORG, "Pagination Org");
+  await createProject(sql, ORG, PROJECT);
+  await createSession(sql, ORG, PROJECT, SESSION, "user:manu");
+  await createSession(sql, ORG, PROJECT, TIE_SESSION, "user:manu");
+
+  // 25 events with distinct millisecond timestamps, inserted oldest-first
+  const base = Date.parse("2026-06-10T10:00:00.000Z");
+  for (let i = 0; i < TOTAL; i++) {
+    const event = makeEvent(SESSION, new Date(base + i * 1000).toISOString(), `prompt ${i}`);
+    insertedIds.push(event.id);
+    await pushEvent(sql, ORG, event);
+  }
+
+  // 6 events sharing an identical timestamp — keyset must fall back to id ordering
+  const tieTs = "2026-06-10T12:00:00.000Z";
+  for (let i = 0; i < 6; i++) {
+    const event = makeEvent(TIE_SESSION, tieTs, `tie ${i}`);
+    tieIds.push(event.id);
+    await pushEvent(sql, ORG, event);
+  }
+});
+
+afterAll(async () => {
+  await sql.end();
+});
+
+describe("getSessionEventsPage", () => {
+  test("returns at most `limit` events, newest first", async () => {
+    const { events } = await getSessionEventsPage(sql, ORG, PROJECT, SESSION, { limit: 10 });
+    expect(events).toHaveLength(10);
+    expect(events[0].payload).toHaveProperty("prompt", `prompt ${TOTAL - 1}`);
+    for (let i = 1; i < events.length; i++) {
+      expect(Date.parse(events[i - 1].timestamp)).toBeGreaterThanOrEqual(Date.parse(events[i].timestamp));
+    }
+  });
+
+  test("default limit returns everything when under 100, with null cursor", async () => {
+    const { events, nextCursor } = await getSessionEventsPage(sql, ORG, PROJECT, SESSION);
+    expect(events).toHaveLength(TOTAL);
+    expect(nextCursor).toBeNull();
+  });
+
+  test("nextCursor is the composite cursor of the oldest returned row", async () => {
+    const { events, nextCursor } = await getSessionEventsPage(sql, ORG, PROJECT, SESSION, { limit: 10 });
+    const oldest = events[events.length - 1];
+    expect(nextCursor).toBe(`${oldest.timestamp}|${oldest.id}`);
+  });
+
+  test("pages through all events with no duplicates or gaps", async () => {
+    const seen = new Set<string>();
+    const pageSizes: number[] = [];
+    let cursor: string | undefined;
+    let lastCursor: string | null = null;
+    while (true) {
+      const page = await getSessionEventsPage(sql, ORG, PROJECT, SESSION, { limit: 10, before: cursor });
+      if (page.events.length === 0) {
+        expect(page.nextCursor).toBeNull();
+        break;
+      }
+      pageSizes.push(page.events.length);
+      for (const event of page.events) {
+        expect(seen.has(event.id)).toBe(false); // no duplicates across pages
+        seen.add(event.id);
+      }
+      lastCursor = page.nextCursor;
+      if (!page.nextCursor) break;
+      cursor = page.nextCursor;
+    }
+    expect(pageSizes).toEqual([10, 10, 5]);
+    expect(lastCursor).toBeNull(); // short final page ends pagination
+    expect(seen.size).toBe(TOTAL);
+    expect([...seen].sort()).toEqual([...insertedIds].sort()); // no gaps
+  });
+
+  test("pages do not overlap and stay strictly older across the cursor boundary", async () => {
+    const page1 = await getSessionEventsPage(sql, ORG, PROJECT, SESSION, { limit: 10 });
+    const page2 = await getSessionEventsPage(sql, ORG, PROJECT, SESSION, { limit: 10, before: page1.nextCursor! });
+    const page1Ids = new Set(page1.events.map((e) => e.id));
+    for (const event of page2.events) {
+      expect(page1Ids.has(event.id)).toBe(false);
+    }
+    const oldestOfPage1 = page1.events[page1.events.length - 1];
+    expect(Date.parse(page2.events[0].timestamp)).toBeLessThan(Date.parse(oldestOfPage1.timestamp));
+  });
+
+  test("keyset is stable across identical timestamps (id tiebreak, no dupes/gaps)", async () => {
+    const seen = new Set<string>();
+    let cursor: string | undefined;
+    while (true) {
+      const page = await getSessionEventsPage(sql, ORG, PROJECT, TIE_SESSION, { limit: 2, before: cursor });
+      if (page.events.length === 0) {
+        expect(page.nextCursor).toBeNull();
+        break;
+      }
+      for (const event of page.events) {
+        expect(seen.has(event.id)).toBe(false);
+        seen.add(event.id);
+      }
+      if (!page.nextCursor) break;
+      cursor = page.nextCursor;
+    }
+    expect(seen.size).toBe(tieIds.length);
+    expect([...seen].sort()).toEqual([...tieIds].sort());
+  });
+
+  test("empty session returns no events and a null cursor", async () => {
+    const { events, nextCursor } = await getSessionEventsPage(sql, ORG, PROJECT, "fx-nothing-here");
+    expect(events).toEqual([]);
+    expect(nextCursor).toBeNull();
+  });
+});

package/tests/recover.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, test, afterAll } from "bun:test";
+import { mkdtemp, mkdir, rm, writeFile, readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+// Best-effort coverage of the `polaris recover` contract: read ~/.polaris/logs/*.jsonl,
+// re-POST events missing upstream, print a scanned/missing/restored summary, and —
+// crucially — never throw. The CLI runs as a subprocess with an isolated HOME so the
+// real ~/.polaris is untouched. Until the cli agent's command is integrated, the
+// tests detect its absence in src/cli/cli.ts and skip with a warning.
+
+const CLI_PATH = join(import.meta.dir, "..", "src", "cli", "cli.ts");
+
+let hasRecover = false;
+try {
+  hasRecover = /\brecover\b/.test(await readFile(CLI_PATH, "utf-8"));
+} catch {
+  // CLI missing entirely — skip.
+}
+if (!hasRecover) {
+  console.warn("[recover.test] `polaris recover` not implemented yet — skipping (expected before cli-agent integration)");
+}
+
+const homes: string[] = [];
+
+afterAll(async () => {
+  for (const home of homes) {
+    try { await rm(home, { recursive: true, force: true }); } catch { /* best-effort */ }
+  }
+});
+
+async function runRecover(jsonlLines: string[] | null): Promise<{ exitCode: number; output: string }> {
+  const home = await mkdtemp(join(tmpdir(), "polaris-recover-"));
+  homes.push(home);
+  if (jsonlLines !== null) {
+    const logDir = join(home, ".polaris", "logs");
+    await mkdir(logDir, { recursive: true });
+    await writeFile(join(logDir, "daemon-2026-06-01.jsonl"), jsonlLines.join("\n") + "\n");
+  }
+  const env = { ...(process.env as Record<string, string>) };
+  const proc = Bun.spawn([process.execPath, CLI_PATH, "recover"], {
+    env: {
+      ...env,
+      HOME: home,
+      // Unreachable API: recover is best-effort and must still exit cleanly.
+      POLARIS_SERVICE_URL: "http://127.0.0.1:9",
+      POLARIS_AUTH_TOKEN: "",
+    },
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ]);
+  return { exitCode, output: stdout + stderr };
+}
+
+describe("polaris recover", () => {
+  test.skipIf(!hasRecover)("exits cleanly with no logs present", async () => {
+    const { exitCode } = await runRecover(null);
+    expect(exitCode).toBe(0);
+  }, 30000);
+
+  test.skipIf(!hasRecover)("never throws on mixed/malformed log lines and an unreachable API", async () => {
+    const { exitCode, output } = await runRecover([
+      JSON.stringify({
+        t: "2026-06-01T10:00:00.000Z",
+        endpoint: "/events",
+        payload: { session_id: "cc-r1", hook_event_name: "UserPromptSubmit", prompt: "recover me" },
+      }),
+      "this line is not json {{{",
+      JSON.stringify({ t: "2026-06-01T10:01:00.000Z", endpoint: "/reply", payload: { ccSessionId: "cc-r1", message: "done" } }),
+    ]);
+    expect(exitCode).toBe(0);
+    // Contract: print a summary (scanned / missing / restored). Soft-check only —
+    // exact wording belongs to the cli agent.
+    if (!/scan|missing|restor|recover/i.test(output)) {
+      console.warn("[recover.test] no recognizable summary in output:", output.slice(0, 200));
+    }
+  }, 30000);
+});

package/tests/reply-attribution.test.ts

@@ -0,0 +1,103 @@
+// APPROACH CHOSEN (per the tests contract): the daemon test harness (startDaemon +
+// startServer) is usable exactly as in tests/daemon.test.ts, so this exercises the
+// full /reply path rather than a db-level unit test. The contract under test:
+// a daemon /reply must produce an event attributed to the session's AGENT identity
+// (mapping.agent), not the human driver (mapping.user) — replies are authored by the
+// agent on the user's behalf.
+import { describe, expect, test, beforeAll, afterAll, beforeEach } from "bun:test";
+import { startServer } from "../src/service/server";
+import { startDaemon } from "../src/daemon/daemon";
+import type { Sql } from "../src/service/db";
+import { resetTestData } from "./helpers";
+
+const DATABASE_URL = process.env.DATABASE_URL ?? "postgres://polaris:polaris@localhost:5432/polaris_test";
+
+let serviceUrl: string;
+let daemonUrl: string;
+let sql: Sql;
+let stopService: () => Promise<void>;
+let stopDaemon: () => void;
+
+beforeAll(async () => {
+  const s = await startServer({ port: 0, databaseUrl: DATABASE_URL });
+  sql = s.sql;
+  stopService = s.stop;
+  serviceUrl = `http://localhost:${s.server.port}`;
+
+  process.env.POLARIS_SERVICE_URL = serviceUrl;
+  process.env.POLARIS_AUTH_TOKEN = "";
+  const d = startDaemon(0);
+  stopDaemon = d.stop;
+  daemonUrl = `http://127.0.0.1:${d.server.port}`;
+});
+
+afterAll(async () => {
+  stopDaemon();
+  await stopService();
+});
+
+beforeEach(async () => {
+  await resetTestData(sql);
+  // The daemon session registry is module-level state; clear any mappings left
+  // behind by other test files so /reply routes only via our own ccSessionId.
+  await post(daemonUrl, "/disconnect-all", {});
+});
+
+async function post(base: string, path: string, body: unknown) {
+  return fetch(`${base}${path}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+}
+
+async function get(base: string, path: string) {
+  return fetch(`${base}${path}`);
+}
+
+describe("daemon /reply attribution", () => {
+  test("reply is attributed to the connected agent identity, not the user", async () => {
+    const connectRes = await post(daemonUrl, "/connect", {
+      ccSessionId: "cc-reply-attr",
+      project: "pj-reply",
+      session: "fx-reply",
+      user: "user:manu",
+      agent: "agent:replybot",
+    });
+    expect(connectRes.status).toBe(200);
+
+    const replyRes = await post(daemonUrl, "/reply", {
+      ccSessionId: "cc-reply-attr",
+      message: "Deployed the fix to staging",
+    });
+    expect(replyRes.status).toBe(200);
+
+    const messages = await get(serviceUrl, "/projects/pj-reply/sessions/fx-reply/messages");
+    const body = await messages.json();
+    expect(body).toHaveLength(1);
+    expect(body[0].payload.stop_response).toBe("Deployed the fix to staging");
+    expect(body[0].sender).toBe("agent:replybot"); // the agent identity from /connect
+    expect(body[0].sender).not.toBe("user:manu"); // never the human driver
+  });
+
+  test("reply uses the default agent identity when none was given at connect", async () => {
+    await post(daemonUrl, "/connect", {
+      ccSessionId: "cc-reply-default",
+      project: "pj-reply",
+      session: "fx-reply-default",
+      user: "user:krishna",
+    });
+
+    const replyRes = await post(daemonUrl, "/reply", {
+      ccSessionId: "cc-reply-default",
+      message: "Tests are green",
+    });
+    expect(replyRes.status).toBe(200);
+
+    const messages = await get(serviceUrl, "/projects/pj-reply/sessions/fx-reply-default/messages");
+    const body = await messages.json();
+    expect(body).toHaveLength(1);
+    expect(body[0].sender).toBe("agent:claude"); // daemon's default agent identity
+    expect(body[0].sender).not.toBe("user:krishna");
+  });
+});

package/tests/search-acl.test.ts

@@ -0,0 +1,117 @@
+import { describe, expect, test, beforeAll, afterAll } from "bun:test";
+import {
+  createDb,
+  createOrg,
+  createProject,
+  createSession,
+  pushEvent,
+  searchEvents,
+  addAnnotation,
+  listDecisions,
+  setProjectVisibility,
+  addProjectMember,
+  type Sql,
+} from "../src/service/db";
+import type { PolarisEvent } from "../src/types";
+
+// Regression test for the ACL bypass: search / decisions WITHOUT a project filter
+// must not leak content from 'members'-restricted projects to non-members.
+
+const DATABASE_URL = process.env.DATABASE_URL ?? "postgres://polaris:polaris@localhost:5432/polaris_test";
+
+const RUN = crypto.randomUUID().slice(0, 8);
+const ORG = `sacl-org-${RUN}`;
+const OPEN_PROJECT = `pj-sacl-open-${RUN}`;
+const LOCKED_PROJECT = `pj-sacl-locked-${RUN}`;
+const MEMBER = `user:member-${RUN}`;
+const OUTSIDER = `user:outsider-${RUN}`;
+
+// Distinctive single-token search terms so each match is unambiguous.
+const OPEN_TERM = "pelican";
+const LOCKED_TERM = "narwhal";
+
+let sql: Sql;
+
+function ev(project: string, session: string, ts: string, prompt: string): PolarisEvent {
+  return {
+    id: crypto.randomUUID(),
+    project,
+    session,
+    timestamp: ts,
+    source: "hook",
+    sender: "user:manu",
+    payload: { hook_event_name: "UserPromptSubmit", session_id: "cc-s", prompt },
+  };
+}
+
+beforeAll(async () => {
+  sql = await createDb(DATABASE_URL);
+  await sql`DROP TABLE IF EXISTS plan_changes`;
+  await sql`DROP TABLE IF EXISTS annotations`;
+  await sql`DROP TABLE IF EXISTS events`;
+  await sql`DROP TABLE IF EXISTS sessions`;
+  await sql`DROP TABLE IF EXISTS projects`;
+  await sql`DROP TABLE IF EXISTS users`;
+  await sql`DROP TABLE IF EXISTS orgs`;
+  await sql.end();
+  sql = await createDb(DATABASE_URL);
+
+  await createOrg(sql, ORG, "Search ACL Org");
+  await createProject(sql, ORG, OPEN_PROJECT);
+  await createProject(sql, ORG, LOCKED_PROJECT);
+  await createSession(sql, ORG, OPEN_PROJECT, "s1", "user:manu");
+  await createSession(sql, ORG, LOCKED_PROJECT, "s1", "user:manu");
+
+  await pushEvent(sql, ORG, ev(OPEN_PROJECT, "s1", "2026-06-10T10:00:00.000Z", `the ${OPEN_TERM} swims`));
+  await pushEvent(sql, ORG, ev(LOCKED_PROJECT, "s1", "2026-06-10T10:01:00.000Z", `the ${LOCKED_TERM} dives`));
+
+  await addAnnotation(sql, ORG, { project: OPEN_PROJECT, session: "s1", participant_id: "user:manu", kind: "decision", value: "use postgres" });
+  await addAnnotation(sql, ORG, { project: LOCKED_PROJECT, session: "s1", participant_id: "user:manu", kind: "decision", value: "use kafka" });
+
+  // Lock the second project and add MEMBER (OUTSIDER is intentionally not added).
+  await setProjectVisibility(sql, ORG, LOCKED_PROJECT, "members");
+  await addProjectMember(sql, ORG, LOCKED_PROJECT, MEMBER, "editor");
+});
+
+afterAll(async () => {
+  await sql.end();
+});
+
+describe("search respects project ACLs (no project filter)", () => {
+  test("outsider cannot find events in a 'members'-restricted project", async () => {
+    const open = await searchEvents(sql, ORG, { q: OPEN_TERM, participantId: OUTSIDER });
+    expect(open.results.length).toBeGreaterThan(0); // open project still searchable
+
+    const locked = await searchEvents(sql, ORG, { q: LOCKED_TERM, participantId: OUTSIDER });
+    expect(locked.results).toHaveLength(0); // restricted project content NOT leaked
+  });
+
+  test("member can find events in the restricted project", async () => {
+    const locked = await searchEvents(sql, ORG, { q: LOCKED_TERM, participantId: MEMBER });
+    expect(locked.results.length).toBeGreaterThan(0);
+  });
+
+  test("no participant (default-open / anonymous) sees everything", async () => {
+    const locked = await searchEvents(sql, ORG, { q: LOCKED_TERM });
+    expect(locked.results.length).toBeGreaterThan(0);
+  });
+});
+
+describe("decisions respect project ACLs (no project filter)", () => {
+  test("outsider does not see decisions from a restricted project", async () => {
+    const decisions = await listDecisions(sql, ORG, { participantId: OUTSIDER });
+    const projects = decisions.map((d) => d.project);
+    expect(projects).toContain(OPEN_PROJECT);
+    expect(projects).not.toContain(LOCKED_PROJECT);
+  });
+
+  test("member sees decisions from the restricted project", async () => {
+    const decisions = await listDecisions(sql, ORG, { participantId: MEMBER });
+    expect(decisions.map((d) => d.project)).toContain(LOCKED_PROJECT);
+  });
+
+  test("no participant (default-open) sees all decisions", async () => {
+    const decisions = await listDecisions(sql, ORG, {});
+    expect(decisions.map((d) => d.project)).toContain(LOCKED_PROJECT);
+  });
+});

package/tests/search.test.ts

@@ -0,0 +1,145 @@
+import { describe, expect, test, beforeAll, afterAll } from "bun:test";
+import {
+  createDb,
+  createOrg,
+  createProject,
+  createSession,
+  pushEvent,
+  searchEvents,
+  type Sql,
+} from "../src/service/db";
+import type { PolarisEvent } from "../src/types";
+
+const DATABASE_URL = process.env.DATABASE_URL ?? "postgres://polaris:polaris@localhost:5432/polaris_test";
+
+// Unique ids so this file is self-contained against a live Postgres.
+const RUN = crypto.randomUUID().slice(0, 8);
+const ORG = `search-org-${RUN}`;
+const PROJECT_A = `pj-search-a-${RUN}`;
+const PROJECT_B = `pj-search-b-${RUN}`;
+
+let sql: Sql;
+
+function baseEvent(project: string, session: string, timestamp: string): Pick<PolarisEvent, "id" | "project" | "session" | "timestamp"> {
+  return { id: crypto.randomUUID(), project, session, timestamp };
+}
+
+// Distinctive vocabulary per field so each match is unambiguous:
+//   "zeppelin"  -> prompt (A/s1), inject content (A/s1), prompt (B/s1)
+//   "quasar"    -> stop_response (A/s1)
+//   "labyrinth" -> last_assistant_message (A/s2)
+const promptEvent: PolarisEvent = {
+  ...baseEvent(PROJECT_A, "s1", "2026-06-10T10:00:00.000Z"),
+  source: "hook",
+  sender: "user:manu",
+  payload: { hook_event_name: "UserPromptSubmit", session_id: "cc-s", prompt: "deploy the zeppelin airship today" },
+};
+const stopEvent: PolarisEvent = {
+  ...baseEvent(PROJECT_A, "s1", "2026-06-10T10:01:00.000Z"),
+  source: "hook",
+  sender: "agent:claude",
+  payload: { hook_event_name: "Stop", session_id: "cc-s", stop_response: "the quasar pipeline output is ready" },
+};
+const lastMessageEvent: PolarisEvent = {
+  ...baseEvent(PROJECT_A, "s2", "2026-06-10T10:02:00.000Z"),
+  source: "hook",
+  sender: "agent:claude",
+  payload: { hook_event_name: "Stop", session_id: "cc-s", last_assistant_message: "finished the labyrinth refactor" },
+};
+const injectEvent: PolarisEvent = {
+  ...baseEvent(PROJECT_A, "s1", "2026-06-10T10:03:00.000Z"),
+  source: "inject",
+  sender: "user:priya",
+  payload: { type: "inject", content: "watch the zeppelin fuel budget", sender: "user:priya", target: "s1" },
+};
+const otherProjectEvent: PolarisEvent = {
+  ...baseEvent(PROJECT_B, "s1", "2026-06-10T10:04:00.000Z"),
+  source: "hook",
+  sender: "user:manu",
+  payload: { hook_event_name: "UserPromptSubmit", session_id: "cc-s", prompt: "zeppelin maintenance checklist" },
+};
+
+beforeAll(async () => {
+  // Drop and recreate via createDb (mirrors tests/db.test.ts) so the schema —
+  // including the additive migrations — matches src/service/db.ts exactly.
+  sql = await createDb(DATABASE_URL);
+  await sql`DROP TABLE IF EXISTS plan_changes`;
+  await sql`DROP TABLE IF EXISTS events`;
+  await sql`DROP TABLE IF EXISTS sessions`;
+  await sql`DROP TABLE IF EXISTS projects`;
+  await sql`DROP TABLE IF EXISTS users`;
+  await sql`DROP TABLE IF EXISTS orgs`;
+  await sql.end();
+  sql = await createDb(DATABASE_URL);
+  await createOrg(sql, ORG, "Search Org");
+  await createProject(sql, ORG, PROJECT_A);
+  await createProject(sql, ORG, PROJECT_B);
+  await createSession(sql, ORG, PROJECT_A, "s1", "user:manu");
+  await createSession(sql, ORG, PROJECT_A, "s2", "user:manu");
+  await createSession(sql, ORG, PROJECT_B, "s1", "user:manu");
+  for (const event of [promptEvent, stopEvent, lastMessageEvent, injectEvent, otherProjectEvent]) {
+    await pushEvent(sql, ORG, event);
+  }
+});
+
+afterAll(async () => {
+  await sql.end();
+});
+
+function ids(results: Array<{ event: PolarisEvent; snippet: string }>): string[] {
+  return results.map((r) => r.event.id).sort();
+}
+
+describe("searchEvents", () => {
+  test("matches a keyword in stop_response and returns a non-empty snippet", async () => {
+    const { results } = await searchEvents(sql, ORG, { q: "quasar" });
+    expect(results).toHaveLength(1);
+    expect(results[0].event.id).toBe(stopEvent.id);
+    expect(results[0].snippet.length).toBeGreaterThan(0);
+    expect(results[0].snippet.toLowerCase()).toContain("quasar");
+  });
+
+  test("matches across prompt, inject content, and last_assistant_message", async () => {
+    const zeppelin = await searchEvents(sql, ORG, { q: "zeppelin" });
+    expect(ids(zeppelin.results)).toEqual([promptEvent.id, injectEvent.id, otherProjectEvent.id].sort());
+
+    const labyrinth = await searchEvents(sql, ORG, { q: "labyrinth" });
+    expect(ids(labyrinth.results)).toEqual([lastMessageEvent.id]);
+  });
+
+  test("respects the project filter", async () => {
+    const { results } = await searchEvents(sql, ORG, { q: "zeppelin", project: PROJECT_A });
+    expect(ids(results)).toEqual([promptEvent.id, injectEvent.id].sort());
+  });
+
+  test("respects the session filter", async () => {
+    const inS1 = await searchEvents(sql, ORG, { q: "zeppelin", project: PROJECT_A, session: "s1" });
+    expect(ids(inS1.results)).toEqual([promptEvent.id, injectEvent.id].sort());
+
+    const inS2 = await searchEvents(sql, ORG, { q: "zeppelin", project: PROJECT_A, session: "s2" });
+    expect(inS2.results).toEqual([]);
+  });
+
+  test("respects the sender filter", async () => {
+    const { results } = await searchEvents(sql, ORG, { q: "zeppelin", sender: "user:priya" });
+    expect(ids(results)).toEqual([injectEvent.id]);
+  });
+
+  test("respects the source filter", async () => {
+    const injects = await searchEvents(sql, ORG, { q: "zeppelin", source: "inject" });
+    expect(ids(injects.results)).toEqual([injectEvent.id]);
+
+    const hooks = await searchEvents(sql, ORG, { q: "zeppelin", source: "hook" });
+    expect(ids(hooks.results)).toEqual([promptEvent.id, otherProjectEvent.id].sort());
+  });
+
+  test("respects the limit", async () => {
+    const { results } = await searchEvents(sql, ORG, { q: "zeppelin", limit: 1 });
+    expect(results).toHaveLength(1);
+  });
+
+  test("returns no results for a non-matching query", async () => {
+    const { results } = await searchEvents(sql, ORG, { q: "octopus" });
+    expect(results).toEqual([]);
+  });
+});