@vellumai/assistant 0.8.1 → 0.8.2

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

@@ -51,6 +51,34 @@ mock.module("../runtime/gateway-client.js", () => ({
   deliverChannelReply: async () => {},
 }));
 
+type DownloadedSlackFile = {
+  filename: string;
+  mimeType: string;
+  data: string;
+};
+
+const downloadSlackFileMock = mock(
+  async (_file: unknown, _token: string): Promise<DownloadedSlackFile | null> =>
+    null,
+);
+
+mock.module("../messaging/providers/slack/download.js", () => ({
+  downloadSlackFile: (file: unknown, token: string) =>
+    downloadSlackFileMock(file, token),
+}));
+
+mock.module("../messaging/providers/slack/adapter.js", () => ({
+  slackProvider: {
+    resolveConnection: async () => ({}),
+    getThreadRepliesPage: async () => ({ messages: [], hasMore: false }),
+    getHistory: async () => [],
+  },
+  withSlackBotToken: async (
+    _account: string | undefined,
+    fn: (token: string) => Promise<unknown>,
+  ) => fn("test-slack-token"),
+}));
+
 // ---------------------------------------------------------------------------
 // Imports (after mocks)
 // ---------------------------------------------------------------------------
@@ -65,6 +93,7 @@ import {
 import type { MessageRow } from "../memory/conversation-crud.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
+import { recordInbound } from "../memory/delivery-crud.js";
 import type { Message as MessagingMessage } from "../messaging/provider-types.js";
 import * as slackBackfill from "../messaging/providers/slack/backfill.js";
 import {
@@ -122,6 +151,8 @@ const SLACK_CHANNEL_ID = "C0THREAD";
 
 function resetState(): void {
   const db = getDb();
+  db.$client.exec("DELETE FROM message_attachments");
+  db.$client.exec("DELETE FROM attachments");
   db.$client.exec("DELETE FROM messages");
   db.$client.exec("DELETE FROM conversations");
   _backfillTriggerCache.clear();
@@ -129,6 +160,8 @@ function resetState(): void {
   backfillThreadMock.mockImplementation(async () => []);
   backfillDmMock.mockReset();
   backfillDmMock.mockImplementation(async () => []);
+  downloadSlackFileMock.mockReset();
+  downloadSlackFileMock.mockResolvedValue(null);
 }
 
 let convCounter = 0;
@@ -224,11 +257,31 @@ function makeBackfillMessage(
 
 interface PersistedRow {
   role: string;
+  /**
+   * Inner content with any `<external_content …>` wrapper stripped. Most
+   * assertions want to match against the raw text the backfill source
+   * produced; the wrapping is verified separately via {@link rawContent}.
+   */
   content: string;
+  /** Raw persisted content, including any wrapping the daemon applied. */
+  rawContent: string;
   channelTs: string | undefined;
   threadTs: string | undefined;
   displayName: string | undefined;
+  actorExternalUserId: string | undefined;
   slackFiles: Array<{ name: string; mimetype?: string }> | undefined;
+  provenanceTrustClass: string | undefined;
+  provenanceSourceChannel: string | undefined;
+  provenanceGuardianExternalUserId: string | undefined;
+  provenanceRequesterIdentifier: string | undefined;
+}
+
+const EXTERNAL_CONTENT_WRAPPER =
+  /^<external_content[^>]*>\n([\s\S]*?)\n<\/external_content>$/;
+
+function unwrapExternalContent(content: string): string {
+  const match = content.match(EXTERNAL_CONTENT_WRAPPER);
+  return match ? match[1] : content;
 }
 
 function readPersistedSlackRows(conversationId: string): PersistedRow[] {
@@ -237,11 +290,17 @@ function readPersistedSlackRows(conversationId: string): PersistedRow[] {
   for (const row of rows) {
     const blank: PersistedRow = {
       role: row.role,
-      content: row.content,
+      content: unwrapExternalContent(row.content),
+      rawContent: row.content,
       channelTs: undefined,
       threadTs: undefined,
       displayName: undefined,
+      actorExternalUserId: undefined,
       slackFiles: undefined,
+      provenanceTrustClass: undefined,
+      provenanceSourceChannel: undefined,
+      provenanceGuardianExternalUserId: undefined,
+      provenanceRequesterIdentifier: undefined,
     };
     if (!row.metadata) {
       out.push(blank);
@@ -271,14 +330,32 @@ function readPersistedSlackRows(conversationId: string): PersistedRow[] {
     const slackMeta = readSlackMetadata(slackMetaRaw);
     out.push({
       role: row.role,
-      content: row.content,
+      content: unwrapExternalContent(row.content),
+      rawContent: row.content,
       channelTs: slackMeta?.channelTs,
       threadTs: slackMeta?.threadTs,
       displayName: slackMeta?.displayName,
+      actorExternalUserId: slackMeta?.actorExternalUserId,
       slackFiles: slackMeta?.slackFiles?.map((file) => ({
         name: file.name,
         ...(file.mimetype ? { mimetype: file.mimetype } : {}),
       })),
+      provenanceTrustClass:
+        typeof envelope.provenanceTrustClass === "string"
+          ? envelope.provenanceTrustClass
+          : undefined,
+      provenanceSourceChannel:
+        typeof envelope.provenanceSourceChannel === "string"
+          ? envelope.provenanceSourceChannel
+          : undefined,
+      provenanceGuardianExternalUserId:
+        typeof envelope.provenanceGuardianExternalUserId === "string"
+          ? envelope.provenanceGuardianExternalUserId
+          : undefined,
+      provenanceRequesterIdentifier:
+        typeof envelope.provenanceRequesterIdentifier === "string"
+          ? envelope.provenanceRequesterIdentifier
+          : undefined,
     });
   }
   return out;
@@ -828,6 +905,274 @@ describe("triggerSlackThreadBackfillIfNeeded — gap detection and persistence",
     expect(rendered).not.toContain("F-DRAFT");
   });
 
+  test("backfilled Slack image files are persisted as image content blocks", async () => {
+    const conv = createTestConversation();
+
+    seedSlackRow(conv.id, "1234.0", undefined, "parent already here");
+
+    const imageBase64 = Buffer.from("fake image bytes").toString("base64");
+    downloadSlackFileMock.mockResolvedValue({
+      filename: "diagram.png",
+      mimeType: "image/png",
+      data: imageBase64,
+    });
+    backfillThreadMock.mockImplementation(async () => [
+      makeBackfillMessage({
+        id: "1234.1",
+        text: "uploaded the diagram",
+        threadId: "1234.0",
+        sender: { id: "U_IMAGE", name: "Image Sharer" },
+        metadata: {
+          slackFiles: [
+            {
+              id: "F-DIAGRAM",
+              name: "diagram.png",
+              mimetype: "image/png",
+              urlPrivateDownload:
+                "https://files.slack.com/files-pri/T/F/download",
+            },
+          ],
+        },
+      }),
+    ]);
+
+    await triggerSlackThreadBackfillIfNeeded({
+      conversationId: conv.id,
+      channelId: SLACK_CHANNEL_ID,
+      threadTs: "1234.0",
+      excludeChannelTs: "1234.2",
+    });
+
+    expect(downloadSlackFileMock).toHaveBeenCalledTimes(1);
+    expect(downloadSlackFileMock.mock.calls[0]?.[1]).toBe("test-slack-token");
+
+    const imageRow = readMessagesByConversation(conv.id).find((row) =>
+      row.content.includes("uploaded the diagram"),
+    );
+    expect(imageRow).toBeDefined();
+    const blocks = JSON.parse(imageRow!.content) as Message["content"];
+    const textBlock = blocks.find(
+      (block): block is Extract<Message["content"][number], { type: "text" }> =>
+        block.type === "text",
+    );
+    const imageBlock = blocks.find(
+      (
+        block,
+      ): block is Extract<Message["content"][number], { type: "image" }> =>
+        block.type === "image",
+    );
+    expect(textBlock?.text).toBe("uploaded the diagram");
+    expect(textBlock?.text).not.toContain("<external_content");
+    expect(imageBlock?.source.media_type).toBe("image/png");
+    expect(imageBlock?.source.data).toBe(imageBase64);
+
+    const context = loadSlackChronologicalContext(conv.id, SLACK_CHANNEL_CAPS, {
+      loader: readMessageRowsByConversation,
+      trustClass: "guardian",
+    });
+
+    expect(context).not.toBeNull();
+    const contextImage = context!.messages
+      .flatMap((message) => message.content)
+      .find((block) => block.type === "image");
+    expect(contextImage).toBeDefined();
+  });
+
+  test("backfilled bot Slack image files are persisted as user image history", async () => {
+    const conv = createTestConversation();
+
+    seedSlackRow(conv.id, "1234.0", undefined, "parent already here");
+    downloadSlackFileMock.mockResolvedValue({
+      filename: "bot-diagram.png",
+      mimeType: "image/png",
+      data: Buffer.from("bot image bytes").toString("base64"),
+    });
+    backfillThreadMock.mockImplementation(async () => [
+      makeBackfillMessage({
+        id: "1234.1",
+        text: "bot posted a diagram",
+        threadId: "1234.0",
+        sender: { id: "B_IMAGE", name: "Build Bot" },
+        metadata: {
+          isBot: true,
+          slackFiles: [
+            {
+              id: "F-BOT-DIAGRAM",
+              name: "bot-diagram.png",
+              mimetype: "image/png",
+              urlPrivateDownload:
+                "https://files.slack.com/files-pri/T/F/download",
+            },
+          ],
+        },
+      }),
+    ]);
+
+    await triggerSlackThreadBackfillIfNeeded({
+      conversationId: conv.id,
+      channelId: SLACK_CHANNEL_ID,
+      threadTs: "1234.0",
+      excludeChannelTs: "1234.2",
+    });
+
+    expect(downloadSlackFileMock).toHaveBeenCalledTimes(1);
+    const botRow = readMessagesByConversation(conv.id).find((row) =>
+      row.content.includes("bot posted a diagram"),
+    );
+    expect(botRow).toBeDefined();
+    expect(botRow?.role).toBe("user");
+    const blocks = JSON.parse(botRow!.content) as Message["content"];
+    const textBlock = blocks.find(
+      (block): block is Extract<Message["content"][number], { type: "text" }> =>
+        block.type === "text",
+    );
+    const imageBlock = blocks.find(
+      (
+        block,
+      ): block is Extract<Message["content"][number], { type: "image" }> =>
+        block.type === "image",
+    );
+    expect(textBlock?.text).toBe("bot posted a diagram");
+    expect(textBlock?.text).not.toContain("<external_content");
+    expect(imageBlock?.source.media_type).toBe("image/png");
+
+    const context = loadSlackChronologicalContext(conv.id, SLACK_CHANNEL_CAPS, {
+      loader: readMessageRowsByConversation,
+      trustClass: "guardian",
+    });
+
+    expect(context).not.toBeNull();
+    const contextImage = context!.messages
+      .flatMap((message) => message.content)
+      .find((block) => block.type === "image");
+    expect(contextImage).toBeDefined();
+  });
+
+  test("backfilled non-guardian text is persisted raw with actor provenance", async () => {
+    const conv = createTestConversation();
+
+    backfillThreadMock.mockImplementation(async () => [
+      makeBackfillMessage({
+        id: "1234.0",
+        text: "i can't find the credential field",
+        threadId: undefined,
+        sender: { id: "U_ANITA", name: "Anita" },
+      }),
+    ]);
+
+    await triggerSlackThreadBackfillIfNeeded({
+      conversationId: conv.id,
+      channelId: SLACK_CHANNEL_ID,
+      threadTs: "1234.0",
+      guardianExternalUserId: "U_GUARDIAN",
+    });
+
+    const [persisted] = readPersistedSlackRows(conv.id).filter(
+      (p) => p.channelTs === "1234.0",
+    );
+    expect(persisted).toBeDefined();
+    expect(persisted.role).toBe("user");
+    expect(persisted.rawContent).toBe("i can't find the credential field");
+    expect(persisted.rawContent).not.toContain("<external_content");
+    expect(persisted.content).toBe("i can't find the credential field");
+    expect(persisted.actorExternalUserId).toBe("U_ANITA");
+    expect(persisted.provenanceTrustClass).toBe("unknown");
+    expect(persisted.provenanceSourceChannel).toBe("slack");
+    expect(persisted.provenanceGuardianExternalUserId).toBe("U_GUARDIAN");
+    expect(persisted.provenanceRequesterIdentifier).toBe("U_ANITA");
+  });
+
+  test("backfilled guardian-authored text is persisted raw with guardian provenance", async () => {
+    const conv = createTestConversation();
+
+    backfillThreadMock.mockImplementation(async () => [
+      makeBackfillMessage({
+        id: "1234.0",
+        text: "here is the trusted context",
+        threadId: undefined,
+        sender: { id: "U_GUARDIAN", name: "Guardian User" },
+      }),
+    ]);
+
+    await triggerSlackThreadBackfillIfNeeded({
+      conversationId: conv.id,
+      channelId: SLACK_CHANNEL_ID,
+      threadTs: "1234.0",
+      guardianExternalUserId: "U_GUARDIAN",
+    });
+
+    const [persisted] = readPersistedSlackRows(conv.id).filter(
+      (p) => p.channelTs === "1234.0",
+    );
+    expect(persisted).toBeDefined();
+    expect(persisted.role).toBe("user");
+    expect(persisted.rawContent).toBe("here is the trusted context");
+    expect(persisted.rawContent).not.toContain("<external_content");
+    expect(persisted.actorExternalUserId).toBe("U_GUARDIAN");
+    expect(persisted.provenanceTrustClass).toBe("guardian");
+    expect(persisted.provenanceSourceChannel).toBe("slack");
+    expect(persisted.provenanceGuardianExternalUserId).toBe("U_GUARDIAN");
+    expect(persisted.provenanceRequesterIdentifier).toBe("U_GUARDIAN");
+  });
+
+  test("backfilled bot-authored text is persisted raw as user history", async () => {
+    const conv = createTestConversation();
+
+    backfillThreadMock.mockImplementation(async () => [
+      makeBackfillMessage({
+        id: "1234.0",
+        text: "earlier assistant reply",
+        threadId: undefined,
+        sender: { id: "U_BOT", name: "Douglas" },
+        metadata: { isBot: true },
+      }),
+    ]);
+
+    await triggerSlackThreadBackfillIfNeeded({
+      conversationId: conv.id,
+      channelId: SLACK_CHANNEL_ID,
+      threadTs: "1234.0",
+    });
+
+    const [persisted] = readPersistedSlackRows(conv.id).filter(
+      (p) => p.channelTs === "1234.0",
+    );
+    expect(persisted).toBeDefined();
+    expect(persisted.role).toBe("user");
+    expect(persisted.rawContent).toBe("earlier assistant reply");
+    expect(persisted.rawContent).not.toContain("<external_content");
+    expect(persisted.actorExternalUserId).toBe("U_BOT");
+    expect(persisted.provenanceTrustClass).toBe("unknown");
+    expect(persisted.provenanceSourceChannel).toBe("slack");
+    expect(persisted.provenanceRequesterIdentifier).toBe("U_BOT");
+  });
+
+  test("backfilled non-bot message with empty text is persisted unwrapped", async () => {
+    const conv = createTestConversation();
+
+    backfillThreadMock.mockImplementation(async () => [
+      makeBackfillMessage({
+        id: "1234.0",
+        text: "",
+        threadId: undefined,
+        sender: { id: "U_QUIET", name: "Quiet User" },
+      }),
+    ]);
+
+    await triggerSlackThreadBackfillIfNeeded({
+      conversationId: conv.id,
+      channelId: SLACK_CHANNEL_ID,
+      threadTs: "1234.0",
+    });
+
+    const [persisted] = readPersistedSlackRows(conv.id).filter(
+      (p) => p.channelTs === "1234.0",
+    );
+    expect(persisted).toBeDefined();
+    expect(persisted.rawContent).toBe("");
+    expect(persisted.rawContent).not.toContain("<external_content");
+  });
+
   test("latest stored thread message at or after inbound ts skips backfill using parsed Slack timestamps", async () => {
     const conv = createTestConversation();
 
@@ -1313,8 +1658,54 @@ function seedHttpActiveMember(chatId = HTTP_SLACK_CHANNEL_ID): void {
   });
 }
 
+function seedHttpGuardianMember(chatId = HTTP_SLACK_CHANNEL_ID): void {
+  upsertContactChannel({
+    sourceChannel: "slack",
+    externalUserId: HTTP_SLACK_USER_ID,
+    externalChatId: chatId,
+    status: "active",
+    policy: "allow",
+    displayName: HTTP_SLACK_DISPLAY_NAME,
+    role: "guardian",
+    verifiedAt: Date.now(),
+    verifiedVia: "test",
+  });
+}
+
 let httpMsgCounter = 0;
 
+function buildSlackChannelRequest(
+  messageId: string,
+  overrides: Record<string, unknown> = {},
+): Request {
+  httpMsgCounter++;
+  const body: Record<string, unknown> = {
+    sourceChannel: "slack",
+    interface: "slack",
+    conversationExternalId: HTTP_SLACK_CHANNEL_ID,
+    externalMessageId: `${HTTP_SLACK_CHANNEL_ID}:${messageId}:${httpMsgCounter}`,
+    content: "channel text",
+    actorExternalId: HTTP_SLACK_USER_ID,
+    actorDisplayName: HTTP_SLACK_DISPLAY_NAME,
+    actorUsername: "charlie",
+    replyCallbackUrl: "http://localhost:7830/deliver/slack",
+    sourceMetadata: {
+      messageId,
+      chatType: "channel",
+    },
+    ...overrides,
+  };
+
+  return new Request("http://localhost:8080/channels/inbound", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-Gateway-Origin": TEST_BEARER_TOKEN,
+    },
+    body: JSON.stringify(body),
+  });
+}
+
 function buildThreadReplyRequest(
   threadId: string,
   messageId: string,
@@ -1383,12 +1774,14 @@ function buildSlackDmRequest(
 }
 
 interface SlackInboundProcessOptions {
+  displayContent?: string;
   slackRuntimeContextNotice?: string;
   slackInbound?: {
     channelId: string;
     channelTs: string;
     threadTs?: string;
     displayName?: string;
+    actorExternalUserId?: string;
   };
 }
 
@@ -1397,8 +1790,9 @@ function persistSlackInboundFromProcessMessage(
   content: string,
   options?: SlackInboundProcessOptions,
 ): string {
+  const contentToPersist = options?.displayContent ?? content;
   const slackInbound = options?.slackInbound;
-  return insertMessage(conversationId, "user", content, {
+  return insertMessage(conversationId, "user", contentToPersist, {
     ...(slackInbound
       ? {
           slackMeta: writeSlackMetadata({
@@ -1411,6 +1805,9 @@ function persistSlackInboundFromProcessMessage(
             ...(slackInbound.displayName
               ? { displayName: slackInbound.displayName }
               : {}),
+            ...(slackInbound.actorExternalUserId
+              ? { actorExternalUserId: slackInbound.actorExternalUserId }
+              : {}),
             eventKind: "message",
           }),
         }
@@ -1436,6 +1833,77 @@ function flattenText(messages: Message[]): string {
     .join("\n");
 }
 
+interface CapturedSlackProcessMessage {
+  conversationId: string;
+  content: string;
+  attachmentIds?: string[];
+  options?: SlackInboundProcessOptions;
+}
+
+function seedAttachment(id: string): void {
+  getDb()
+    .$client.prepare(
+      `INSERT INTO attachments (
+          id, original_filename, mime_type, size_bytes, kind, data_base64, created_at
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?)`,
+    )
+    .run(
+      id,
+      "attachment.pdf",
+      "application/pdf",
+      Buffer.byteLength("pdf bytes"),
+      "upload",
+      Buffer.from("pdf bytes").toString("base64"),
+      Date.now(),
+    );
+}
+
+async function handleAndCaptureLiveSlackProcessMessage(
+  request: Request,
+): Promise<CapturedSlackProcessMessage> {
+  let captured: CapturedSlackProcessMessage | undefined;
+  let resolveProcessed: (() => void) | undefined;
+  const processed = new Promise<void>((resolve) => {
+    resolveProcessed = resolve;
+  });
+
+  const processMessage = async (
+    conversationId: string,
+    content: string,
+    attachmentIds?: string[],
+    options?: SlackInboundProcessOptions,
+  ): Promise<{ messageId: string }> => {
+    captured = { conversationId, content, attachmentIds, options };
+    const messageId = persistSlackInboundFromProcessMessage(
+      conversationId,
+      content,
+      options,
+    );
+    resolveProcessed?.();
+    return { messageId };
+  };
+  setAdapterProcessMessage(processMessage);
+
+  const resp = await handleChannelInbound(
+    request,
+    processMessage,
+    TEST_BEARER_TOKEN,
+  );
+  expect(resp.status).toBe(200);
+  await Promise.race([
+    processed,
+    new Promise((_, reject) =>
+      setTimeout(() => reject(new Error("processMessage not called")), 250),
+    ),
+  ]);
+
+  if (!captured) {
+    throw new Error("processMessage not called");
+  }
+  return captured;
+}
+
 describe("handleChannelInbound — Slack thread backfill wiring", () => {
   beforeEach(() => {
     resetHttpState();
@@ -1536,14 +2004,76 @@ describe("handleChannelInbound — Slack thread backfill wiring", () => {
     ).toBe(false);
   });
 
+  test("live Slack non-guardian passes raw displayContent while wrapping model content", async () => {
+    const rawContent = "live Slack raw text";
+    const captured = await handleAndCaptureLiveSlackProcessMessage(
+      buildSlackChannelRequest("1700000000.000300", {
+        content: rawContent,
+      }),
+    );
+
+    expect(captured.content.match(/<external_content/g)?.length).toBe(1);
+    expect(captured.content).toContain('<external_content source="slack"');
+    expect(captured.content).not.toContain('source="webhook"');
+    expect(captured.content).toContain(`\n${rawContent}\n</external_content>`);
+    expect(captured.options?.displayContent).toBe(rawContent);
+    expect(captured.options?.slackInbound?.actorExternalUserId).toBe(
+      HTTP_SLACK_USER_ID,
+    );
+
+    const persisted = readMessagesByConversation(captured.conversationId);
+    expect(persisted).toHaveLength(1);
+    expect(persisted[0].content).toBe(rawContent);
+  });
+
+  test("live Slack attachment-only passes empty raw displayContent for persistence", async () => {
+    seedAttachment("att-slack-file");
+
+    const captured = await handleAndCaptureLiveSlackProcessMessage(
+      buildSlackChannelRequest("1700000000.000350", {
+        content: "",
+        attachmentIds: ["att-slack-file"],
+      }),
+    );
+
+    expect(captured.content.match(/<external_content/g)?.length).toBe(1);
+    expect(captured.content).toContain('<external_content source="slack"');
+    expect(captured.content).toContain("\n\n</external_content>");
+    expect(captured.attachmentIds).toEqual(["att-slack-file"]);
+    expect(captured.options?.displayContent).toBe("");
+
+    const persisted = readMessagesByConversation(captured.conversationId);
+    expect(persisted).toHaveLength(1);
+    expect(persisted[0].content).toBe("");
+    expect(persisted[0].content).not.toContain("<external_content");
+  });
+
+  test("live Slack guardian keeps raw content without displayContent", async () => {
+    seedHttpGuardianMember();
+    const rawContent = "guardian live Slack text";
+    const captured = await handleAndCaptureLiveSlackProcessMessage(
+      buildSlackChannelRequest("1700000000.000400", {
+        content: rawContent,
+      }),
+    );
+
+    expect(captured.content).toBe(rawContent);
+    expect(captured.content).not.toContain("<external_content");
+    expect(
+      Object.prototype.hasOwnProperty.call(
+        captured.options ?? {},
+        "displayContent",
+      ),
+    ).toBe(false);
+
+    const persisted = readMessagesByConversation(captured.conversationId);
+    expect(persisted).toHaveLength(1);
+    expect(persisted[0].content).toBe(rawContent);
+  });
+
   test("late app mention sees unseen backfilled replies before the mention", async () => {
     let capturedTranscript = "";
-    let parentTurnSeen = false;
-    let resolveParentTurn: (() => void) | undefined;
     let secondTurnSeen = false;
-    const parentTurnProcessed = new Promise<void>((resolve) => {
-      resolveParentTurn = resolve;
-    });
     let resolveSecondTurn: (() => void) | undefined;
     const secondTurnProcessed = new Promise<void>((resolve) => {
       resolveSecondTurn = resolve;
@@ -1560,10 +2090,6 @@ describe("handleChannelInbound — Slack thread backfill wiring", () => {
         content,
         options,
       );
-      if (options?.slackInbound?.channelTs === "1234.0") {
-        parentTurnSeen = true;
-        resolveParentTurn?.();
-      }
       if (options?.slackInbound?.channelTs === "1234.5") {
         const context = loadSlackChronologicalContext(
           conversationId,
@@ -1581,23 +2107,27 @@ describe("handleChannelInbound — Slack thread backfill wiring", () => {
     };
     setAdapterProcessMessage(processMessage);
 
-    const parentResp = await handleChannelInbound(
-      buildThreadReplyRequest("1234.0", "1234.0", {
-        content: "parent already stored",
-        sourceMetadata: {
-          messageId: "1234.0",
-          chatType: "channel",
+    const parentInbound = recordInbound(
+      "slack",
+      HTTP_SLACK_CHANNEL_ID,
+      `${HTTP_SLACK_CHANNEL_ID}:1234.0:seed`,
+      {
+        sourceMessageId: "1234.0",
+        sourceThreadId: "1234.0",
+      },
+    );
+    persistSlackInboundFromProcessMessage(
+      parentInbound.conversationId,
+      "parent already stored",
+      {
+        slackInbound: {
+          channelId: HTTP_SLACK_CHANNEL_ID,
+          channelTs: "1234.0",
+          threadTs: "1234.0",
+          displayName: HTTP_SLACK_DISPLAY_NAME,
         },
-      }),
-      processMessage,
-      TEST_BEARER_TOKEN,
+      },
     );
-    expect(parentResp.status).toBe(200);
-    await Promise.race([
-      parentTurnProcessed,
-      new Promise((resolve) => setTimeout(resolve, 250)),
-    ]);
-    expect(parentTurnSeen).toBe(true);
 
     backfillThreadMock.mockReset();
     backfillThreadMock.mockImplementation(async () => [