@vellumai/assistant 0.10.4-dev.202607010146.a37a2fa → 0.10.4-dev.202607010319.f2b69c7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.10.4-dev.202607010146.a37a2fa",
+  "version": "0.10.4-dev.202607010319.f2b69c7",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/clear-all-lexical.test.ts

@@ -0,0 +1,93 @@
+// clearAll() must drop the memory feature's bulk per-message index (the whole
+// lexical Qdrant collection) — a "delete all" leaves no conversation ids to key
+// per-conversation purges on, so the points would otherwise survive a
+// "permanently delete everything" action. clearAll routes this through the
+// `MemoryPersistenceHooks.onAllConversationsCleared` seam (persistence stays
+// decoupled from the plugin); the memory plugin's impl calls
+// `clearMessagesLexicalIndex`. This asserts the full chain fires.
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { makeMockLogger } from "./helpers/mock-logger.js";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => makeMockLogger(),
+}));
+
+// Spy on `clearMessagesLexicalIndex` (the plugin's `onAllConversationsCleared`
+// impl calls it) while keeping the rest of the module REAL. `mock.module` is
+// process-global and not undone by `mock.restore()`, so a partial mock that
+// drops the other exports would leak into any later test file in the same
+// process that imports them (e.g. the handler tests importing
+// `indexMessageLexicalJob`). Spread the real module so only this one export is
+// replaced. Importing the real module here is safe: its deps
+// (`@qdrant/js-client-rest`, `uuid`, the local TF-IDF encoder) resolve in the
+// worktree.
+const actualLexical =
+  await import("../plugins/defaults/memory/job-handlers/index-message-lexical.js");
+let clearCalls = 0;
+mock.module(
+  "../plugins/defaults/memory/job-handlers/index-message-lexical.js",
+  () => ({
+    ...actualLexical,
+    clearMessagesLexicalIndex: async () => {
+      clearCalls += 1;
+    },
+  }),
+);
+
+import { clearAll } from "../persistence/conversation-crud.js";
+import { initializeDb } from "../persistence/db-init.js";
+import {
+  getMemoryPersistenceHooks,
+  registerMemoryPersistenceHooks,
+  resetMemoryPersistenceHooksForTests,
+} from "../persistence/memory-lifecycle-hooks.js";
+import { registerDefaultPluginPersistenceHooks } from "../plugins/defaults/index.js";
+
+await initializeDb();
+
+describe("clearAll bulk lexical index cleanup", () => {
+  beforeEach(() => {
+    clearCalls = 0;
+    // Register the real memory persistence hooks so `onAllConversationsCleared`
+    // routes to the plugin impl (which calls the spied clear helper).
+    registerDefaultPluginPersistenceHooks();
+  });
+
+  test("clearAll fires onAllConversationsCleared, which clears the lexical index", async () => {
+    await clearAll();
+    expect(clearCalls).toBe(1);
+  });
+
+  test("clearAll AWAITS the collection drop before returning", async () => {
+    // The drop must complete before clearAll resolves — otherwise a write right
+    // after clear-all could land in a collection that is about to be dropped.
+    // Register a hook whose drop yields to the microtask queue before finishing;
+    // if clearAll did not await, `dropCompleted` would still be false here.
+    let dropCompleted = false;
+    registerMemoryPersistenceHooks({
+      ...getMemoryPersistenceHooks(),
+      async onAllConversationsCleared() {
+        await new Promise((r) => setTimeout(r, 10));
+        dropCompleted = true;
+      },
+    });
+
+    await clearAll();
+    expect(dropCompleted).toBe(true);
+
+    registerDefaultPluginPersistenceHooks();
+  });
+
+  test("clearAll is a safe no-op when the memory hooks are not registered", async () => {
+    // Persistence must work with no memory present — the seam falls through to
+    // its no-op and clearAll does not touch the lexical index.
+    resetMemoryPersistenceHooksForTests();
+    clearCalls = 0;
+    await clearAll();
+    expect(clearCalls).toBe(0);
+    // Restore for any later test in the same process.
+    registerDefaultPluginPersistenceHooks();
+  });
+});

package/src/__tests__/conversation-wipe.test.ts

@@ -118,16 +118,31 @@ describe("wipeConversation", () => {
       }
     ).$client;
 
-    // Both jobs should be failed with conversation_wiped error
     const jobs = raw
-      .query("SELECT status, last_error FROM memory_jobs")
-      .all() as Array<{ status: string; last_error: string | null }>;
-
-    for (const job of jobs) {
+      .query("SELECT type, status, last_error FROM memory_jobs")
+      .all() as Array<{
+      type: string;
+      status: string;
+      last_error: string | null;
+    }>;
+
+    // The pre-existing jobs should be failed with the conversation_wiped error.
+    for (const job of jobs.filter(
+      (j) => j.type !== "purge_conversation_lexical",
+    )) {
       expect(job.status).toBe("failed");
       expect(job.last_error).toContain("conversation_wiped");
     }
 
+    // Wiping also enqueues a lexical-index purge, which must SURVIVE the
+    // job-cancellation pass (it is enqueued after cancellation) so the worker
+    // can delete the conversation's Qdrant points.
+    const purgeJobs = jobs.filter(
+      (j) => j.type === "purge_conversation_lexical",
+    );
+    expect(purgeJobs).toHaveLength(1);
+    expect(purgeJobs[0].status).toBe("pending");
+
     expect(result.cancelledJobCount).toBeGreaterThanOrEqual(2);
   });
 

package/src/__tests__/edit-propagation.test.ts

@@ -21,10 +21,10 @@ mock.module("../util/logger.js", () => ({
 import { readSlackMetadata } from "../messaging/providers/slack/message-metadata.js";
 import { addMessage } from "../persistence/conversation-crud.js";
 import { getConversationByKey } from "../persistence/conversation-key-store.js";
-import { getDb } from "../persistence/db-connection.js";
+import { getDb, getMemoryDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
 import { linkMessage, recordInbound } from "../persistence/delivery-crud.js";
-import { messages } from "../persistence/schema/index.js";
+import { memoryJobs, messages } from "../persistence/schema/index.js";
 import { handleEditIntercept } from "../runtime/routes/inbound-stages/edit-intercept.js";
 
 await initializeDb();
@@ -35,6 +35,25 @@ function resetTables(): void {
   db.run("DELETE FROM messages");
   db.run("DELETE FROM conversation_keys");
   db.run("DELETE FROM conversations");
+  // memory_jobs lives in the dedicated memory connection.
+  getMemoryDb()!.run("DELETE FROM memory_jobs");
+}
+
+function lexicalIndexJobMessageIds(): string[] {
+  return getMemoryDb()!
+    .select({ payload: memoryJobs.payload })
+    .from(memoryJobs)
+    .where(eq(memoryJobs.type, "index_message_lexical"))
+    .all()
+    .map((r) => {
+      try {
+        return (
+          (JSON.parse(r.payload) as { messageId?: string }).messageId ?? ""
+        );
+      } catch {
+        return "";
+      }
+    });
 }
 
 interface SeededFixture {
@@ -276,6 +295,41 @@ describe("Slack edit propagation", () => {
     expect(after.content).toBe(before.content);
     // No metadata mutation either -- the write is fully skipped.
     expect(after.metadata).toBe(before.metadata);
+
+    // A no-op edit changes no searchable text, so it must NOT enqueue a lexical
+    // reindex.
+    expect(lexicalIndexJobMessageIds()).not.toContain(seeded.messageId);
+  });
+
+  test("a content-changing edit enqueues a lexical reindex for the message", async () => {
+    // Regression: channel edits update the row in-place via
+    // updateMessageContentAndMetadata / updateMessageContent, bypassing
+    // onMessagePersisted. The lexical index must be refreshed so the old Qdrant
+    // point does not go stale against the edited (FTS-updated) content.
+    const seeded = await seedSlackMessage({
+      conversationExternalId: "C0123CHANNEL",
+      channelTs: "1234.5678",
+      initialContent: "original text",
+    });
+
+    // The seed used skipIndexing, so no lexical job exists yet.
+    expect(lexicalIndexJobMessageIds()).not.toContain(seeded.messageId);
+
+    await handleEditIntercept({
+      sourceChannel: "slack",
+      conversationExternalId: seeded.conversationExternalId,
+      externalMessageId: nextEditEventId(),
+      sourceMessageId: seeded.channelTs,
+      canonicalAssistantId: "self",
+      assistantId: "self",
+      content: "edited searchable text",
+    });
+
+    expect(readMessageRow(seeded.messageId).content).toBe(
+      "edited searchable text",
+    );
+    // The edit reindexed the message into the lexical index.
+    expect(lexicalIndexJobMessageIds()).toContain(seeded.messageId);
   });
 
   // The lookup retries 5 times with 2s backoff (~10s total) before giving up,

package/src/__tests__/job-handler-registry-guard.test.ts

@@ -45,6 +45,7 @@ const MEMORY_JOB_TYPES = [
   "memory_retrospective",
   "index_message_lexical",
   "purge_conversation_lexical",
+  "delete_message_lexical",
   "backfill_lexical_index",
 ].sort();
 

package/src/__tests__/lexical-index-dual-write.test.ts

@@ -0,0 +1,418 @@
+// Integration coverage for the messages lexical-index dual-write wiring:
+//   - a real persist (`addMessage` → `onMessagePersisted`) enqueues one
+//     `index_message_lexical` job for the message when memory is enabled, and
+//     none when memory is disabled;
+//   - forking a conversation copies message rows WITHOUT routing through
+//     `onMessagePersisted`, so a fork enqueues ZERO `index_message_lexical`
+//     jobs (the fork-exclusion regression);
+//   - wiping a conversation enqueues one `purge_conversation_lexical` job.
+//
+// The heavy segment indexer (`indexMessageNow`) is stubbed to a no-op so these
+// tests exercise only the lexical enqueue seam, not the embedding/extraction
+// machinery. Memory config is real (default-enabled), flipped on disk for the
+// disabled case.
+
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { eq } from "drizzle-orm";
+
+import { makeMockLogger } from "./helpers/mock-logger.js";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => makeMockLogger(),
+}));
+
+// Stub the segment indexer so `onMessagePersisted` runs cheaply. The lexical
+// enqueue in the hook is a separate call and still fires. Other exports are
+// provided so any transitive importer of this module resolves. `throwFromIndex`
+// lets a test simulate a transient segment-indexing failure to prove the
+// lexical enqueue survives it.
+let throwFromIndex = false;
+mock.module("../plugins/defaults/memory/indexer.js", () => ({
+  MIN_SEGMENT_CHARS: 50,
+  indexMessageNow: async () => {
+    if (throwFromIndex) throw new Error("simulated segment-indexing failure");
+    return { indexedSegments: 0, enqueuedJobs: 0 };
+  },
+  enqueueBackfillJob: () => "",
+  enqueueRebuildIndexJob: () => "",
+}));
+
+import {
+  invalidateConfigCache,
+  loadRawConfig,
+  saveRawConfig,
+} from "../config/loader.js";
+import { consolidateAssistantMessages } from "../daemon/conversation-history.js";
+import {
+  addMessage,
+  createConversation,
+  deleteConversation,
+  deleteConversationGently,
+  deleteLastExchange,
+  deleteMessageById,
+  forkConversation,
+  getMessages,
+  updateMessageContent,
+  wipeConversation,
+} from "../persistence/conversation-crud.js";
+import { getMemoryDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+import type { MemoryJobType } from "../persistence/jobs-store.js";
+import {
+  getMemoryPersistenceHooks,
+  type MemoryPersistenceHooks,
+  registerMemoryPersistenceHooks,
+} from "../persistence/memory-lifecycle-hooks.js";
+import { memoryJobs } from "../persistence/schema/index.js";
+import { registerDefaultPluginPersistenceHooks } from "../plugins/defaults/index.js";
+import { enqueueLexicalIndexForMessage } from "../plugins/defaults/memory/job-handlers/index-message-lexical.js";
+
+await initializeDb();
+
+function countJobs(type: MemoryJobType, conversationId?: string): number {
+  const rows = getMemoryDb()!
+    .select({ payload: memoryJobs.payload })
+    .from(memoryJobs)
+    .where(eq(memoryJobs.type, type))
+    .all();
+  if (conversationId == null) return rows.length;
+  return rows.filter((r) => {
+    try {
+      return (
+        (JSON.parse(r.payload) as { conversationId?: string })
+          .conversationId === conversationId
+      );
+    } catch {
+      return false;
+    }
+  }).length;
+}
+
+function lexicalJobMessageIds(): string[] {
+  return getMemoryDb()!
+    .select({ payload: memoryJobs.payload })
+    .from(memoryJobs)
+    .where(eq(memoryJobs.type, "index_message_lexical"))
+    .all()
+    .map((r) => {
+      try {
+        return (
+          (JSON.parse(r.payload) as { messageId?: string }).messageId ?? ""
+        );
+      } catch {
+        return "";
+      }
+    });
+}
+
+function resetMemoryJobs(): void {
+  getMemoryDb()!.delete(memoryJobs).run();
+}
+
+function setMemoryEnabled(enabled: boolean): void {
+  const raw = loadRawConfig();
+  const memory =
+    raw.memory && typeof raw.memory === "object"
+      ? (raw.memory as Record<string, unknown>)
+      : {};
+  saveRawConfig({ ...raw, memory: { ...memory, enabled } });
+  invalidateConfigCache();
+}
+
+describe("messages lexical-index dual-write", () => {
+  beforeEach(() => {
+    resetMemoryJobs();
+    registerDefaultPluginPersistenceHooks();
+  });
+
+  afterEach(() => {
+    // Restore the default-enabled config so a disabled-case test cannot leak
+    // into later tests sharing this process.
+    setMemoryEnabled(true);
+    throwFromIndex = false;
+  });
+
+  test("addMessage enqueues one index_message_lexical job for the persisted message", async () => {
+    const conv = createConversation("Lexical persist thread");
+    const message = await addMessage(conv.id, "user", "hello lexical world");
+
+    const ids = lexicalJobMessageIds();
+    expect(ids).toContain(message.id);
+    expect(ids.filter((id) => id === message.id)).toHaveLength(1);
+  });
+
+  test("lexical job is still enqueued when segment indexing (indexMessageNow) throws", async () => {
+    // The sparse lexical job is independent of the dense embedding path, so a
+    // transient segment-indexing failure must not leave the message missing
+    // from the lexical index. `addMessage` catches the hook throw as non-fatal.
+    throwFromIndex = true;
+    const conv = createConversation("Segment failure thread");
+    const message = await addMessage(
+      conv.id,
+      "user",
+      "index me despite failure",
+    );
+
+    expect(lexicalJobMessageIds()).toContain(message.id);
+  });
+
+  test("addMessage enqueues NO index_message_lexical job when memory is disabled", async () => {
+    setMemoryEnabled(false);
+    const conv = createConversation("Disabled memory thread");
+    await addMessage(conv.id, "user", "should not be lexically indexed");
+
+    expect(countJobs("index_message_lexical")).toBe(0);
+  });
+
+  test("enqueueLexicalIndexForMessage no-ops on an empty message id", () => {
+    enqueueLexicalIndexForMessage("");
+    expect(countJobs("index_message_lexical")).toBe(0);
+  });
+
+  test("forking a conversation enqueues ZERO index_message_lexical jobs", async () => {
+    const source = createConversation("Fork exclusion thread");
+    // Persist source messages through the real path so each enqueues a lexical
+    // job — this makes the "fork adds none" assertion meaningful.
+    await addMessage(source.id, "user", "Draft a launch plan");
+    await addMessage(source.id, "assistant", "Here is a first pass.");
+    await addMessage(source.id, "user", "Fork from here");
+
+    const beforeFork = countJobs("index_message_lexical");
+    expect(beforeFork).toBe(3);
+
+    // The fork copies every source row directly, bypassing onMessagePersisted.
+    const fork = forkConversation({ conversationId: source.id });
+    expect(fork.id).not.toBe(source.id);
+
+    // No new lexical index jobs were enqueued for the copied fork rows.
+    expect(countJobs("index_message_lexical")).toBe(beforeFork);
+    // ...and specifically none of the fork's own message ids were enqueued.
+    const enqueuedMessageIds = new Set(lexicalJobMessageIds());
+    for (const forkMessage of getMessages(fork.id)) {
+      expect(enqueuedMessageIds.has(forkMessage.id)).toBe(false);
+    }
+  });
+
+  test("wipeConversation enqueues a purge_conversation_lexical job for the conversation", async () => {
+    const conv = createConversation("Lexical wipe thread");
+    await addMessage(conv.id, "user", "index me then wipe me");
+
+    resetMemoryJobs();
+    wipeConversation(conv.id);
+
+    expect(countJobs("purge_conversation_lexical", conv.id)).toBe(1);
+  });
+
+  test("deleteConversation (direct, no route) enqueues a purge for the conversation", async () => {
+    // Retrospective startup cleanup calls deleteConversation directly, bypassing
+    // the HTTP route — the purge must still fire from the shared primitive.
+    const conv = createConversation("Direct delete thread");
+    await addMessage(conv.id, "user", "index me then delete me");
+
+    resetMemoryJobs();
+    deleteConversation(conv.id);
+
+    expect(countJobs("purge_conversation_lexical", conv.id)).toBe(1);
+  });
+
+  test("deleteConversationGently (retrospective GC) enqueues a purge for the conversation", async () => {
+    const conv = createConversation("Gentle delete thread");
+    await addMessage(conv.id, "user", "index me then gently delete me");
+
+    resetMemoryJobs();
+    await deleteConversationGently(conv.id);
+
+    expect(countJobs("purge_conversation_lexical", conv.id)).toBe(1);
+  });
+
+  test("deleteMessageById enqueues a delete_message_lexical job for the removed message", async () => {
+    const conv = createConversation("Single delete thread");
+    const message = await addMessage(conv.id, "user", "delete just me");
+
+    resetMemoryJobs();
+    deleteMessageById(message.id);
+
+    const ids = getMemoryDb()!
+      .select({ payload: memoryJobs.payload })
+      .from(memoryJobs)
+      .where(eq(memoryJobs.type, "delete_message_lexical"))
+      .all()
+      .map((r) => (JSON.parse(r.payload) as { messageId?: string }).messageId);
+    expect(ids).toEqual([message.id]);
+  });
+
+  test("deleteMessageById for a nonexistent message enqueues nothing", () => {
+    resetMemoryJobs();
+    deleteMessageById("does-not-exist");
+    expect(countJobs("delete_message_lexical")).toBe(0);
+  });
+
+  test("deleteLastExchange enqueues delete_message_lexical for every removed message", async () => {
+    // Undo bulk-deletes the last user turn + everything after it via a single
+    // `tx.delete(messages)`, bypassing `deleteMessageById`. It must still purge
+    // each removed message's lexical point.
+    const conv = createConversation("Undo thread");
+    await addMessage(conv.id, "user", "first user turn");
+    await addMessage(conv.id, "assistant", "first assistant reply");
+    const lastUser = await addMessage(conv.id, "user", "undo this turn");
+    const lastAssistant = await addMessage(
+      conv.id,
+      "assistant",
+      "and this reply",
+    );
+
+    resetMemoryJobs();
+    const removed = deleteLastExchange(conv.id);
+    expect(removed).toBe(2);
+
+    const deletedIds = getMemoryDb()!
+      .select({ payload: memoryJobs.payload })
+      .from(memoryJobs)
+      .where(eq(memoryJobs.type, "delete_message_lexical"))
+      .all()
+      .map((r) => (JSON.parse(r.payload) as { messageId?: string }).messageId);
+    expect(new Set(deletedIds)).toEqual(
+      new Set([lastUser.id, lastAssistant.id]),
+    );
+  });
+
+  test("updateMessageContent (CRUD primitive) does not enqueue a reindex on its own", async () => {
+    // The reindex is owned by the semantic seams (streaming finalize, edits,
+    // consolidation), NOT the low-level primitive — this keeps mid-stream
+    // partial flushes and tool-timing stamps from spamming reindex jobs.
+    const conv = createConversation("Raw update thread");
+    const message = await addMessage(conv.id, "user", "original text");
+
+    resetMemoryJobs();
+    updateMessageContent(
+      message.id,
+      JSON.stringify([{ type: "text", text: "edited text" }]),
+    );
+
+    expect(countJobs("index_message_lexical")).toBe(0);
+  });
+
+  test("consolidation reindexes the retained message and purges the merged-away rows", async () => {
+    const conv = createConversation("Consolidation thread");
+    const userMsg = await addMessage(conv.id, "user", "do a multi-step task");
+    const retained = await addMessage(
+      conv.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "first assistant segment" }]),
+    );
+    const mergedAway = await addMessage(
+      conv.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "second assistant segment" }]),
+    );
+
+    resetMemoryJobs();
+    const didConsolidate = consolidateAssistantMessages(conv.id, userMsg.id);
+    expect(didConsolidate).toBe(true);
+
+    // The retained (first) assistant row is reindexed with the merged content.
+    expect(lexicalJobMessageIds()).toContain(retained.id);
+    // The merged-away row's point is removed via delete_message_lexical.
+    const deletedIds = getMemoryDb()!
+      .select({ payload: memoryJobs.payload })
+      .from(memoryJobs)
+      .where(eq(memoryJobs.type, "delete_message_lexical"))
+      .all()
+      .map((r) => (JSON.parse(r.payload) as { messageId?: string }).messageId);
+    expect(deletedIds).toContain(mergedAway.id);
+    // The retained row is not itself scheduled for deletion.
+    expect(deletedIds).not.toContain(retained.id);
+  });
+});
+
+// The delete paths must route their cleanup through the persistence-hook seam
+// rather than importing memory internals directly, so persistence stays
+// decoupled from the plugin: single-message deletes fire `onMessagesDeleted`,
+// and whole-conversation deletes fire `onConversationDeleted` from the shared
+// `deleteConversation`/`deleteConversationGently` primitive (covering every
+// caller, not just the HTTP route).
+describe("delete paths route through the persistence-hook seam", () => {
+  const deletedBatches: string[][] = [];
+  const deletedConversations: string[] = [];
+  const spyHooks: MemoryPersistenceHooks = {
+    onMessagePersisted() {},
+    onConversationForked() {},
+    onConversationWiped() {
+      return 0;
+    },
+    onConversationDeleted(id) {
+      deletedConversations.push(id);
+    },
+    onMessagesDeleted(ids) {
+      deletedBatches.push(ids);
+    },
+    async onAllConversationsCleared() {},
+    onWorkerStartup() {},
+    countMemoryBufferLines() {
+      return 0;
+    },
+  };
+
+  beforeEach(() => {
+    resetMemoryJobs();
+    deletedBatches.length = 0;
+    deletedConversations.length = 0;
+    registerMemoryPersistenceHooks(spyHooks);
+  });
+
+  afterEach(() => {
+    // Restore the real memory hooks so later tests are unaffected.
+    registerDefaultPluginPersistenceHooks();
+  });
+
+  test("the spy hook is installed", () => {
+    expect(getMemoryPersistenceHooks()).toBe(spyHooks);
+  });
+
+  test("deleteConversation fires onConversationDeleted (covers all callers, not just the route)", async () => {
+    const conv = createConversation("Seam conversation delete");
+    await addMessage(conv.id, "user", "hello");
+
+    deletedConversations.length = 0;
+    deleteConversation(conv.id);
+
+    expect(deletedConversations).toEqual([conv.id]);
+  });
+
+  test("deleteConversationGently fires onConversationDeleted (the retrospective-GC path)", async () => {
+    const conv = createConversation("Seam gentle delete");
+    await addMessage(conv.id, "user", "hello");
+
+    deletedConversations.length = 0;
+    await deleteConversationGently(conv.id);
+
+    expect(deletedConversations).toEqual([conv.id]);
+  });
+
+  test("deleteMessageById fires onMessagesDeleted with the single id", async () => {
+    const conv = createConversation("Seam single delete");
+    const message = await addMessage(conv.id, "user", "delete me via seam");
+
+    deletedBatches.length = 0;
+    deleteMessageById(message.id);
+
+    expect(deletedBatches).toEqual([[message.id]]);
+  });
+
+  test("deleteLastExchange fires onMessagesDeleted with every removed id", async () => {
+    const conv = createConversation("Seam undo");
+    await addMessage(conv.id, "user", "first turn");
+    await addMessage(conv.id, "assistant", "first reply");
+    const lastUser = await addMessage(conv.id, "user", "undo this");
+    const lastAssistant = await addMessage(conv.id, "assistant", "and this");
+
+    deletedBatches.length = 0;
+    deleteLastExchange(conv.id);
+
+    expect(deletedBatches).toHaveLength(1);
+    expect(new Set(deletedBatches[0])).toEqual(
+      new Set([lastUser.id, lastAssistant.id]),
+    );
+  });
+});