@vellumai/assistant 0.11.4 → 0.11.5-staging.2

package/src/runtime/routes/identity-routes.ts

@@ -19,6 +19,7 @@ import {
   getContainerMemoryLimitBytes,
   getContainerMemoryUsageBytes,
 } from "../../util/cgroup-memory.js";
+import { getCachedContainerCpuPercent } from "../../util/container-cpu-sampler.js";
 import { getDiskUsageInfo } from "../../util/disk-usage.js";
 import { getWorkspacePromptPath } from "../../util/platform.js";
 import { APP_VERSION } from "../../version.js";
@@ -93,128 +94,11 @@ interface CpuInfo {
   maxCores: number;
 }
 
-/**
- * Read the container's CPU usage from cgroup accounting files.
- *
- * Returns total CPU microseconds consumed by the container since boot.
- * We use the delta between two samples to compute percentage.
- */
-function getContainerCpuUsageUs(): number | null {
-  // cgroups v2: cpu.stat has a "usage_usec" line.
-  try {
-    const stat = readFileSync("/sys/fs/cgroup/cpu.stat", "utf-8");
-    for (const line of stat.split("\n")) {
-      if (line.startsWith("usage_usec")) {
-        const val = parseInt(line.split(/\s+/)[1], 10);
-        if (!isNaN(val) && val > 0) {
-          return val;
-        }
-      }
-    }
-  } catch {
-    /* not available */
-  }
-
-  // cgroups v1: cpuacct.usage is in nanoseconds.
-  try {
-    const ns = parseInt(
-      readFileSync("/sys/fs/cgroup/cpuacct/cpuacct.usage", "utf-8").trim(),
-      10,
-    );
-    if (!isNaN(ns) && ns > 0) {
-      return ns / 1000;
-    } // convert ns → µs
-  } catch {
-    /* not available */
-  }
-
-  return null;
-}
-
-// Track CPU usage over a rolling window so /v1/health reports near-real-time
-// utilization instead of a lifetime average (total CPU time / total uptime).
-const CPU_SAMPLE_INTERVAL_MS = 5_000;
-
-/**
- * Sample this process's cumulative CPU time, returning null when the
- * underlying syscall fails (mirroring {@link sampleProcessRssBytes}).
- */
-function sampleProcessCpuUsage(): NodeJS.CpuUsage | null {
-  try {
-    return process.cpuUsage();
-  } catch {
-    return null;
-  }
-}
-
-let _lastProcessCpuUsage: NodeJS.CpuUsage | null = sampleProcessCpuUsage();
-let _lastCgroupCpuUs: number | null = getContainerCpuUsageUs();
-let _lastCpuTime: number = Date.now();
-let _cachedCpuPercent = 0;
-
-// Kick off the background sampler. unref() so it never prevents process exit.
-setInterval(() => {
-  const now = Date.now();
-  const elapsedMs = now - _lastCpuTime;
-  if (elapsedMs <= 0) {
-    return;
-  }
-
-  const numCores = getContainerCpuCores();
-  if (numCores <= 0) {
-    _lastCpuTime = now;
-    return;
-  }
-
-  // Always sample process-level CPU so the baseline stays fresh. This
-  // prevents a spike if the platform cgroup path later falls back to
-  // process.cpuUsage() after cgroup stats were previously available.
-  const newProcessUsage = sampleProcessCpuUsage();
-  const processDeltaUs =
-    newProcessUsage !== null && _lastProcessCpuUsage !== null
-      ? newProcessUsage.user -
-        _lastProcessCpuUsage.user +
-        (newProcessUsage.system - _lastProcessCpuUsage.system)
-      : null;
-  if (newProcessUsage !== null) {
-    _lastProcessCpuUsage = newProcessUsage;
-  }
-
-  if (getIsPlatform()) {
-    // In platform mode, prefer cgroup-level CPU usage so we see the full
-    // container footprint, not just this process.
-    const cgroupUs = getContainerCpuUsageUs();
-    if (cgroupUs !== null && _lastCgroupCpuUs !== null) {
-      const deltaCpuUs = cgroupUs - _lastCgroupCpuUs;
-      const deltaCpuMs = deltaCpuUs / 1000;
-      _cachedCpuPercent =
-        Math.round((deltaCpuMs / (elapsedMs * numCores)) * 10000) / 100;
-    } else if (processDeltaUs !== null) {
-      // cgroup CPU stats unavailable (e.g. gVisor) – fall back to process-level.
-      const deltaCpuMs = processDeltaUs / 1000;
-      _cachedCpuPercent =
-        Math.round((deltaCpuMs / (elapsedMs * numCores)) * 10000) / 100;
-    }
-    _lastCgroupCpuUs = cgroupUs;
-  } else if (processDeltaUs !== null) {
-    // Non-platform: use process.cpuUsage() (accurate for single-process mode).
-    const deltaCpuMs = processDeltaUs / 1000;
-    _cachedCpuPercent =
-      Math.round((deltaCpuMs / (elapsedMs * numCores)) * 10000) / 100;
-  }
-
-  _lastCpuTime = now;
-}, CPU_SAMPLE_INTERVAL_MS).unref();
-
 function getCpuInfo(): CpuInfo {
-  try {
-    return {
-      currentPercent: _cachedCpuPercent,
-      maxCores: Math.ceil(getContainerCpuCores()),
-    };
-  } catch {
-    return { currentPercent: 0, maxCores: 0 };
-  }
+  return {
+    currentPercent: getCachedContainerCpuPercent(),
+    maxCores: Math.ceil(getContainerCpuCores()),
+  };
 }
 
 /**

package/src/runtime/routes/inbound-message-handler.ts

@@ -17,6 +17,7 @@ import {
   attachmentsToContentBlocks,
   type MessageAttachmentInput,
 } from "../../agent/attachments.js";
+import { audienceForReader } from "../../channels/message-audience.js";
 import {
   CHANNEL_IDS,
   INTERFACE_IDS,
@@ -42,6 +43,7 @@ import { mapChatTypeToConversationType } from "../../daemon/trust-context.js";
 import type { TrustContext } from "../../daemon/trust-context-types.js";
 import { HeartbeatService } from "../../heartbeat/heartbeat-service.js";
 import type { Message as ProviderMessage } from "../../messaging/provider-types.js";
+import { editChannelMessage } from "../../messaging/providers/index.js";
 import {
   resolveSlackBotUserId,
   withSlackBotToken,
@@ -77,7 +79,7 @@ import {
   addMessage,
   getMessageById,
   getMessages,
-  selectSlackMetaCandidateMetadata,
+  selectProviderMetaCandidateMetadata,
   updateMessageContent,
   updateMessageMetadata,
 } from "../../persistence/conversation-crud.js";
@@ -90,6 +92,7 @@ import {
 import { markProcessed } from "../../persistence/delivery-status.js";
 import { upsertBinding } from "../../persistence/external-conversation-store.js";
 import type { ContentBlock } from "../../providers/types.js";
+import { checkIngressForSecrets } from "../../security/secret-ingress.js";
 import { canonicalizeInboundIdentity } from "../../util/canonicalize-identity.js";
 import { getLogger } from "../../util/logger.js";
 import { truncate } from "../../util/truncate.js";
@@ -417,9 +420,10 @@ export async function handleChannelInbound({
   // 👍 never triggers a verification handshake or an access-request
   // notification, and a stranger's reaction creates no conversation/binding.
   // The interceptor drops strangers, records known contacts' reactions as
-  // transcript signals, and routes a guardian's reaction on an approval card
-  // through the guardian decision pipeline. Reactions never drive an
-  // agent turn.
+  // transcript signals in the conversation of the reacted message, and routes
+  // a guardian's reaction on an approval card through the guardian decision
+  // pipeline. Reactions never mint a conversation and never drive an agent
+  // turn.
   if (isSlackReactionEvent(body)) {
     return handleSlackReactionIntercept({
       callbackData: body.callbackData!,
@@ -433,7 +437,6 @@ export async function handleChannelInbound({
       actorUsername: body.actorUsername,
       replyCallbackUrl: body.replyCallbackUrl,
       sourceMetadata: body.sourceMetadata,
-      slackChannelName,
       approvalConversationGenerator,
     });
   }
@@ -907,10 +910,11 @@ export async function handleChannelInbound({
         text: replyText,
         assistantId: DAEMON_INTERNAL_ASSISTANT_ID,
       };
-      if (sourceChannel === "slack" && (canonicalSenderId ?? rawSenderId)) {
-        replyPayload.ephemeral = true;
-        replyPayload.user = (canonicalSenderId ?? rawSenderId)!;
-      }
+      replyPayload.audience = audienceForReader(
+        sourceChannel,
+        conversationExternalId,
+        canonicalSenderId ?? rawSenderId,
+      );
       try {
         await deliverChannelReply(replyCallbackUrl, replyPayload);
         replyDelivered = true;
@@ -969,10 +973,11 @@ export async function handleChannelInbound({
         text: DISK_PRESSURE_REMOTE_BLOCK_REPLY,
         assistantId: DAEMON_INTERNAL_ASSISTANT_ID,
       };
-      if (sourceChannel === "slack" && (canonicalSenderId ?? rawSenderId)) {
-        replyPayload.ephemeral = true;
-        replyPayload.user = (canonicalSenderId ?? rawSenderId)!;
-      }
+      replyPayload.audience = audienceForReader(
+        sourceChannel,
+        conversationExternalId,
+        canonicalSenderId ?? rawSenderId,
+      );
       try {
         await deliverChannelReply(replyCallbackUrl, replyPayload);
       } catch (err) {
@@ -1189,15 +1194,16 @@ export async function handleChannelInbound({
         }
       }
 
-      // On Slack, edit the original approval message to remove stale buttons
-      // and deliver an ephemeral error so the user gets visible feedback
+      // Edit the original approval message to remove stale buttons
+      // and reply so the user gets visible feedback
       // instead of a silent no-op (JARVIS-299).
-      if (sourceChannel === "slack" && replyCallbackUrl && approvalMessageTs) {
-        deliverChannelReply(replyCallbackUrl, {
+      // No channel check: a transport without `edit` declines the call, so a
+      // channel gains this the moment it can revise a sent message.
+      if (replyCallbackUrl && approvalMessageTs) {
+        editChannelMessage(replyCallbackUrl, {
           chatId: conversationExternalId,
+          messageId: approvalMessageTs,
           text: "This approval request has been resolved.",
-          messageTs: approvalMessageTs,
-          assistantId: DAEMON_INTERNAL_ASSISTANT_ID,
         }).catch((err) => {
           log.error(
             { err, conversationId: result.conversationId },
@@ -1537,7 +1543,7 @@ function countSlackMetaMessages(conversationId: string): number {
   while (offset < SLACK_DM_CANDIDATE_MAX_SCAN) {
     const remaining = SLACK_DM_CANDIDATE_MAX_SCAN - offset;
     const batchLimit = Math.min(SLACK_DM_CANDIDATE_BATCH_SIZE, remaining);
-    const candidates = selectSlackMetaCandidateMetadata(
+    const candidates = selectProviderMetaCandidateMetadata(
       conversationId,
       batchLimit,
       offset,
@@ -1676,6 +1682,10 @@ function readStoredSlackThreadState(
  * content.
  * Caller is responsible for dedup checks before invoking; this helper
  * performs no idempotency check itself.
+ *
+ * Returns false when the row was refused rather than written. Callers mark
+ * the channel ts seen either way, so a refused body is not reconsidered on
+ * the next pass.
  */
 async function persistBackfilledSlackMessage(params: {
   conversationId: string;
@@ -1683,8 +1693,27 @@ async function persistBackfilledSlackMessage(params: {
   message: ProviderMessage;
   account?: string;
   guardianExternalUserId?: string;
-}): Promise<void> {
+}): Promise<boolean> {
   const { message } = params;
+
+  // Backfill writes externally-authored bodies into a conversation, so it
+  // carries the same secret gate as live channel ingress
+  // (`runSecretIngressCheck`). Runs before file hydration, so a refused row
+  // costs no downloads.
+  const secretScan = checkIngressForSecrets(message.text ?? "");
+  if (secretScan.blocked) {
+    log.warn(
+      {
+        conversationId: params.conversationId,
+        channelId: params.channelId,
+        channelTs: message.id,
+        detectedTypes: secretScan.detectedTypes,
+      },
+      "Skipping backfilled Slack message: secret detected",
+    );
+    return false;
+  }
+
   const slackFilesWithUrls = readSlackFilesWithUrlsFromProviderMetadata(
     message.metadata,
   );
@@ -1736,9 +1765,19 @@ async function persistBackfilledSlackMessage(params: {
 
   const rawText = message.text ?? "";
 
+  // `sentAt` is when the message was sent; the row's `createdAt` is when the
+  // import wrote it. History serialization prefers `sentAt` for the display
+  // timestamp, so setting it is what keeps weeks-old history from reading as
+  // having just arrived. The Slack adapter already derives this from the
+  // message ts, so no parsing happens here.
+  const sentAt = Number.isFinite(message.timestamp)
+    ? message.timestamp
+    : undefined;
+
   const persisted = await addMessage(params.conversationId, role, rawText, {
     metadata: {
       slackMeta: writeSlackMetadata(slackMeta),
+      ...(sentAt !== undefined ? { sentAt } : {}),
       provenanceTrustClass: isGuardian ? "guardian" : "unknown",
       provenanceSourceChannel: "slack",
       ...(params.guardianExternalUserId
@@ -1761,7 +1800,7 @@ async function persistBackfilledSlackMessage(params: {
       f.mimetype.startsWith("image/"),
   );
   if (imageFiles.length === 0) {
-    return;
+    return true;
   }
 
   const hydratedAttachments = await withSlackBotToken(
@@ -1832,7 +1871,7 @@ async function persistBackfilledSlackMessage(params: {
       { conversationId: params.conversationId, channelTs: message.id },
       "No Slack token available for backfill image hydration; skipping",
     );
-    return;
+    return true;
   }
 
   if (hydratedAttachments.length > 0) {
@@ -1843,6 +1882,7 @@ async function persistBackfilledSlackMessage(params: {
       ),
     );
   }
+  return true;
 }
 
 async function buildBackfilledSlackContentBlocks(
@@ -2079,7 +2119,7 @@ async function runBackfillSlackDmIfCold(params: {
         continue;
       }
       try {
-        await persistBackfilledSlackMessage({
+        const stored = await persistBackfilledSlackMessage({
           conversationId: params.conversationId,
           channelId: params.channelId,
           message,
@@ -2089,7 +2129,9 @@ async function runBackfillSlackDmIfCold(params: {
             : {}),
         });
         seen.add(message.id);
-        written++;
+        if (stored) {
+          written++;
+        }
       } catch (perRowErr) {
         log.warn(
           {
@@ -2677,7 +2719,7 @@ export async function triggerSlackThreadBackfillIfNeeded(params: {
         continue;
       }
       try {
-        await persistBackfilledSlackMessage({
+        const stored = await persistBackfilledSlackMessage({
           conversationId,
           channelId,
           message,
@@ -2685,7 +2727,9 @@ export async function triggerSlackThreadBackfillIfNeeded(params: {
           ...(guardianExternalUserId ? { guardianExternalUserId } : {}),
         });
         threadState.storedChannelTs.add(message.id);
-        persisted++;
+        if (stored) {
+          persisted++;
+        }
       } catch (err) {
         log.warn(
           { err, conversationId, channelId, threadTs, channelTs: message.id },

package/src/runtime/routes/inbound-stages/acl-enforcement.ts

@@ -19,6 +19,7 @@ import {
   getPendingSession,
   resolveBootstrapToken,
 } from "../../../channels/gateway-verification-sessions.js";
+import { audienceForReader } from "../../../channels/message-audience.js";
 import type { ChannelId } from "../../../channels/types.js";
 import {
   channelStatusToMemberStatus,
@@ -595,11 +596,11 @@ export async function enforceIngressAcl(
             text: replyText,
             assistantId,
           };
-          // On Slack, send as ephemeral so only the requester sees the rejection
-          if (sourceChannel === "slack" && (canonicalSenderId ?? rawSenderId)) {
-            replyPayload.ephemeral = true;
-            replyPayload.user = (canonicalSenderId ?? rawSenderId)!;
-          }
+          replyPayload.audience = audienceForReader(
+            sourceChannel,
+            conversationExternalId,
+            canonicalSenderId ?? rawSenderId,
+          );
           try {
             await deliverChannelReply(replyCallbackUrl, replyPayload);
             replyDelivered = true;
@@ -847,14 +848,11 @@ export async function enforceIngressAcl(
               text: inactiveReplyText,
               assistantId,
             };
-            // On Slack, send as ephemeral so only the requester sees the rejection
-            if (
-              sourceChannel === "slack" &&
-              (canonicalSenderId ?? rawSenderId)
-            ) {
-              inactiveReplyPayload.ephemeral = true;
-              inactiveReplyPayload.user = (canonicalSenderId ?? rawSenderId)!;
-            }
+            inactiveReplyPayload.audience = audienceForReader(
+              sourceChannel,
+              conversationExternalId,
+              canonicalSenderId ?? rawSenderId,
+            );
             try {
               await deliverChannelReply(replyCallbackUrl, inactiveReplyPayload);
               inactiveReplyDelivered = true;
@@ -891,10 +889,11 @@ export async function enforceIngressAcl(
             text: denyReplyText,
             assistantId,
           };
-          if (sourceChannel === "slack" && (canonicalSenderId ?? rawSenderId)) {
-            denyPayload.ephemeral = true;
-            denyPayload.user = (canonicalSenderId ?? rawSenderId)!;
-          }
+          denyPayload.audience = audienceForReader(
+            sourceChannel,
+            conversationExternalId,
+            canonicalSenderId ?? rawSenderId,
+          );
           try {
             await deliverChannelReply(replyCallbackUrl, denyPayload);
             denyReplyDelivered = true;

package/src/runtime/routes/inbound-stages/background-dispatch.test.ts

@@ -88,6 +88,42 @@ mock.module("../../gateway-client.js", () => ({
   },
 }));
 
+const sentReactions: Array<{
+  callbackUrl: string;
+  target: Record<string, unknown>;
+}> = [];
+const sentStreamOps: Array<Record<string, unknown>> = [];
+let sendChannelStreamOpImpl: (
+  op: Record<string, unknown>,
+) => Promise<{ ok: boolean; ts?: string }> = async () => ({ ok: true });
+const sentThreadStatuses: Array<Record<string, unknown>> = [];
+mock.module("../../../messaging/providers/index.js", () => ({
+  sendChannelTyping: async () => ({ ok: true }),
+  supportsChannelTyping: () => false,
+  sendChannelStreamOp: async (
+    _callbackUrl: string,
+    _chatId: string,
+    op: Record<string, unknown>,
+  ) => {
+    sentStreamOps.push(op);
+    return sendChannelStreamOpImpl(op);
+  },
+  setChannelThreadStatus: async (
+    _callbackUrl: string,
+    status: Record<string, unknown>,
+  ) => {
+    sentThreadStatuses.push(status);
+    return { ok: true };
+  },
+  sendChannelReaction: async (
+    callbackUrl: string,
+    target: Record<string, unknown>,
+  ) => {
+    sentReactions.push({ callbackUrl, target });
+    return { ok: true };
+  },
+}));
+
 mock.module("../../channel-reply-delivery.js", () => ({
   deliverReplyViaCallback: async (...args: unknown[]) => {
     const options = args[4] as
@@ -127,6 +163,10 @@ beforeEach(() => {
   __resetChannelTurnAdmissionForTests();
   clearConversations();
   deliveredChannelReplies.length = 0;
+  sentReactions.length = 0;
+  sentStreamOps.length = 0;
+  sendChannelStreamOpImpl = async () => ({ ok: true });
+  sentThreadStatuses.length = 0;
   markedProcessedEvents.length = 0;
   processingFailureEvents.length = 0;
   retryableFailureEvents.length = 0;
@@ -144,10 +184,7 @@ beforeEach(() => {
   deliverReplyViaCallbackImpl = async () => {};
 });
 
-const slackStreamOps = (): Array<Record<string, unknown>> =>
-  deliveredChannelReplies
-    .map((entry) => entry.payload.slackStream as Record<string, unknown>)
-    .filter(Boolean);
+const slackStreamOps = (): Array<Record<string, unknown>> => sentStreamOps;
 
 describe("isBoundGuardianActor", () => {
   test("returns true only when requester matches bound guardian", () => {
@@ -492,7 +529,7 @@ describe("processChannelMessageInBackground — reply delivery", () => {
     const channelId = "D-STREAMED";
     const threadTs = "1700000000.000044";
     const streamTs = "1700000000.000033";
-    deliverChannelReplyImpl = async () => ({ ok: true, ts: streamTs });
+    sendChannelStreamOpImpl = async () => ({ ok: true, ts: streamTs });
 
     const processMessage: MessageProcessor = async (
       _conversationId,
@@ -671,7 +708,7 @@ describe("processChannelMessageInBackground — reply delivery", () => {
     const channelId = "D-STREAM-PROCESSING-FAILURE";
     const threadTs = "1700000000.000066";
     const streamTs = "1700000000.000077";
-    deliverChannelReplyImpl = async () => ({ ok: true, ts: streamTs });
+    sendChannelStreamOpImpl = async () => ({ ok: true, ts: streamTs });
 
     const processMessage: MessageProcessor = async (
       _conversationId,
@@ -925,11 +962,12 @@ describe("Slack thinking status timing", () => {
     const messageTs = "1700000000.000010";
 
     const processMessage: MessageProcessor = async () => {
-      expect(deliveredChannelReplies).toHaveLength(1);
-      expect(deliveredChannelReplies[0]!.payload.reaction).toEqual({
+      expect(sentReactions).toHaveLength(1);
+      expect(sentReactions[0]!.target).toEqual({
+        chatId: channelId,
+        messageId: messageTs,
+        emoji: "eyes",
         action: "add",
-        name: "eyes",
-        messageTs,
       });
       return { messageId: "user-msg-dm-immediate" };
     };
@@ -950,12 +988,14 @@ describe("Slack thinking status timing", () => {
 
     await flush();
 
-    const reactions = deliveredChannelReplies.map(
-      (entry) => entry.payload.reaction,
-    );
-    expect(reactions).toEqual([
-      { action: "add", name: "eyes", messageTs },
-      { action: "remove", name: "eyes", messageTs },
+    expect(sentReactions.map((entry) => entry.target)).toEqual([
+      { chatId: channelId, messageId: messageTs, emoji: "eyes", action: "add" },
+      {
+        chatId: channelId,
+        messageId: messageTs,
+        emoji: "eyes",
+        action: "remove",
+      },
     ]);
   });
 
@@ -965,17 +1005,14 @@ describe("Slack thinking status timing", () => {
     const threadTs = "1700000000.000011";
 
     const processMessage: MessageProcessor = async () => {
-      expect(deliveredChannelReplies).toHaveLength(1);
-      expect(deliveredChannelReplies[0]!.payload.assistantThreadStatus).toEqual(
-        {
-          channel: channelId,
-          threadTs,
-          status: expect.any(String),
-          loadingMessages: ["Thinking\u2026"],
-        },
-      );
-      const threadStatus = deliveredChannelReplies[0]!.payload
-        .assistantThreadStatus as { status: string };
+      expect(sentThreadStatuses).toHaveLength(1);
+      expect(sentThreadStatuses[0]).toEqual({
+        chatId: channelId,
+        threadTs,
+        status: expect.any(String),
+        loadingMessages: ["Thinking\u2026"],
+      });
+      const threadStatus = sentThreadStatuses[0] as { status: string };
       expect(slackStatusLabels).toContain(threadStatus.status);
       return { messageId: "user-msg-mention-immediate" };
     };
@@ -996,12 +1033,9 @@ describe("Slack thinking status timing", () => {
 
     await flush();
 
-    const statuses = deliveredChannelReplies.map((entry) => {
-      const status = entry.payload.assistantThreadStatus as
-        | { status?: string }
-        | undefined;
-      return status?.status;
-    });
+    const statuses = sentThreadStatuses.map(
+      (entry) => (entry as { status?: string }).status,
+    );
     expect(slackStatusLabels).toContain(statuses[0]!);
     expect(statuses[1]).toBe("");
   });
@@ -1082,12 +1116,9 @@ describe("Slack thinking status timing", () => {
 
     await flush();
 
-    const statuses = deliveredChannelReplies.map((entry) => {
-      const status = entry.payload.assistantThreadStatus as
-        | { status?: string }
-        | undefined;
-      return status?.status;
-    });
+    const statuses = sentThreadStatuses.map(
+      (entry) => (entry as { status?: string }).status,
+    );
     expect(slackStatusLabels).toContain(statuses[0]!);
     expect(statuses[1]).toBe("");
   });
@@ -1144,18 +1175,16 @@ describe("Slack thinking status timing", () => {
 
     await flush();
 
-    const statuses = deliveredChannelReplies.map(
-      (entry) => entry.payload.assistantThreadStatus,
-    );
+    const statuses = sentThreadStatuses;
     expect(statuses).toEqual([
       {
-        channel: channelId,
+        chatId: channelId,
         threadTs,
         status: expect.any(String),
         loadingMessages: ["In progress (1/2): Search docs"],
       },
       {
-        channel: channelId,
+        chatId: channelId,
         threadTs,
         status: "",
       },
@@ -1278,24 +1307,22 @@ describe("Slack thinking status timing", () => {
 
     await flush();
 
-    const statuses = deliveredChannelReplies.map(
-      (entry) => entry.payload.assistantThreadStatus,
-    );
+    const statuses = sentThreadStatuses;
     expect(statuses).toEqual([
       {
-        channel: channelId,
+        chatId: channelId,
         threadTs,
         status: expect.any(String),
         loadingMessages: ["In progress (1/2): Read request"],
       },
       {
-        channel: channelId,
+        chatId: channelId,
         threadTs,
         status: expect.any(String),
         loadingMessages: ["In progress (2/2): Write answer"],
       },
       {
-        channel: channelId,
+        chatId: channelId,
         threadTs,
         status: "",
       },