@vellumai/assistant 0.12.2 → 0.12.3-staging.2

package/src/__tests__/cu-unified-flow.test.ts

@@ -5,8 +5,11 @@
  * point between the agent loop and the HostCuProxy.
  */
 
-import { afterEach, describe, expect, mock, test } from "bun:test";
+import { afterEach, describe, expect, mock, spyOn, test } from "bun:test";
 
+import { isSessionGroupsEnabled } from "../config/session-groups-gate.js";
+import { ComputerUseModeSessionProducer } from "../daemon/computer-use-mode-session.js";
+import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
 import { asConversation } from "./helpers/mock-conversation.js";
 
 const sentMessages: unknown[] = [];
@@ -76,6 +79,10 @@ function buildMockContext(
   // attach one (the gate denies, or the context predates the hook).
   ensureHostProxiesForTurn?: () => void,
 ): Conversation {
+  const computerUseModeSessions = {
+    recordAction: () => false,
+    endTask: () => false,
+  } as unknown as Conversation["computerUseModeSessions"];
   const ctx: Conversation = asConversation({
     conversationId: "test-session",
     trustContext:
@@ -105,6 +112,7 @@ function buildMockContext(
     accumulatedSurfaceState: new Map(),
     surfaceActionRequestIds: new Set(),
     currentTurnSurfaces: [],
+    computerUseModeSessions,
     hostCuProxy,
     transportInterface: "web",
     ensureHostProxiesForTurn,
@@ -139,6 +147,7 @@ describe("surfaceProxyResolver — CU tool routing", () => {
   }
 
   afterEach(() => {
+    setOverridesForTesting({});
     proxy?.dispose();
   });
 
@@ -337,6 +346,78 @@ describe("surfaceProxyResolver — CU tool routing", () => {
   // -------------------------------------------------------------------------
 
   describe("action tools proxy to client", () => {
+    test("dispatches without mode-session side effects while session groups are disabled", async () => {
+      setOverridesForTesting({ "session-groups": false });
+      const ctx = setupProxy();
+      ctx.currentRequestId = "turn-123";
+      const activateSource = mock(() => {
+        throw new Error("disabled tracking must not activate a source");
+      });
+      (
+        ctx as unknown as {
+          computerUseModeSessions: Conversation["computerUseModeSessions"];
+        }
+      ).computerUseModeSessions = new ComputerUseModeSessionProducer(
+        {
+          activateSource,
+          beginDraining: mock(() => false),
+          claimTurn: mock(() => undefined),
+          getTurnOwner: mock(() => undefined),
+          recordActivity: mock(() => false),
+          retireSource: mock(() => false),
+        },
+        isSessionGroupsEnabled,
+      );
+
+      const resultPromise = surfaceProxyResolver(ctx, "computer_use_click", {
+        element_id: 42,
+      });
+      const sent = sentMessages[0] as { requestId: string; type: string };
+      expect(sent.type).toBe("host_cu_request");
+      expect(activateSource).not.toHaveBeenCalled();
+
+      proxy.processObservation(sent.requestId, { executionResult: "clicked" });
+      const result = await resultPromise;
+      expect(result.isError).toBe(false);
+    });
+
+    test("dispatches once after tracking admission throws and still cleans up the task", async () => {
+      const ctx = setupProxy();
+      ctx.currentRequestId = "turn-123";
+      const recordAction = spyOn(
+        ctx.computerUseModeSessions,
+        "recordAction",
+      ).mockImplementation(() => {
+        throw new Error("tracking unavailable");
+      });
+      const endTask = spyOn(
+        ctx.computerUseModeSessions,
+        "endTask",
+      ).mockImplementation(() => {
+        throw new Error("tracking unavailable");
+      });
+      try {
+        const resultPromise = surfaceProxyResolver(ctx, "computer_use_click", {
+          element_id: 42,
+        });
+        expect(sentMessages).toHaveLength(1);
+        const sent = sentMessages[0] as { requestId: string };
+        proxy.processObservation(sent.requestId, {
+          executionResult: "clicked",
+        });
+        expect((await resultPromise).isError).toBe(false);
+        expect(recordAction).toHaveBeenCalledTimes(1);
+        expect(
+          (await surfaceProxyResolver(ctx, "computer_use_done", {})).isError,
+        ).toBe(false);
+        expect(endTask).toHaveBeenCalledTimes(1);
+        expect(proxy.stepCount).toBe(0);
+      } finally {
+        recordAction.mockRestore();
+        endTask.mockRestore();
+      }
+    });
+
     test("computer_use_click routes through proxy and returns observation", async () => {
       const ctx = setupProxy();
 

package/src/__tests__/db-conversation-tool-surface.test.ts

@@ -0,0 +1,221 @@
+/**
+ * Tests for the per-conversation wire surface record
+ * (`persistence/conversation-tool-surface.ts`): the send-boundary recorder
+ * stores the tools array a live turn sends with the delegation-section state
+ * its prompt rendered, fork wakes read both back verbatim, and an unchanged
+ * surface is never rewritten.
+ */
+
+import { Database } from "bun:sqlite";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import {
+  getConversationToolSurface as getConversationToolSurfaceViaPluginApi,
+  getRecordedConversationToolSurface,
+} from "../persistence/conversation-plugin-facade.js";
+import {
+  type ConversationToolSurface,
+  getConversationToolSurface,
+  hashConversationToolSurface,
+  recordConversationToolSurface,
+} from "../persistence/conversation-tool-surface.js";
+import { clearStoredDb, setStoredDb } from "../persistence/db-singleton.js";
+import { migrateCreateConversationToolSurfaces } from "../persistence/migrations/378-create-conversation-tool-surfaces.js";
+import { migrateConversationToolSurfacesDelegateIndependentTasks } from "../persistence/migrations/380-conversation-tool-surfaces-delegate-independent-tasks.js";
+import * as schema from "../persistence/schema/index.js";
+import type { ToolDefinition } from "../providers/types.js";
+
+let sqlite: Database;
+
+beforeEach(() => {
+  sqlite = new Database(":memory:");
+  sqlite.run("PRAGMA foreign_keys = ON");
+  sqlite.run(/*sql*/ `CREATE TABLE conversations (id TEXT PRIMARY KEY)`);
+  sqlite.query(`INSERT INTO conversations (id) VALUES (?)`).run("conv-1");
+  const db = drizzle(sqlite, { schema });
+  migrateCreateConversationToolSurfaces(db);
+  migrateConversationToolSurfacesDelegateIndependentTasks(db);
+  setStoredDb("main", db, () => sqlite.close());
+});
+
+afterEach(() => {
+  clearStoredDb("main");
+});
+
+const TOOLS: ToolDefinition[] = [
+  {
+    name: "remember",
+    description: "Save a fact",
+    input_schema: { type: "object", properties: { content: {} } },
+  },
+  { name: "bell_jingle", description: "Ring", input_schema: {} },
+];
+
+const SURFACE: ConversationToolSurface = {
+  tools: TOOLS,
+  delegateIndependentTasks: true,
+};
+
+function storedRow(): { tools_hash: string; updated_at: number } | null {
+  return sqlite
+    .query(
+      `SELECT tools_hash, updated_at FROM conversation_tool_surfaces WHERE conversation_id = ?`,
+    )
+    .get("conv-1") as { tools_hash: string; updated_at: number } | null;
+}
+
+describe("recordConversationToolSurface", () => {
+  test("stores the surface and returns its content hash", () => {
+    const hash = recordConversationToolSurface("conv-1", SURFACE);
+
+    expect(hash).toBe(hashConversationToolSurface(SURFACE));
+    expect(storedRow()?.tools_hash).toBe(hash);
+    expect(getConversationToolSurface("conv-1")).toEqual(SURFACE);
+  });
+
+  test("replays the exact array, including key order and extra fields", () => {
+    const serverTool = {
+      type: "web_search_20250305",
+      name: "web_search",
+      max_uses: 5,
+    } as unknown as ToolDefinition;
+    const tools = [...TOOLS, serverTool];
+
+    recordConversationToolSurface("conv-1", {
+      tools,
+      delegateIndependentTasks: false,
+    });
+
+    expect(JSON.stringify(getConversationToolSurface("conv-1")?.tools)).toBe(
+      JSON.stringify(tools),
+    );
+  });
+
+  test("the delegation-section state round-trips, unknown included", () => {
+    for (const delegateIndependentTasks of [true, false, null]) {
+      recordConversationToolSurface("conv-1", {
+        tools: TOOLS,
+        delegateIndependentTasks,
+      });
+
+      expect(
+        getConversationToolSurface("conv-1")?.delegateIndependentTasks,
+      ).toBe(delegateIndependentTasks);
+    }
+  });
+
+  test("an unchanged surface with a known hash skips the write", () => {
+    const hash = recordConversationToolSurface("conv-1", SURFACE);
+    const before = storedRow()!.updated_at;
+    sqlite
+      .query(
+        `UPDATE conversation_tool_surfaces SET updated_at = ? WHERE conversation_id = ?`,
+      )
+      .run(before - 1000, "conv-1");
+
+    recordConversationToolSurface("conv-1", SURFACE, hash);
+
+    expect(storedRow()!.updated_at).toBe(before - 1000);
+  });
+
+  test("an unchanged surface with no known hash compares against the stored row before writing", () => {
+    recordConversationToolSurface("conv-1", SURFACE);
+    const marker = 42;
+    sqlite
+      .query(
+        `UPDATE conversation_tool_surfaces SET updated_at = ? WHERE conversation_id = ?`,
+      )
+      .run(marker, "conv-1");
+
+    // A freshly loaded conversation knows no hash yet; the stored row matches,
+    // so nothing is rewritten.
+    recordConversationToolSurface("conv-1", SURFACE, undefined);
+
+    expect(storedRow()!.updated_at).toBe(marker);
+  });
+
+  test("a changed array overwrites the stored surface", () => {
+    const first = recordConversationToolSurface("conv-1", SURFACE);
+    const changed = { ...SURFACE, tools: TOOLS.slice(0, 1) };
+
+    const second = recordConversationToolSurface("conv-1", changed, first);
+
+    expect(second).not.toBe(first);
+    expect(storedRow()?.tools_hash).toBe(second);
+    expect(getConversationToolSurface("conv-1")).toEqual(changed);
+  });
+
+  test("a change to the delegation-section state alone overwrites it too", () => {
+    // The state is part of the hash: a turn whose scope flips the section
+    // (a background run's allowlist after an interactive turn) records it.
+    const first = recordConversationToolSurface("conv-1", SURFACE);
+    const changed = { ...SURFACE, delegateIndependentTasks: false };
+
+    const second = recordConversationToolSurface("conv-1", changed, first);
+
+    expect(second).not.toBe(first);
+    expect(storedRow()?.tools_hash).toBe(second);
+    expect(getConversationToolSurface("conv-1")).toEqual(changed);
+  });
+
+  test("a row recorded before the state existed reads unknown and is replaced on the next record", () => {
+    sqlite
+      .query(
+        /*sql*/ `INSERT INTO conversation_tool_surfaces (conversation_id, tools_json, tools_hash, updated_at) VALUES (?, ?, ?, ?)`,
+      )
+      .run("conv-1", JSON.stringify(TOOLS), "pre-upgrade-hash", 1);
+
+    expect(getConversationToolSurface("conv-1")).toEqual({
+      tools: TOOLS,
+      delegateIndependentTasks: null,
+    });
+
+    // The stored hash predates the state, so the next live turn's record
+    // rewrites the row with it.
+    const hash = recordConversationToolSurface("conv-1", SURFACE, undefined);
+
+    expect(storedRow()?.tools_hash).toBe(hash);
+    expect(getConversationToolSurface("conv-1")).toEqual(SURFACE);
+  });
+});
+
+describe("getConversationToolSurface", () => {
+  test("returns null when no turn has recorded a surface", () => {
+    expect(getConversationToolSurface("conv-1")).toBeNull();
+  });
+
+  test("returns null for an unreadable stored payload", () => {
+    sqlite
+      .query(
+        /*sql*/ `INSERT INTO conversation_tool_surfaces (conversation_id, tools_json, tools_hash, updated_at) VALUES (?, ?, ?, ?)`,
+      )
+      .run("conv-1", "not json", "h", 1);
+
+    expect(getConversationToolSurface("conv-1")).toBeNull();
+  });
+
+  test("the row cascades with its conversation", () => {
+    recordConversationToolSurface("conv-1", SURFACE);
+
+    sqlite.query(`DELETE FROM conversations WHERE id = ?`).run("conv-1");
+
+    expect(getConversationToolSurface("conv-1")).toBeNull();
+  });
+});
+
+describe("plugin facade", () => {
+  test("the array accessor is a projection of the recorded surface", async () => {
+    expect(await getConversationToolSurfaceViaPluginApi("conv-1")).toBeNull();
+    expect(await getRecordedConversationToolSurface("conv-1")).toBeNull();
+
+    recordConversationToolSurface("conv-1", SURFACE);
+
+    expect(await getRecordedConversationToolSurface("conv-1")).toEqual(SURFACE);
+    // The array shape the public `@vellumai/plugin-api` accessor returns.
+    expect(await getConversationToolSurfaceViaPluginApi("conv-1")).toEqual(
+      TOOLS,
+    );
+  });
+});

package/src/__tests__/db-mode-sessions-migration.test.ts

@@ -0,0 +1,175 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import {
+  downCreateConversationModeSessions,
+  migrateCreateConversationModeSessions,
+} from "../persistence/migrations/381-create-conversation-mode-sessions.js";
+import * as schema from "../persistence/schema.js";
+
+function createPreMigrationDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec(/* sql */ `
+    PRAGMA foreign_keys = ON;
+    CREATE TABLE conversations (
+      id TEXT PRIMARY KEY
+    );
+  `);
+  return { sqlite, db: drizzle(sqlite, { schema }) };
+}
+
+function tableExists(sqlite: Database): boolean {
+  return (
+    sqlite
+      .query(
+        "SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'conversation_mode_sessions'",
+      )
+      .get() != null
+  );
+}
+
+describe("migration 380: conversation mode sessions", () => {
+  test("creates the table and indexed conversation lookup", () => {
+    const { sqlite, db } = createPreMigrationDb();
+    migrateCreateConversationModeSessions(db);
+
+    expect(tableExists(sqlite)).toBe(true);
+    const indexes = sqlite
+      .query("PRAGMA index_list(conversation_mode_sessions)")
+      .all() as Array<{ name: string }>;
+    expect(indexes.map((index) => index.name)).toContain(
+      "idx_conversation_mode_sessions_conversation_status",
+    );
+  });
+
+  test("is idempotent on an existing migrated database", () => {
+    const { sqlite, db } = createPreMigrationDb();
+    migrateCreateConversationModeSessions(db);
+    expect(() => migrateCreateConversationModeSessions(db)).not.toThrow();
+
+    expect(tableExists(sqlite)).toBe(true);
+  });
+
+  test("supports rollback and reapply", () => {
+    const { sqlite, db } = createPreMigrationDb();
+    migrateCreateConversationModeSessions(db);
+    downCreateConversationModeSessions(db);
+    expect(tableExists(sqlite)).toBe(false);
+
+    migrateCreateConversationModeSessions(db);
+    expect(tableExists(sqlite)).toBe(true);
+  });
+
+  test("enforces status values and deletes rows with their conversation", () => {
+    const { sqlite, db } = createPreMigrationDb();
+    migrateCreateConversationModeSessions(db);
+    sqlite.exec(/* sql */ `
+      INSERT INTO conversations (id) VALUES ('conv-123');
+      INSERT INTO conversation_mode_sessions (
+        id, conversation_id, mode, status, source_started_at, last_activity_at
+      ) VALUES (
+        'session-123', 'conv-123', 'browser', 'active', 100, 100
+      );
+    `);
+
+    expect(() =>
+      sqlite
+        .query(
+          /* sql */ `
+        INSERT INTO conversation_mode_sessions (
+          id, conversation_id, mode, status, source_started_at, last_activity_at
+        ) VALUES (
+          'session-456', 'conv-123', 'browser', 'waiting', 100, 100
+        )
+      `,
+        )
+        .run(),
+    ).toThrow();
+
+    expect(() =>
+      sqlite
+        .query(
+          /* sql */ `
+        INSERT INTO conversation_mode_sessions (
+          id, conversation_id, mode, status, source_started_at, last_activity_at,
+          ended_at, end_reason
+        ) VALUES (
+          'session-completed-without-end', 'conv-123', 'browser', 'completed',
+          100, 100, NULL, 'settled'
+        )
+      `,
+        )
+        .run(),
+    ).toThrow();
+
+    expect(() =>
+      sqlite
+        .query(
+          /* sql */ `
+        INSERT INTO conversation_mode_sessions (
+          id, conversation_id, mode, status, source_started_at, last_activity_at,
+          ended_at, end_reason
+        ) VALUES (
+          'session-empty-reason', 'conv-123', 'browser', 'completed',
+          100, 100, 125, ''
+        )
+      `,
+        )
+        .run(),
+    ).toThrow();
+
+    expect(() =>
+      sqlite
+        .query(
+          /* sql */ `
+        INSERT INTO conversation_mode_sessions (
+          id, conversation_id, mode, status, source_started_at, last_activity_at,
+          ended_at, end_reason
+        ) VALUES (
+          'session-null-reason', 'conv-123', 'browser', 'completed',
+          100, 100, 125, NULL
+        )
+      `,
+        )
+        .run(),
+    ).toThrow();
+
+    expect(() =>
+      sqlite
+        .query(
+          /* sql */ `
+        INSERT INTO conversation_mode_sessions (
+          id, conversation_id, mode, status, source_started_at, last_activity_at,
+          ended_at, end_reason
+        ) VALUES (
+          'session-backwards-end', 'conv-123', 'browser', 'interrupted',
+          100, 150, 125, 'connection_lost'
+        )
+      `,
+        )
+        .run(),
+    ).toThrow();
+
+    expect(() =>
+      sqlite
+        .query(
+          /* sql */ `
+        INSERT INTO conversation_mode_sessions (
+          id, conversation_id, mode, status, source_started_at,
+          first_included_at, last_activity_at
+        ) VALUES (
+          'session-half-boundary', 'conv-123', 'browser', 'active', 100, 110, 110
+        )
+      `,
+        )
+        .run(),
+    ).toThrow();
+
+    sqlite.exec("DELETE FROM conversations WHERE id = 'conv-123'");
+    expect(
+      sqlite.query("SELECT id FROM conversation_mode_sessions").all(),
+    ).toEqual([]);
+  });
+});

package/src/__tests__/deterministic-verification-control-plane.test.ts

@@ -153,6 +153,7 @@ describe("Call session mode metadata", () => {
 
     const { conversationId } = getOrCreateConversation("test-conv-mode");
     const session = createCallSession({
+      direction: "inbound",
       conversationId,
       provider: "twilio",
       fromNumber: "+15551234567",
@@ -181,6 +182,7 @@ describe("Call session mode metadata", () => {
       "test-conv-mode-default",
     );
     const session = createCallSession({
+      direction: "inbound",
       conversationId,
       provider: "twilio",
       fromNumber: "+15551234567",

package/src/__tests__/dm-backfill.test.ts

@@ -11,7 +11,15 @@
  *  - When `backfillDm` throws, the turn proceeds without a crash and
  *    nothing extra is persisted.
  */
-import { beforeEach, describe, expect, mock, test } from "bun:test";
+import {
+  afterAll,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from "bun:test";
 
 // ---------------------------------------------------------------------------
 // Mocks (must precede module imports under test)
@@ -68,6 +76,7 @@ mock.module("../messaging/providers/slack/backfill.js", () => ({
   backfillThread: () => backfillThreadMock(),
 }));
 
+import * as inboundTrustReader from "../calls/inbound-trust-reader.js";
 import {
   loadRawConfig,
   saveRawConfig,
@@ -87,6 +96,15 @@ import {
 
 await initializeDb();
 
+// Backfilled senders are classified by the gateway verdict; with no gateway
+// in the test process the read reports unreachable unless a test says so.
+// A spy rather than mock.module, so the stub does not leak into other files.
+const readInboundTrustMock = spyOn(inboundTrustReader, "readInboundTrust");
+
+afterAll(() => {
+  readInboundTrustMock.mockRestore();
+});
+
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -180,6 +198,8 @@ function readPersistedSlackRows(): Array<{
   provenanceSourceChannel: string | undefined;
   provenanceGuardianExternalUserId: string | undefined;
   provenanceRequesterIdentifier: string | undefined;
+  provenanceContactId: string | undefined;
+  provenanceLookupFailed: boolean | undefined;
   sentAt: number | undefined;
   createdAt: number;
 }> {
@@ -234,6 +254,14 @@ function readPersistedSlackRows(): Array<{
           typeof envelope.provenanceRequesterIdentifier === "string"
             ? envelope.provenanceRequesterIdentifier
             : undefined,
+        provenanceContactId:
+          typeof envelope.provenanceContactId === "string"
+            ? envelope.provenanceContactId
+            : undefined,
+        provenanceLookupFailed:
+          typeof envelope.provenanceLookupFailed === "boolean"
+            ? envelope.provenanceLookupFailed
+            : undefined,
         sentAt:
           typeof envelope.sentAt === "number" ? envelope.sentAt : undefined,
         createdAt: row.createdAt,
@@ -279,6 +307,8 @@ describe("PR 23 — Slack DM cold-start backfill", () => {
     backfillDmMock.mockReset();
     backfillDmMock.mockImplementation(async () => []);
     backfillThreadMock.mockReset();
+    readInboundTrustMock.mockReset();
+    readInboundTrustMock.mockImplementation(async () => ({ ok: false }));
   });
 
   test("first DM in cold conversation triggers backfill exactly once and persists history", async () => {
@@ -335,6 +365,8 @@ describe("PR 23 — Slack DM cold-start backfill", () => {
       expect(meta!.channelId).toBe(SLACK_DM_CHANNEL_ID);
       expect(meta!.actorExternalUserId).toBe(SLACK_DM_USER_ID);
       expect(r.provenanceTrustClass).toBe("unknown");
+      // No gateway in the test process: the lookup failed, and the row says so.
+      expect(r.provenanceLookupFailed).toBe(true);
       expect(r.provenanceSourceChannel).toBe("slack");
       expect(r.provenanceRequesterIdentifier).toBe(SLACK_DM_USER_ID);
       return meta!.channelTs;
@@ -523,6 +555,64 @@ describe("PR 23 — Slack DM cold-start backfill", () => {
     expect(botRow?.provenanceRequesterIdentifier).toBe("B_BOT");
   });
 
+  test("backfilled rows record the sender's gateway trust class and contact id", async () => {
+    readInboundTrustMock.mockImplementation(async (input) =>
+      input.actorExternalId === SLACK_DM_USER_ID
+        ? {
+            ok: true,
+            verdict: {
+              trustClass: "trusted_contact",
+              canonicalSenderId: SLACK_DM_USER_ID,
+              contactId: "contact-dm-user",
+              channelId: "channel-dm-user",
+              status: "active",
+              policy: "allow",
+            },
+            admissionPolicy: null,
+          }
+        : { ok: false },
+    );
+    backfillDmMock.mockImplementation(async () => [
+      makeBackfilledMessage({
+        id: "1700000000.000001",
+        text: "first from member",
+      }),
+      makeBackfilledMessage({
+        id: "1700000000.000002",
+        text: "assistant's own post",
+        sender: { id: "U_BOT", name: "assistant-bot" },
+        metadata: { isBot: true },
+      }),
+      makeBackfilledMessage({
+        id: "1700000000.000003",
+        text: "second from member",
+      }),
+    ]);
+
+    await handleChannelInbound(
+      buildDmRequest("live new DM"),
+      noopProcessMessage,
+      TEST_BEARER_TOKEN,
+    );
+
+    const rows = readPersistedSlackRows();
+    const memberRows = rows.filter((r) => r.role === "user");
+    expect(memberRows.map((r) => r.content).sort()).toEqual([
+      "first from member",
+      "second from member",
+    ]);
+    for (const row of memberRows) {
+      expect(row.provenanceTrustClass).toBe("trusted_contact");
+      expect(row.provenanceContactId).toBe("contact-dm-user");
+      expect(row.provenanceLookupFailed).toBeUndefined();
+    }
+    const ownPost = rows.find((r) => r.role === "assistant");
+    expect(ownPost?.provenanceTrustClass).toBe("unknown");
+    expect(ownPost?.provenanceContactId).toBeUndefined();
+    // One read per distinct sender, the member's rows sharing theirs.
+    expect(readInboundTrustMock).toHaveBeenCalledTimes(2);
+  });
+
   test("skips Slack assistant new-thread placeholder during DM backfill", async () => {
     backfillDmMock.mockImplementation(async () => [
       makeBackfilledMessage({