@cursor/july 0.1.109 → 0.1.112

package/src/channels/slack/dispatch.ts

@@ -9,7 +9,10 @@ import {
   normalizeIdentity,
 } from "../../internal/continuation-identity.js";
 import { isDeferredChannelSession } from "../../internal/deferred-channel-session.js";
+import type { HostedAdmissionPlatformHandoff } from "../../internal/hosted-delivery-protocol.js";
 import { routeLocalIngressContinuation } from "../../internal/local-ingress.js";
+import { mapThrownRequestError } from "../../internal/request-error-status.js";
+import { isSlackImChannel } from "../../internal/slack-thread-key.js";
 import { steeringEnabled } from "../../internal/steering.js";
 import type {
   ArtifactsApi,
@@ -47,6 +50,13 @@ import {
   parseReactionAddedEvent,
 } from "./inbound.js";
 import { defaultSlackLog, type SlackLog } from "./log.js";
+import { paintTurnStart, retractTurnStart } from "./paint-start.js";
+import {
+  adoptPlaceholder,
+  retractPlaceholderMessage,
+  retractPlaceholderSlot,
+  startPlaceholder,
+} from "./placeholder.js";
 import { isWholeMessageStop } from "./stop.js";
 import {
   loadSlackThreadContextBlock,
@@ -138,10 +148,44 @@ export function emptySlackChannelState(
     approvalMessageByCallId: {},
     reasoningCard: undefined,
     toolCardCounts: {},
+    agenticFiles: [],
+    startPainted: false,
+    turnStartedAtMs: null,
     ...patch,
   };
 }
 
+/** Wake fields only. Empty maps/flags stay on the persisted record. */
+export type SlackWakeState = {
+  channelId: string;
+  threadTs: string;
+  teamId: string | null;
+  triggeringUserId: string | null;
+  startPainted?: true;
+  placeholderPosted?: boolean;
+};
+
+export function slackWakeChannelState(args: {
+  channelId: string;
+  threadTs: string;
+  teamId?: string | null;
+  triggeringUserId?: string | null;
+  startPainted?: boolean;
+  placeholderPosted?: boolean;
+}): SlackWakeState {
+  const wake: SlackWakeState = {
+    channelId: args.channelId,
+    threadTs: args.threadTs,
+    teamId: args.teamId ?? null,
+    triggeringUserId: args.triggeringUserId ?? null,
+    placeholderPosted: args.placeholderPosted === true,
+  };
+  if (args.startPainted === true) {
+    wake.startPainted = true;
+  }
+  return wake;
+}
+
 export interface SlackInboundDispatchDeps extends SlackContinuationProbes {
   send: SendMessageFn;
   continuation?: ContinuationIdentity;
@@ -173,9 +217,28 @@ export interface SlackInboundDispatchDeps extends SlackContinuationProbes {
    * `message.completed` handler is replaced, so it lingers past the turn.
    */
   followUpStatus?: boolean;
+  /**
+   * Reaction to stamp on the parent when the handler accepts, before
+   * `send()`. Agentic mode sets this so the thread paints during boot.
+   */
+  ack?: string;
+  /**
+   * Static replaceable first message. Fired with `send()`
+   * locally, and on hosted admission when the continuation already
+   * exists (warm / coalesced follow-up). Cold hosted posts it on
+   * `turn.started` unless {@link platformHandoff} already seeded the
+   * slot from a control-plane post. Overlay claims that slot.
+   */
+  placeholder?: string;
+  /**
+   * Trusted control-plane handoff (Slack placeholder ts). Hosted
+   * admission passes this so the guest adopts the CP-posted message
+   * instead of posting a duplicate.
+   */
+  platformHandoff?: HostedAdmissionPlatformHandoff;
   /**
    * When false, skip the built-in `eval` directive. Defaults to true when
-   * `host.evals` is present.
+   * `host.evals` is present; only ever runs on mentions and DMs.
    */
   evalCommandsEnabled?: boolean;
   /**
@@ -223,6 +286,69 @@ function continuationArg(identity: ContinuationIdentity | undefined): {
   return identity === undefined ? {} : { continuation: identity };
 }
 
+function inboundContinuation(deps: SlackInboundDispatchDeps): {
+  continuation?: ContinuationIdentity;
+  hasContinuationSession?: SlackInboundDispatchDeps["hasContinuationSession"];
+  isContinuationBusy?: SlackInboundDispatchDeps["isContinuationBusy"];
+  getContinuationLastBotMessageTs?: SlackInboundDispatchDeps["getContinuationLastBotMessageTs"];
+  interruptContinuation?: SlackInboundDispatchDeps["interruptContinuation"];
+} {
+  return {
+    ...continuationArg(deps.continuation),
+    ...(deps.hasContinuationSession === undefined
+      ? {}
+      : { hasContinuationSession: deps.hasContinuationSession }),
+    ...(deps.isContinuationBusy === undefined
+      ? {}
+      : { isContinuationBusy: deps.isContinuationBusy }),
+    ...(deps.getContinuationLastBotMessageTs === undefined
+      ? {}
+      : {
+          getContinuationLastBotMessageTs: deps.getContinuationLastBotMessageTs,
+        }),
+    ...(deps.interruptContinuation === undefined
+      ? {}
+      : { interruptContinuation: deps.interruptContinuation }),
+  };
+}
+
+function scheduleInbound(
+  deps: SlackInboundDispatchDeps,
+  log: SlackLog,
+  args: {
+    kind: "app_mention" | "direct_message" | "reaction_added";
+    message: SlackMessage;
+    handler: SlackMessageHandler;
+    evalCommandsEnabled?: boolean;
+    eventId?: string;
+    platformHandoff?: HostedAdmissionPlatformHandoff;
+  }
+): void {
+  deps.waitUntil(
+    dispatchInboundMessage({
+      kind: args.kind,
+      message: args.message,
+      handler: args.handler,
+      propagateHandlerErrors: deps.propagateHandlerErrors,
+      send: deps.send,
+      credentials: deps.credentials,
+      host: deps.host,
+      artifacts: deps.artifacts,
+      log,
+      evalCommandsEnabled: args.evalCommandsEnabled,
+      followUpStatus: deps.followUpStatus,
+      ack: deps.ack,
+      placeholder: deps.placeholder,
+      blockExternals: deps.blockExternals,
+      ...inboundContinuation(deps),
+      ...(args.eventId === undefined ? {} : { eventId: args.eventId }),
+      ...(args.platformHandoff === undefined
+        ? {}
+        : { platformHandoff: args.platformHandoff }),
+    })
+  );
+}
+
 function slackSessionContinuation(
   identity: ContinuationIdentity | undefined,
   channelId: string,
@@ -276,6 +402,12 @@ export async function dispatchInboundMessage(args: {
   followUpStatus?: boolean;
   blockExternals?: boolean;
   continuation?: ContinuationIdentity;
+  /** See {@link SlackInboundDispatchDeps.ack}. */
+  ack?: string;
+  /** See {@link SlackInboundDispatchDeps.placeholder}. */
+  placeholder?: string;
+  /** See {@link SlackInboundDispatchDeps.platformHandoff}. */
+  platformHandoff?: HostedAdmissionPlatformHandoff;
   /** See {@link SlackInboundDispatchDeps.propagateHandlerErrors}. */
   propagateHandlerErrors?: boolean;
 }): Promise<void> {
@@ -301,49 +433,122 @@ export async function dispatchInboundMessage(args: {
     team: message.teamId,
   });
 
-  if (args.blockExternals !== false && message.author?.isBot !== true) {
-    const userId = message.author?.userId ?? "";
-    const teamId = message.teamId;
-    if (teamId === undefined || teamId === "") {
-      log.info("inbound dropped (missing team)", {
-        kind,
+  const handoff = args.platformHandoff?.slackPlaceholder;
+  const matchedHandoff =
+    args.placeholder !== undefined &&
+    kind !== "channel_post" &&
+    handoff !== undefined &&
+    handoff.channelId === message.channelId &&
+    handoff.threadTs === message.threadTs
+      ? handoff
+      : undefined;
+  let adoptedPlaceholder = false;
+  let handoffRetracted = false;
+  const retractUnadoptedHandoff = async (): Promise<void> => {
+    if (matchedHandoff === undefined || handoffRetracted) {
+      return;
+    }
+    handoffRetracted = true;
+    await retractPlaceholderMessage({
+      botToken: args.credentials?.botToken,
+      channelId: matchedHandoff.channelId,
+      ts: matchedHandoff.messageTs,
+      streamed: matchedHandoff.streamed,
+      log,
+    });
+  };
+  const adoptMatchedHandoff = async (): Promise<void> => {
+    if (matchedHandoff === undefined) {
+      return;
+    }
+    const adoption = adoptPlaceholder({
+      channelId: matchedHandoff.channelId,
+      threadTs: matchedHandoff.threadTs,
+      ts: matchedHandoff.messageTs,
+      streamed: matchedHandoff.streamed,
+    });
+    if (adoption === "adopted") {
+      adoptedPlaceholder = true;
+      log.info("placeholder adopted from control-plane handoff", {
         channel: message.channelId,
         thread_ts: message.threadTs,
-        user: userId,
-        event_id: args.eventId,
+        message_ts: matchedHandoff.messageTs,
       });
       return;
     }
-    if (
-      await isExternalSlackSender({
-        botToken: args.credentials?.botToken,
-        slackTeamId: teamId,
-        userId,
-      })
-    ) {
-      log.info("inbound dropped (external sender)", {
+    if (adoption === "occupied") {
+      // Another delivery owns this thread's slot. Remove only this delivery's
+      // redundant CP post.
+      await retractUnadoptedHandoff();
+    }
+  };
+  const retractAdoptedPlaceholder = async (): Promise<void> => {
+    if (!adoptedPlaceholder) {
+      return;
+    }
+    adoptedPlaceholder = false;
+    await retractPlaceholderSlot({
+      channelId: message.channelId,
+      threadTs: message.threadTs,
+      botToken: args.credentials?.botToken,
+      log,
+    });
+  };
+
+  const userId = message.author?.userId ?? "";
+  const teamId = message.teamId;
+  let membership: Promise<boolean> | undefined;
+  if (args.blockExternals !== false && message.author?.isBot !== true) {
+    if (teamId === undefined || teamId === "") {
+      log.info("inbound dropped (missing team)", {
         kind,
         channel: message.channelId,
         thread_ts: message.threadTs,
         user: userId,
-        team: teamId,
         event_id: args.eventId,
       });
+      await retractUnadoptedHandoff();
       return;
     }
+    membership = isExternalSlackSender({
+      botToken: args.credentials?.botToken,
+      slackTeamId: teamId,
+      userId,
+    });
   }
+  const dropExternal = (): void => {
+    log.info("inbound dropped (external sender)", {
+      kind,
+      channel: message.channelId,
+      thread_ts: message.threadTs,
+      user: userId,
+      team: teamId,
+      event_id: args.eventId,
+    });
+  };
 
   const { probeKey: continuation, sendPatch } = slackSessionContinuation(
     args.continuation,
     message.channelId,
     message.threadTs
   );
+  const loadThread = !isSlackImChannel(message.channelId);
+  const hosted = args.propagateHandlerErrors === true;
+  const existsP =
+    args.hasContinuationSession === undefined || (!loadThread && !hosted)
+      ? undefined
+      : args.hasContinuationSession(continuation);
 
   // Whole-message stop: cancel active turn + clear nudges (Benny parity).
   if (
     isWholeMessageStop(message.text) ||
     isWholeMessageStop(message.markdown)
   ) {
+    if (membership !== undefined && (await membership)) {
+      dropExternal();
+      await retractUnadoptedHandoff();
+      return;
+    }
     log.info("stop directive", {
       kind,
       channel: message.channelId,
@@ -363,17 +568,27 @@ export async function dispatchInboundMessage(args: {
     } catch {
       // best-effort status
     }
+    await retractUnadoptedHandoff();
     return;
   }
 
   // Built-in eval directive: run playground batches without an agent turn.
-  const evalCommandsEnabled = args.evalCommandsEnabled !== false;
+  // Only when the bot is addressed — a watched channel post is dispatched
+  // whatever it says, and may open with `eval` while talking to someone else.
+  const evalCommandsEnabled =
+    args.evalCommandsEnabled !== false &&
+    (kind === "app_mention" || kind === "direct_message");
   const evalDirective =
     evalCommandsEnabled && args.host.evals !== undefined
       ? (parseSlackEvalDirective(message.text) ??
         parseSlackEvalDirective(message.markdown))
       : null;
   if (evalDirective !== null && args.host.evals !== undefined) {
+    if (membership !== undefined && (await membership)) {
+      dropExternal();
+      await retractUnadoptedHandoff();
+      return;
+    }
     log.info("eval directive", {
       kind,
       channel: message.channelId,
@@ -387,19 +602,10 @@ export async function dispatchInboundMessage(args: {
       evals: args.host.evals,
       binding,
     });
+    await retractUnadoptedHandoff();
     return;
   }
 
-  if (message.ts === message.threadTs) {
-    await maybeSetThreadTitle({
-      botToken: args.credentials?.botToken,
-      channelId: message.channelId,
-      threadTs: message.threadTs,
-      title: firstLineTitle(message.markdown),
-      log,
-    });
-  }
-
   let decision: SlackDispatchDecision | null | undefined;
   try {
     decision = await args.handler(binding, message);
@@ -411,8 +617,12 @@ export async function dispatchInboundMessage(args: {
       event_id: args.eventId,
     });
     if (args.propagateHandlerErrors === true) {
+      if (mapThrownRequestError(error)?.retry !== "transient") {
+        await retractUnadoptedHandoff();
+      }
       throw error;
     }
+    await retractUnadoptedHandoff();
     return;
   }
   if (decision === null || decision === undefined) {
@@ -422,6 +632,7 @@ export async function dispatchInboundMessage(args: {
       thread_ts: message.threadTs,
       event_id: args.eventId,
     });
+    await retractUnadoptedHandoff();
     return;
   }
 
@@ -441,56 +652,100 @@ export async function dispatchInboundMessage(args: {
     return;
   }
 
-  const media = await slackTurnMedia({
-    message,
-    decision,
-    botToken: args.credentials?.botToken,
-    log,
-  });
-  if (message.files !== undefined && message.files.length > 0) {
-    log.info("slack attachments prepared", {
-      kind,
-      channel: message.channelId,
-      thread_ts: message.threadTs,
-      images: media.images?.length ?? 0,
-      workspace_files: Object.keys(media.workspaceFiles ?? {}).length,
-      event_id: args.eventId,
+  await adoptMatchedHandoff();
+
+  const painted =
+    args.ack === undefined
+      ? undefined
+      : paintTurnStart({
+          botToken: args.credentials?.botToken,
+          channelId: message.channelId,
+          threadTs: message.threadTs,
+          ack: args.ack,
+          log,
+        });
+  if (message.ts === message.threadTs && !isSlackImChannel(message.channelId)) {
+    void maybeSetThreadTitle({
+      botToken: args.credentials?.botToken,
+      channelId: message.channelId,
+      threadTs: message.threadTs,
+      title: firstLineTitle(message.markdown),
+      log,
     });
   }
+
   const excludeThreadTimestamps = [
     message.ts,
     ...(decision.excludeThreadTimestamps ?? []),
   ];
-  const hasSession =
-    args.hasContinuationSession === undefined
-      ? false
-      : await args.hasContinuationSession(continuation);
   const mergeMessages = [triggeringMergeMessage(message)];
+  const mediaTask = slackTurnMedia({
+    message,
+    decision,
+    botToken: args.credentials?.botToken,
+    log,
+  });
+  const continuationExists = existsP === undefined ? false : await existsP;
+  const hasSession = loadThread && continuationExists;
   const afterTs =
-    hasSession && args.getContinuationLastBotMessageTs !== undefined
+    loadThread &&
+    hasSession &&
+    args.getContinuationLastBotMessageTs !== undefined
       ? await args.getContinuationLastBotMessageTs(continuation)
       : undefined;
 
-  // Cold start: full <slack_thread>. Warm: <slack_thread_delta> since last
-  // agent post (session watermark), else last matching bot post in-thread.
-  const threadContext = hasSession
-    ? await loadSlackThreadDeltaBlock({
-        botToken: args.credentials?.botToken,
-        channelId: message.channelId,
-        threadTs: message.threadTs,
-        ...(afterTs === undefined ? {} : { afterTs }),
-        excludeTs: excludeThreadTimestamps,
-        mergeMessages,
-        log,
-      })
-    : await loadSlackThreadContextBlock({
+  // Channel mentions: cold <slack_thread>, warm <slack_thread_delta>.
+  const threadTask = !loadThread
+    ? Promise.resolve(undefined)
+    : hasSession
+      ? loadSlackThreadDeltaBlock({
+          botToken: args.credentials?.botToken,
+          channelId: message.channelId,
+          threadTs: message.threadTs,
+          ...(afterTs === undefined ? {} : { afterTs }),
+          excludeTs: excludeThreadTimestamps,
+          mergeMessages,
+          log,
+        })
+      : loadSlackThreadContextBlock({
+          botToken: args.credentials?.botToken,
+          channelId: message.channelId,
+          threadTs: message.threadTs,
+          excludeTs: excludeThreadTimestamps,
+          mergeMessages,
+          log,
+        });
+  const [media, threadContext, external] = await Promise.all([
+    mediaTask,
+    threadTask,
+    membership ?? Promise.resolve(false),
+  ]);
+  if (external === true) {
+    dropExternal();
+    if (painted !== undefined) {
+      await painted;
+      await retractTurnStart({
         botToken: args.credentials?.botToken,
         channelId: message.channelId,
         threadTs: message.threadTs,
-        excludeTs: excludeThreadTimestamps,
-        mergeMessages,
+        ack: args.ack ?? "",
         log,
       });
+    }
+    await args.host.slackNudges?.releaseAsk(message.channelId, message.ts);
+    await retractAdoptedPlaceholder();
+    return;
+  }
+  if (message.files !== undefined && message.files.length > 0) {
+    log.info("slack attachments prepared", {
+      kind,
+      channel: message.channelId,
+      thread_ts: message.threadTs,
+      images: media.images?.length ?? 0,
+      workspace_files: Object.keys(media.workspaceFiles ?? {}).length,
+      event_id: args.eventId,
+    });
+  }
   if (threadContext !== undefined) {
     log.info(hasSession ? "thread delta loaded" : "thread context loaded", {
       kind,
@@ -517,20 +772,54 @@ export async function dispatchInboundMessage(args: {
     "",
     media.userText,
   ]
-    .filter((part) => part.length > 0)
+    .filter(part => part.length > 0)
     .join("\n");
 
+  const paintedStart = painted !== undefined;
+  const placeholderLine = args.placeholder;
+  const hasPlaceholder =
+    placeholderLine !== undefined && kind !== "channel_post";
+  const hostedFollowup =
+    hosted &&
+    hasPlaceholder &&
+    (message.ts !== message.threadTs || continuationExists);
+  // Adopted slots already exist in Slack; skip a second post. Cold hosted
+  // without a handoff still defers to `turn.started`.
+  const placeholder =
+    !adoptedPlaceholder && hasPlaceholder && (!hosted || hostedFollowup)
+      ? startPlaceholder({
+          line: placeholderLine,
+          botToken: args.credentials?.botToken,
+          channelId: message.channelId,
+          threadTs: message.threadTs,
+          log,
+          recipientUserId: message.author?.userId,
+          recipientTeamId: message.teamId,
+        })
+      : undefined;
+  const posted = adoptedPlaceholder || placeholder !== undefined;
+  const state = emptySlackChannelState({
+    channelId: message.channelId,
+    threadTs: message.threadTs,
+    teamId: message.teamId ?? null,
+    triggeringUserId: message.author?.userId ?? null,
+    startPainted: paintedStart,
+    placeholderPosted: posted,
+  });
   const sendOptions = {
     auth: decision.auth,
     ...sendPatch,
     admission: "coalesce" as const,
     coalesceSourceTs: message.ts,
-    state: emptySlackChannelState({
+    state: state as unknown as JsonValue,
+    refreshState: slackWakeChannelState({
       channelId: message.channelId,
       threadTs: message.threadTs,
       teamId: message.teamId ?? null,
       triggeringUserId: message.author?.userId ?? null,
-    }) as unknown as JsonValue,
+      startPainted: paintedStart,
+      placeholderPosted: posted,
+    }),
     title: decision.title ?? `slack:${message.channelId}:${message.threadTs}`,
     workspaceDir: decision.workspaceDir,
     workspaceFiles: media.workspaceFiles,
@@ -542,9 +831,6 @@ export async function dispatchInboundMessage(args: {
   try {
     const session = await args.send(prompt, sendOptions);
     if (isDeferredChannelSession(session)) {
-      // Hosted admission captured the send; the control plane allocates
-      // the session and runs the turn only after this delivery is
-      // acknowledged, so there is nothing to observe or coalesce yet.
       log.info("session send captured (hosted admission)", {
         kind,
         continuation,
@@ -570,6 +856,7 @@ export async function dispatchInboundMessage(args: {
     // Coalesce admits leave the active turn running: the follow-up is queued
     // for the carrier to inject at the next tool boundary, and anything it
     // does not reach in time drains into the boundary turn instead.
+    // Keep the placeholder; a new DM ts cannot overlay the carrier turn.
     if (session.coalesced === true) {
       log.info("session busy; coalescing follow-up", {
         kind,
@@ -618,6 +905,20 @@ export async function dispatchInboundMessage(args: {
     }
   } catch (error) {
     await args.host.slackNudges?.releaseAsk(message.channelId, message.ts);
+    if (placeholder !== undefined) {
+      await placeholder.retract();
+    }
+    await retractAdoptedPlaceholder();
+    if (painted !== undefined) {
+      await painted;
+      await retractTurnStart({
+        botToken: args.credentials?.botToken,
+        channelId: message.channelId,
+        threadTs: message.threadTs,
+        ack: args.ack ?? "",
+        log,
+      });
+    }
     log.error(
       `${kind} delivery failed: ${
         error instanceof Error ? error.message : String(error)
@@ -629,6 +930,10 @@ export async function dispatchInboundMessage(args: {
         event_id: args.eventId,
       }
     );
+  } finally {
+    if (placeholder !== undefined) {
+      await placeholder.done;
+    }
   }
 }
 
@@ -643,6 +948,21 @@ export function dispatchInboundFromEventBody(
 ): boolean {
   const log = deps.log ?? defaultSlackLog;
   let eventId: string | undefined;
+  const retractUnscheduledHandoff = (): void => {
+    const placeholder = deps.platformHandoff?.slackPlaceholder;
+    if (placeholder === undefined) {
+      return;
+    }
+    deps.waitUntil(
+      retractPlaceholderMessage({
+        botToken: deps.credentials?.botToken,
+        channelId: placeholder.channelId,
+        ts: placeholder.messageTs,
+        streamed: placeholder.streamed,
+        log,
+      })
+    );
+  };
 
   if (body !== null && typeof body === "object" && !Array.isArray(body)) {
     const root = body as { event_id?: unknown };
@@ -650,6 +970,7 @@ export function dispatchInboundFromEventBody(
       eventId = root.event_id;
       if (!deps.eventIds.tryHandle(root.event_id)) {
         log.debug("inbound dedupe drop", { event_id: eventId });
+        retractUnscheduledHandoff();
         return false;
       }
     }
@@ -661,6 +982,7 @@ export function dispatchInboundFromEventBody(
   if (mention !== null) {
     if (deps.mentionsEnabled === false) {
       log.debug("inbound ignored (mentions disabled)", { event_id: eventId });
+      retractUnscheduledHandoff();
       return false;
     }
     if (mention.author?.isBot === true) {
@@ -678,42 +1000,18 @@ export function dispatchInboundFromEventBody(
           from_bot: mention.author.botId ?? mention.author.userId,
           reason: verdict.reason,
         });
+        retractUnscheduledHandoff();
         return false;
       }
     }
-    deps.waitUntil(
-      dispatchInboundMessage({
-        kind: "app_mention",
-        message: mention,
-        handler: deps.onAppMention,
-        propagateHandlerErrors: deps.propagateHandlerErrors,
-        send: deps.send,
-        credentials: deps.credentials,
-        host: deps.host,
-        artifacts: deps.artifacts,
-        log,
-        evalCommandsEnabled: deps.evalCommandsEnabled,
-        followUpStatus: deps.followUpStatus,
-        blockExternals: deps.blockExternals,
-        ...continuationArg(deps.continuation),
-        ...(deps.hasContinuationSession === undefined
-          ? {}
-          : { hasContinuationSession: deps.hasContinuationSession }),
-        ...(deps.isContinuationBusy === undefined
-          ? {}
-          : { isContinuationBusy: deps.isContinuationBusy }),
-        ...(deps.getContinuationLastBotMessageTs === undefined
-          ? {}
-          : {
-              getContinuationLastBotMessageTs:
-                deps.getContinuationLastBotMessageTs,
-            }),
-        ...(deps.interruptContinuation === undefined
-          ? {}
-          : { interruptContinuation: deps.interruptContinuation }),
-        ...(eventId === undefined ? {} : { eventId }),
-      })
-    );
+    scheduleInbound(deps, log, {
+      kind: "app_mention",
+      message: mention,
+      handler: deps.onAppMention,
+      evalCommandsEnabled: deps.evalCommandsEnabled,
+      eventId,
+      platformHandoff: deps.platformHandoff,
+    });
     return true;
   }
 
@@ -723,79 +1021,30 @@ export function dispatchInboundFromEventBody(
       log.debug("inbound ignored (direct messages disabled)", {
         event_id: eventId,
       });
+      retractUnscheduledHandoff();
       return false;
     }
-    deps.waitUntil(
-      dispatchInboundMessage({
-        kind: "direct_message",
-        message: dm,
-        handler: deps.onDirectMessage,
-        propagateHandlerErrors: deps.propagateHandlerErrors,
-        send: deps.send,
-        credentials: deps.credentials,
-        host: deps.host,
-        artifacts: deps.artifacts,
-        log,
-        evalCommandsEnabled: deps.evalCommandsEnabled,
-        followUpStatus: deps.followUpStatus,
-        blockExternals: deps.blockExternals,
-        ...continuationArg(deps.continuation),
-        ...(deps.hasContinuationSession === undefined
-          ? {}
-          : { hasContinuationSession: deps.hasContinuationSession }),
-        ...(deps.isContinuationBusy === undefined
-          ? {}
-          : { isContinuationBusy: deps.isContinuationBusy }),
-        ...(deps.getContinuationLastBotMessageTs === undefined
-          ? {}
-          : {
-              getContinuationLastBotMessageTs:
-                deps.getContinuationLastBotMessageTs,
-            }),
-        ...(deps.interruptContinuation === undefined
-          ? {}
-          : { interruptContinuation: deps.interruptContinuation }),
-        ...(eventId === undefined ? {} : { eventId }),
-      })
-    );
+    scheduleInbound(deps, log, {
+      kind: "direct_message",
+      message: dm,
+      handler: deps.onDirectMessage,
+      evalCommandsEnabled: deps.evalCommandsEnabled,
+      eventId,
+      platformHandoff: deps.platformHandoff,
+    });
     return true;
   }
 
   const reaction = parseReactionAddedEvent(body);
   if (reaction !== null && deps.onReactionAdded !== undefined) {
-    deps.waitUntil(
-      dispatchInboundMessage({
-        kind: "reaction_added",
-        message: reaction,
-        handler: deps.onReactionAdded,
-        propagateHandlerErrors: deps.propagateHandlerErrors,
-        send: deps.send,
-        credentials: deps.credentials,
-        host: deps.host,
-        artifacts: deps.artifacts,
-        log,
-        evalCommandsEnabled: false,
-        followUpStatus: deps.followUpStatus,
-        blockExternals: deps.blockExternals,
-        ...continuationArg(deps.continuation),
-        ...(deps.hasContinuationSession === undefined
-          ? {}
-          : { hasContinuationSession: deps.hasContinuationSession }),
-        ...(deps.isContinuationBusy === undefined
-          ? {}
-          : { isContinuationBusy: deps.isContinuationBusy }),
-        ...(deps.getContinuationLastBotMessageTs === undefined
-          ? {}
-          : {
-              getContinuationLastBotMessageTs:
-                deps.getContinuationLastBotMessageTs,
-            }),
-        ...(deps.interruptContinuation === undefined
-          ? {}
-          : { interruptContinuation: deps.interruptContinuation }),
-        ...(eventId === undefined ? {} : { eventId }),
-      })
-    );
+    retractUnscheduledHandoff();
+    scheduleInbound(deps, log, {
+      kind: "reaction_added",
+      message: reaction,
+      handler: deps.onReactionAdded,
+      evalCommandsEnabled: false,
+      eventId,
+    });
     return true;
   }
 
@@ -853,6 +1102,7 @@ export function dispatchInboundFromEventBody(
       includeBotAuthored: true,
     });
     if (channelEvent !== null) {
+      retractUnscheduledHandoff();
       return deps.channelWatch.handle(channelEvent, eventId);
     }
   }
@@ -861,5 +1111,6 @@ export function dispatchInboundFromEventBody(
     ...describeSlackEventShape(body),
     event_id: eventId,
   });
+  retractUnscheduledHandoff();
   return false;
 }