@vellumai/assistant 0.10.3-staging.2 → 0.10.4-staging.1

package/src/__tests__/config-loader-backfill.test.ts

@@ -1426,9 +1426,156 @@ describe("seedInferenceProfiles BYOK-mode managed profile labels", () => {
 
     expect(config.llm.profiles.balanced?.status).toBe("disabled");
     expect(config.llm.profiles["quality-optimized"]?.status).toBe("disabled");
+    expect(config.llm.profiles.frontier?.status).toBe("disabled");
     expect(config.llm.profiles["cost-optimized"]?.status).toBe("disabled");
   });
 
+  test("off-platform BYOK hatch defaults advisor to the personal quality profile", () => {
+    const overlayPath = join(WORKSPACE_DIR, "hatch-overlay.json");
+    writeFileSync(
+      overlayPath,
+      JSON.stringify({ llm: { default: { provider: "anthropic" } } }, null, 2) +
+        "\n",
+    );
+    process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH = overlayPath;
+
+    mergeDefaultConfigAndSeedInferenceProfiles();
+    const config = loadConfig();
+
+    expect(config.llm.activeProfile).toBe("custom-balanced");
+    expect(config.llm.advisorProfile).toBe("custom-quality-optimized");
+    expect(config.llm.profiles["custom-quality-optimized"]?.provider).toBe(
+      "anthropic",
+    );
+    expect(
+      config.llm.profiles["custom-quality-optimized"]?.provider_connection,
+    ).toBe("anthropic-personal");
+    expect(config.llm.profiles.frontier?.status).toBe("disabled");
+  });
+
+  test("off-platform boot repairs a disabled managed advisor to a personal profile when no active managed replacement exists", () => {
+    writeConfig({
+      llm: {
+        advisorProfile: "frontier",
+        profiles: {
+          frontier: {
+            source: "managed",
+            provider: "anthropic",
+            provider_connection: "anthropic-managed",
+            model: "claude-opus-4-8",
+            status: "disabled",
+          },
+          balanced: {
+            source: "managed",
+            provider: "together",
+            provider_connection: "together-managed",
+            model: "open-model",
+            status: "disabled",
+          },
+          "quality-optimized": {
+            source: "managed",
+            provider: "fireworks",
+            provider_connection: "fireworks-managed",
+            model: "accounts/fireworks/models/glm-5p2",
+            status: "disabled",
+          },
+          "cost-optimized": {
+            source: "managed",
+            provider: "fireworks",
+            provider_connection: "fireworks-managed",
+            model: "accounts/fireworks/models/deepseek-v4-flash",
+            status: "disabled",
+          },
+          "custom-quality-optimized": {
+            source: "user",
+            provider: "anthropic",
+            provider_connection: "anthropic-personal",
+            model: "claude-opus-4-8",
+            label: "Quality",
+          },
+        },
+      },
+    });
+
+    mergeDefaultConfigAndSeedInferenceProfiles();
+    const config = loadConfig();
+
+    expect(config.llm.advisorProfile).toBe("custom-quality-optimized");
+  });
+
+  test("platform boot repairs a disabled managed advisor to an active managed profile", () => {
+    process.env.IS_PLATFORM = "true";
+    writeConfig({
+      llm: {
+        advisorProfile: "frontier",
+        profiles: {
+          frontier: {
+            source: "managed",
+            provider: "anthropic",
+            provider_connection: "anthropic-managed",
+            model: "claude-opus-4-8",
+            status: "disabled",
+          },
+          "custom-quality-optimized": {
+            source: "user",
+            provider: "anthropic",
+            provider_connection: "anthropic-personal",
+            model: "claude-opus-4-8",
+            label: "Quality",
+          },
+        },
+      },
+    });
+
+    mergeDefaultConfigAndSeedInferenceProfiles();
+    const config = loadConfig();
+
+    expect(config.llm.advisorProfile).toBe("quality-optimized");
+  });
+
+  test("off-platform boot clears a disabled managed advisor when no active replacement exists", () => {
+    writeConfig({
+      llm: {
+        advisorProfile: "frontier",
+        profiles: {
+          frontier: {
+            source: "managed",
+            provider: "anthropic",
+            provider_connection: "anthropic-managed",
+            model: "claude-opus-4-8",
+            status: "disabled",
+          },
+          balanced: {
+            source: "managed",
+            provider: "together",
+            provider_connection: "together-managed",
+            model: "open-model",
+            status: "disabled",
+          },
+          "quality-optimized": {
+            source: "managed",
+            provider: "fireworks",
+            provider_connection: "fireworks-managed",
+            model: "accounts/fireworks/models/glm-5p2",
+            status: "disabled",
+          },
+          "cost-optimized": {
+            source: "managed",
+            provider: "fireworks",
+            provider_connection: "fireworks-managed",
+            model: "accounts/fireworks/models/deepseek-v4-flash",
+            status: "disabled",
+          },
+        },
+      },
+    });
+
+    mergeDefaultConfigAndSeedInferenceProfiles();
+    const config = loadConfig();
+
+    expect(config.llm.advisorProfile).toBeUndefined();
+  });
+
   test("off-platform managed-inference hatch keeps selected managed connection active", () => {
     const overlayPath = join(WORKSPACE_DIR, "hatch-overlay.json");
     writeFileSync(
@@ -1451,6 +1598,7 @@ describe("seedInferenceProfiles BYOK-mode managed profile labels", () => {
     const raw = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
 
     expect(raw.llm.activeProfile).toBe("balanced");
+    expect(raw.llm.advisorProfile).toBe("balanced");
     expect(raw.llm.profiles.balanced.provider_connection).toBe(
       "together-managed",
     );

package/src/__tests__/consult-deadline.test.ts

@@ -0,0 +1,60 @@
+/**
+ * Tests for `createConsultDeadline` — the advisor consult's progress-aware
+ * timeout. Uses short real timers with generous (>=3x) margins so a streamed
+ * chunk reliably lands inside the idle window without timing flakiness.
+ */
+import { describe, expect, test } from "bun:test";
+
+import { createConsultDeadline } from "../tools/subagent/consult-deadline.js";
+
+const delay = (ms: number): Promise<void> =>
+  new Promise((resolve) => setTimeout(resolve, ms));
+
+describe("createConsultDeadline", () => {
+  test("streamed progress keeps the consult alive past the idle window", async () => {
+    // Record progress every 25ms against a 150ms idle window (6x margin). Each
+    // chunk resets the window, so it must never abort over ~200ms of streaming.
+    const d = createConsultDeadline({ idleMs: 150, maxMs: 10_000 });
+    try {
+      for (let i = 0; i < 8; i++) {
+        await delay(25);
+        expect(d.signal.aborted).toBe(false);
+        d.recordProgress();
+      }
+    } finally {
+      d.dispose();
+    }
+  });
+
+  test("aborts after the idle window once progress stops", async () => {
+    const d = createConsultDeadline({ idleMs: 50, maxMs: 10_000 });
+    try {
+      expect(d.signal.aborted).toBe(false);
+      await delay(250); // 5x the idle window with no progress
+      expect(d.signal.aborted).toBe(true);
+    } finally {
+      d.dispose();
+    }
+  });
+
+  test("aborts at the absolute max even under steady progress", async () => {
+    // Idle window can't fire (huge); the short max must, despite steady chunks.
+    const d = createConsultDeadline({ idleMs: 10_000, maxMs: 70 });
+    try {
+      for (let i = 0; i < 8; i++) {
+        await delay(25);
+        d.recordProgress();
+      }
+      expect(d.signal.aborted).toBe(true); // ~200ms elapsed > 70ms max
+    } finally {
+      d.dispose();
+    }
+  });
+
+  test("dispose() cancels both timers — no late abort", async () => {
+    const d = createConsultDeadline({ idleMs: 40, maxMs: 40 });
+    d.dispose();
+    await delay(150); // well past both windows
+    expect(d.signal.aborted).toBe(false);
+  });
+});

package/src/__tests__/contact-store-interaction-info.test.ts

@@ -0,0 +1,156 @@
+/**
+ * INFO telemetry (interactionCount/lastInteraction/lastSeenAt) is local, not
+ * ACL: the gateway's handle-inbound mirror writes it to the assistant DB, and
+ * model-facing turn context reads it back. These tests assert the daemon-native
+ * read paths (getContact / searchContacts) re-hydrate and aggregate it.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import {
+  findContactInfoById,
+  getContact,
+  searchContacts,
+} from "../contacts/contact-store.js";
+import { getSqlite } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+
+await initializeDb();
+
+function resetContactTables(): void {
+  const sqlite = getSqlite();
+  sqlite.run("DELETE FROM contact_channels");
+  sqlite.run("DELETE FROM contacts");
+}
+
+function insertContact(id: string, displayName: string): void {
+  const now = Date.now();
+  getSqlite().run(
+    "INSERT INTO contacts (id, display_name, role, contact_type, user_file, created_at, updated_at) VALUES (?, ?, 'contact', 'human', ?, ?, ?)",
+    [id, displayName, `${id}.md`, now, now],
+  );
+}
+
+function insertChannel(params: {
+  id: string;
+  contactId: string;
+  type: string;
+  address: string;
+  interactionCount: number;
+  lastInteraction: number | null;
+  lastSeenAt?: number | null;
+}): void {
+  const now = Date.now();
+  getSqlite().run(
+    "INSERT INTO contact_channels (id, contact_id, type, address, is_primary, interaction_count, last_interaction, last_seen_at, created_at, updated_at) VALUES (?, ?, ?, ?, 0, ?, ?, ?, ?, ?)",
+    [
+      params.id,
+      params.contactId,
+      params.type,
+      params.address,
+      params.interactionCount,
+      params.lastInteraction,
+      params.lastSeenAt ?? null,
+      now,
+      now,
+    ],
+  );
+}
+
+describe("contact interaction INFO aggregation", () => {
+  beforeEach(() => {
+    resetContactTables();
+  });
+
+  test("getContact sums interaction_count and takes the latest last_interaction across channels", () => {
+    insertContact("ct_1", "Alice");
+    insertChannel({
+      id: "ch_a",
+      contactId: "ct_1",
+      type: "phone",
+      address: "+15550100",
+      interactionCount: 3,
+      lastInteraction: 1900,
+      lastSeenAt: 1850,
+    });
+    insertChannel({
+      id: "ch_b",
+      contactId: "ct_1",
+      type: "email",
+      address: "alice@example.com",
+      interactionCount: 4,
+      lastInteraction: 2100,
+      lastSeenAt: 2050,
+    });
+
+    const contact = getContact("ct_1");
+    expect(contact).not.toBeNull();
+    expect(contact!.interactionCount).toBe(7);
+    expect(contact!.lastInteraction).toBe(2100);
+
+    // Per-channel INFO is hydrated too.
+    const phone = contact!.channels.find((c) => c.type === "phone");
+    expect(phone?.interactionCount).toBe(3);
+    expect(phone?.lastInteraction).toBe(1900);
+    expect(phone?.lastSeenAt).toBe(1850);
+  });
+
+  test("findContactInfoById surfaces the real interaction count", () => {
+    insertContact("ct_2", "Bob");
+    insertChannel({
+      id: "ch_c",
+      contactId: "ct_2",
+      type: "phone",
+      address: "+15550200",
+      interactionCount: 5,
+      lastInteraction: 1000,
+    });
+
+    const info = findContactInfoById("ct_2");
+    expect(info?.interactionCount).toBe(5);
+  });
+
+  test("lastInteraction is null when no channel has interacted", () => {
+    insertContact("ct_3", "Carol");
+    insertChannel({
+      id: "ch_d",
+      contactId: "ct_3",
+      type: "phone",
+      address: "+15550300",
+      interactionCount: 0,
+      lastInteraction: null,
+    });
+
+    const contact = getContact("ct_3");
+    expect(contact!.interactionCount).toBe(0);
+    expect(contact!.lastInteraction).toBeNull();
+  });
+
+  test("filtered searchContacts carries channel INFO fields", () => {
+    insertContact("ct_4", "Dana");
+    insertChannel({
+      id: "ch_e",
+      contactId: "ct_4",
+      type: "phone",
+      address: "+15550400",
+      interactionCount: 9,
+      lastInteraction: 3000,
+      lastSeenAt: 2900,
+    });
+
+    const results = searchContacts({ query: "Dana", limit: 10 });
+    expect(results).toHaveLength(1);
+    expect(results[0].interactionCount).toBe(9);
+    expect(results[0].lastInteraction).toBe(3000);
+    const ch = results[0].channels[0];
+    expect(ch.interactionCount).toBe(9);
+    expect(ch.lastSeenAt).toBe(2900);
+  });
+});

package/src/__tests__/contact-store-user-file.test.ts

@@ -66,11 +66,10 @@ describe("upsertContact user_file selection", () => {
     resetContactTables();
   });
 
-  test("reuses an existing sibling's userFile when principalId matches", () => {
+  test("assigns a fresh slug per contact; principalId is gateway-owned and no longer groups siblings locally", () => {
     const primary = upsertContact({
       displayName: "Chris",
       role: "guardian",
-      principalId: "principal-abc",
       channels: [
         {
           type: "vellum",
@@ -80,12 +79,12 @@ describe("upsertContact user_file selection", () => {
     });
     expect(primary.userFile).toBe("chris.md");
 
-    // Second contact for the same principal on Slack — must inherit the
-    // first contact's userFile, NOT auto-increment to chris-2.md.
+    // A second contact with the same display name no longer inherits the
+    // first's userFile via a local principal lookup — it gets a fresh
+    // (collision-incremented) slug. Sibling grouping is owned by the gateway.
     const slack = upsertContact({
       displayName: "chris",
       role: "guardian",
-      principalId: "principal-abc",
       channels: [
         {
           type: "slack",
@@ -94,15 +93,14 @@ describe("upsertContact user_file selection", () => {
         },
       ],
     });
-    expect(slack.userFile).toBe("chris.md");
+    expect(slack.userFile).toBe("chris-2.md");
     expect(slack.id).not.toBe(primary.id);
   });
 
-  test("falls back to generateUserFileSlug when principalId has no existing sibling", () => {
+  test("generates a slug from the display name for a brand-new contact", () => {
     const contact = upsertContact({
       displayName: "Alice",
       role: "contact",
-      principalId: "principal-alone",
       channels: [
         {
           type: "slack",
@@ -141,7 +139,7 @@ describe("upsertContact user_file selection", () => {
     expect(second.userFile).toBe("bob-2.md");
   });
 
-  test("ignores a sibling whose userFile is null and generates a new slug", () => {
+  test("a null-userFile contact does not block a fresh slug for a new contact", () => {
     insertContact({
       id: "seed-null",
       displayName: "legacy",
@@ -154,7 +152,6 @@ describe("upsertContact user_file selection", () => {
     const contact = upsertContact({
       displayName: "Legacy",
       role: "guardian",
-      principalId: "principal-null",
       channels: [
         {
           type: "phone",

package/src/__tests__/contacts-relay-reads.test.ts

@@ -63,19 +63,18 @@ const realContactStore = await import("../contacts/contact-store.js");
 // contactType is filtered in SQL (before the limit) rather than relayed.
 const listContactsArgs: Array<{
   limit?: number;
-  role?: string;
   contactType?: string;
 }> = [];
 mock.module("../contacts/contact-store.js", () => ({
   ...realContactStore,
-  listContacts: (limit?: number, role?: string, contactType?: string) => {
+  listContacts: (limit?: number, contactType?: string) => {
     localCalls.push("listContacts");
-    listContactsArgs.push({ limit, role, contactType });
+    listContactsArgs.push({ limit, contactType });
     return [
       {
         id: "local-1",
         displayName: "Local Contact",
-        role: role ?? "contact",
+        role: "contact",
         contactType: contactType ?? "human",
         interactionCount: 0,
         channels: [],
@@ -248,20 +247,18 @@ describe("handleListContacts relay", () => {
     // contactType + limit are pushed into the SQL-filtered daemon read (the
     // daemon-native listContacts filters contactType BEFORE applying limit).
     expect(listContactsArgs).toEqual([
-      { limit: 50, role: undefined, contactType: "assistant" },
+      { limit: 50, contactType: "assistant" },
     ]);
     expect(result.contacts[0].id).toBe("local-1");
     expect(result.contacts[0].contactType).toBe("assistant");
     expect(debugLogs.some((m) => m.includes("daemon-native"))).toBe(true);
   });
 
-  test("contactType + role both flow into the daemon-native read", async () => {
+  test("contactType filters daemon-native; role is gateway-owned and no longer a local predicate", async () => {
     await handleListContacts({ contactType: "human", role: "guardian" });
 
     expect(ipcCalls).toEqual([]);
-    expect(listContactsArgs).toEqual([
-      { limit: 50, role: "guardian", contactType: "human" },
-    ]);
+    expect(listContactsArgs).toEqual([{ limit: 50, contactType: "human" }]);
   });
 });
 

package/src/__tests__/contacts-write.test.ts

@@ -63,8 +63,6 @@ describe("guardian persona seeding and trust-cache invariants", () => {
       externalUserId: "Bob",
       externalChatId: "chat-bob",
       displayName: "Bob",
-      role: "contact",
-      status: "active",
     });
 
     expect(result).not.toBeNull();

package/src/__tests__/conversation-agent-loop-overflow.test.ts

@@ -257,8 +257,8 @@ mock.module("../plugins/defaults/compaction/overflow-policy.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
-    setConversationProcessingStartedAt: () => {},
-    isConversationProcessing: () => false,
+  setConversationProcessingStartedAt: () => {},
+  isConversationProcessing: () => false,
   setConversationOriginChannelIfUnset: () => {},
   setConversationHistoryStrippedAt: () => {},
   updateConversationUsage: () => {},
@@ -289,6 +289,8 @@ mock.module("../memory/conversation-crud.js", () => ({
   getLastUserTimestampBefore: () => 0,
   resolveOverrideProfile: () => undefined,
   reserveMessage: mock(async () => ({ id: "msg-reserve" })),
+  recordConversationPersistedSeq: () => {},
+  getConversationPersistedSeq: () => null,
 }));
 
 afterAll(() => {

package/src/__tests__/conversation-agent-loop.test.ts

@@ -278,6 +278,7 @@ const deleteMessageByIdMock = mock(() => ({
 }));
 const reserveMessageMock = mock(async () => ({ id: "msg-reserve" }));
 const updateMessageContentMock = mock(() => {});
+const addMessageMock = mock(() => ({ id: "mock-msg-id" }));
 mock.module("../memory/conversation-crud.js", () => ({
   setConversationProcessingStartedAt: () => {},
   isConversationProcessing: () => false,
@@ -292,7 +293,7 @@ mock.module("../memory/conversation-crud.js", () => ({
     trustContext: undefined,
   }),
   getConversationOriginInterface: () => null,
-  addMessage: () => ({ id: "mock-msg-id" }),
+  addMessage: addMessageMock,
   deleteMessageById: deleteMessageByIdMock,
   updateConversationContextWindow: () => {},
   updateConversationSlackContextWatermark:
@@ -303,6 +304,8 @@ mock.module("../memory/conversation-crud.js", () => ({
   getLastUserTimestampBefore: () => 0,
   reserveMessage: reserveMessageMock,
   updateMessageContent: updateMessageContentMock,
+  recordConversationPersistedSeq: () => {},
+  getConversationPersistedSeq: () => null,
   // The real schema is a Zod object; tests don't exercise validation,
   // so a passthrough is sufficient — the production code at
   // `handleMessageComplete` only branches on `success` and reads two
@@ -558,13 +561,16 @@ mock.module("../workspace/git-service.js", () => ({
   }),
 }));
 
+let mockConversationErrorClassification = {
+  code: "CONVERSATION_PROCESSING_FAILED",
+  userMessage: "Something went wrong processing your message.",
+  retryable: false,
+  errorCategory: "processing_failed",
+};
+
 mock.module("../daemon/conversation-error.js", () => ({
-  classifyConversationError: (_err: unknown, _ctx: unknown) => ({
-    code: "CONVERSATION_PROCESSING_FAILED",
-    userMessage: "Something went wrong processing your message.",
-    retryable: false,
-    errorCategory: "processing_failed",
-  }),
+  classifyConversationError: (_err: unknown, _ctx: unknown) =>
+    mockConversationErrorClassification,
   isUserCancellation: (err: unknown, ctx: { aborted?: boolean }) => {
     if (!ctx.aborted) return false;
     if (err instanceof DOMException && err.name === "AbortError") return true;
@@ -870,6 +876,13 @@ beforeEach(() => {
   deleteMessageByIdMock.mockClear();
   reserveMessageMock.mockClear();
   updateMessageContentMock.mockClear();
+  addMessageMock.mockClear();
+  mockConversationErrorClassification = {
+    code: "CONVERSATION_PROCESSING_FAILED",
+    userMessage: "Something went wrong processing your message.",
+    retryable: false,
+    errorCategory: "processing_failed",
+  };
   indexMessageNowMock.mockClear();
   projectAssistantMessageMock.mockClear();
   publishSyncInvalidationMock.mockClear();
@@ -2239,6 +2252,49 @@ describe("session-agent-loop", () => {
       expect(backfillCall[0]).toBe("test-conv");
       expect(backfillCall[1]).toBe("mock-msg-id");
     });
+
+    test("does not persist managed credential refresh failures as assistant text", async () => {
+      mockConversationErrorClassification = {
+        code: "MANAGED_KEY_INVALID",
+        userMessage: "Couldn't refresh assistant credentials.",
+        retryable: false,
+        errorCategory: "managed_key_invalid",
+      };
+      const events: ServerMessage[] = [];
+
+      const ctx = makeCtx({
+        loopProvider: {
+          name: "mock-provider",
+          async sendMessage() {
+            throw new Error("API key has expired.");
+          },
+        } as unknown as Provider,
+      });
+      await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
+
+      expect(
+        events.filter((event) => event.type === "assistant_text_delta"),
+      ).toHaveLength(0);
+
+      const conversationError = events.find(
+        (event) => event.type === "conversation_error",
+      );
+      expect(conversationError).toBeDefined();
+      expect(conversationError).toMatchObject({
+        code: "MANAGED_KEY_INVALID",
+        userMessage: "Couldn't refresh assistant credentials.",
+        errorCategory: "managed_key_invalid",
+      });
+
+      expect(addMessageMock).not.toHaveBeenCalled();
+      expect(recordRequestLogMock).not.toHaveBeenCalled();
+      expect(backfillMessageIdOnLogsMock).not.toHaveBeenCalled();
+      expect(deleteMessageByIdMock).toHaveBeenCalledTimes(1);
+      const deleteCall = deleteMessageByIdMock.mock.calls[0] as unknown as [
+        string,
+      ];
+      expect(deleteCall[0]).toBe("msg-reserve");
+    });
   });
 
   describe("B3 pre-allocation: indexing + cleanup", () => {
@@ -2450,6 +2506,41 @@ describe("session-agent-loop", () => {
       expect(lastSync?.[1]).toBe("mock-msg-id");
       expect(lastSync?.[1]).not.toBe("msg-orphaned-reservation");
     });
+
+    test("managed-key provider-error cleanup publishes message invalidation after deleting the reservation", async () => {
+      reserveMessageMock.mockImplementationOnce(async () => ({
+        id: "msg-managed-key-reservation",
+      }));
+      mockConversationErrorClassification = {
+        code: "MANAGED_KEY_INVALID",
+        userMessage: "Couldn't refresh assistant credentials.",
+        retryable: false,
+        errorCategory: "managed_key_invalid",
+      };
+
+      const ctx = makeCtx({
+        loopProvider: {
+          name: "mock-provider",
+          async sendMessage() {
+            throw new Error("API key has expired.");
+          },
+        } as unknown as Provider,
+      });
+      await runAgentLoopImpl(ctx, "hi", "msg-1", () => {});
+
+      expect(deleteMessageByIdMock).toHaveBeenCalledTimes(1);
+      const deleteCall = deleteMessageByIdMock.mock.calls[0] as unknown as [
+        string,
+      ];
+      expect(deleteCall[0]).toBe("msg-managed-key-reservation");
+      expect(addMessageMock).not.toHaveBeenCalled();
+      expect(syncMessageToDiskMock).not.toHaveBeenCalled();
+
+      const messagePublishes = (
+        publishSyncInvalidationMock.mock.calls as unknown as Array<[string[]]>
+      ).filter((args) => args[0]?.includes("conversation:test-conv:messages"));
+      expect(messagePublishes).toHaveLength(1);
+    });
   });
 
   describe("partial persistence", () => {