@cursor/bdk 0.2.2 → 0.2.4

package/src/channels/slack/dispatch.ts

@@ -1,1060 +0,0 @@
-/**
- * Shared inbound dispatch for Slack Events API bodies and Socket Mode.
- */
-
-import {
-  type ContinuationIdentity,
-  continuationSource,
-  type MailboxContinuation,
-  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, HostContext, JsonValue, SendMessageFn } from "../../types.js";
-import { buildSlackBinding, slackContinuationKey } from "./api.js";
-import { firstLineTitle, maybeSetSuggestedPrompts, maybeSetThreadTitle } from "./assistant.js";
-import {
-  appendSlackAttachmentAnnotations,
-  prepareSlackAttachments,
-  SLACK_ATTACHMENT_ONLY_PROMPT,
-} from "./attachments.js";
-import type { SlackBotMentionGate } from "./bot-mentions.js";
-import type { ChannelPostWatcher } from "./channel-watch.js";
-import { handleSlackEvalDirective, parseSlackEvalDirective } from "./eval-directive.js";
-import type { EventIdDedupe } from "./event-id-dedupe.js";
-import { isExternalSlackSender } from "./external-policy.js";
-import {
-  describeSlackEventShape,
-  formatSlackContextBlock,
-  parseAppHomeOpened,
-  parseAppMentionEvent,
-  parseAssistantThreadStarted,
-  parseChannelMessageEvent,
-  parseDirectMessageEvent,
-  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, loadSlackThreadDeltaBlock } from "./thread-context.js";
-import type {
-  SlackBotToken,
-  SlackChannelState,
-  SlackContinuationProbes,
-  SlackCredentials,
-  SlackDispatchDecision,
-  SlackMessage,
-  SlackMessageHandler,
-  SlackSuggestedPrompt,
-} from "./types.js";
-
-const FOLLOWUP_TYPING = "Saw your follow-up…";
-
-function slackUserText(message: SlackMessage, override?: string): string {
-  if (override !== undefined) {
-    return override;
-  }
-  if (message.markdown.trim().length > 0) {
-    return message.markdown;
-  }
-  if (message.files !== undefined && message.files.length > 0) {
-    return SLACK_ATTACHMENT_ONLY_PROMPT;
-  }
-  return message.markdown;
-}
-
-async function slackTurnMedia(args: {
-  message: SlackMessage;
-  decision: SlackDispatchDecision;
-  botToken: SlackBotToken | undefined;
-  log: SlackLog;
-}): Promise<{
-  userText: string;
-  workspaceFiles?: SlackDispatchDecision["workspaceFiles"];
-  images?: SlackDispatchDecision["images"];
-}> {
-  const prepared =
-    args.message.files !== undefined && args.message.files.length > 0
-      ? await prepareSlackAttachments({
-          botToken: args.botToken,
-          files: args.message.files,
-          log: args.log,
-        })
-      : undefined;
-
-  const workspaceFiles = {
-    ...args.decision.workspaceFiles,
-    ...prepared?.workspaceFiles,
-  };
-  const images = [...(args.decision.images ?? []), ...(prepared?.images ?? [])];
-
-  return {
-    userText: appendSlackAttachmentAnnotations(
-      slackUserText(args.message, args.decision.message),
-      prepared?.annotations ?? [],
-    ),
-    workspaceFiles: Object.keys(workspaceFiles).length > 0 ? workspaceFiles : undefined,
-    images: images.length > 0 ? images : undefined,
-  };
-}
-
-/** Blank per-session adapter state. */
-export function emptySlackChannelState(patch: Partial<SlackChannelState> = {}): SlackChannelState {
-  return {
-    channelId: null,
-    threadTs: null,
-    teamId: null,
-    triggeringUserId: null,
-    pendingToolCallMessage: null,
-    lastReasoningTypingAtMs: null,
-    lastReasoningTypingStatus: null,
-    streamTs: null,
-    streamChannelId: null,
-    lastPostedText: null,
-    streamBlockText: null,
-    lastBotMessageTs: null,
-    streamingUnavailable: false,
-    streamFull: false,
-    streamAppendedChunks: 0,
-    progressTs: null,
-    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;
-  waitUntil: (promise: Promise<unknown>) => void;
-  onAppMention: SlackMessageHandler;
-  onDirectMessage: SlackMessageHandler;
-  onReactionAdded?: SlackMessageHandler;
-  credentials: SlackCredentials | undefined;
-  eventIds: EventIdDedupe;
-  host: HostContext;
-  /** Unbound artifacts facade handed to handler bindings (`ctx.artifacts`). */
-  artifacts: ArtifactsApi;
-  log?: SlackLog;
-  /** Dispatch on `app_mention`. Defaults to `true`. */
-  mentionsEnabled?: boolean;
-  /** Dispatch on direct messages. Defaults to `true`. */
-  directMessagesEnabled?: boolean;
-  /** Opt-in channel watch; absent = channel posts are ignored. */
-  channelWatch?: ChannelPostWatcher;
-  /**
-   * Opt-in bot-to-bot mention gate; absent = bot-authored mentions are
-   * dropped at parse time (loop safety).
-   */
-  botMentionGate?: SlackBotMentionGate;
-  /**
-   * When false, do not write `assistant.threads.setStatus` on a coalesced
-   * follow-up. Defaults to `true`. Channels that report progress their own
-   * way turn this off: the chip has no owner to clear it once the default
-   * `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; only ever runs on mentions and DMs.
-   */
-  evalCommandsEnabled?: boolean;
-  /**
-   * Drop external senders before the handler. Defaults to `true`; pass
-   * `false` to admit them (or when an upstream gate already refused them).
-   */
-  blockExternals?: boolean;
-  /**
-   * Suggested prompts pinned when a user opens the agent Messages tab
-   * (`app_home_opened`). Older apps still seed them on
-   * `assistant_thread_started`.
-   */
-  suggestedPrompts?: SlackSuggestedPrompt[];
-  suggestedPromptsTitle?: string;
-  /**
-   * Rethrow handler failures out of the dispatch promise instead of
-   * swallowing them after the error log. Hosted admission sets this so a
-   * throwing handler rejects `waitUntil` and surfaces as a retryable 503
-   * to the control plane (matching the GitHub/Origin adapters); the
-   * long-lived Socket Mode loop keeps the swallow-and-log default.
-   */
-  propagateHandlerErrors?: boolean;
-}
-
-function triggeringMergeMessage(message: SlackMessage): Record<string, unknown> {
-  return {
-    ts: message.ts,
-    ...(message.author?.userId === undefined || message.author.userId === ""
-      ? {}
-      : { user: message.author.userId }),
-    ...(message.author?.botId === undefined ? {} : { bot_id: message.author.botId }),
-    // Flattened body, so this stand-in matches what the real API record
-    // reduces to and is not dropped as empty by the thread-context filters.
-    text: message.body,
-  };
-}
-
-function continuationArg(identity: ContinuationIdentity | undefined): {
-  continuation?: ContinuationIdentity;
-} {
-  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,
-  threadTs: string,
-): {
-  probeKey: string;
-  sendPatch: { continuationToken: string } | { mailboxContinuation: MailboxContinuation };
-} {
-  if (continuationSource(identity, "slack") === "engine") {
-    const key = slackContinuationKey(channelId, threadTs);
-    return { probeKey: key, sendPatch: { continuationToken: key } };
-  }
-  const routed = routeLocalIngressContinuation({
-    identity: normalizeIdentity(identity, "slack"),
-    kind: "slack",
-    eventType: "message",
-    payload: { channelId, threadTs },
-  });
-  const mailbox = routed.mailboxContinuation;
-  if (mailbox === undefined) {
-    throw new Error("v2 slack ingress did not stamp a mailbox");
-  }
-  return { probeKey: mailbox.key, sendPatch: { mailboxContinuation: mailbox } };
-}
-
-export async function dispatchInboundMessage(args: {
-  kind: "app_mention" | "direct_message" | "channel_post" | "reaction_added" | "block_action";
-  message: SlackMessage;
-  handler: SlackMessageHandler;
-  send: SendMessageFn;
-  credentials: SlackCredentials | undefined;
-  host: HostContext;
-  artifacts: ArtifactsApi;
-  hasContinuationSession?: (continuationToken: string) => Promise<boolean>;
-  isContinuationBusy?: (continuationToken: string) => Promise<boolean>;
-  getContinuationLastBotMessageTs?: (continuationToken: string) => Promise<string | undefined>;
-  interruptContinuation?: (continuationToken: string) => Promise<boolean>;
-  log?: SlackLog;
-  eventId?: string;
-  evalCommandsEnabled?: boolean;
-  /** See {@link SlackInboundDispatchDeps.followUpStatus}. Defaults to `true`. */
-  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> {
-  const { message, kind } = args;
-  const log = args.log ?? defaultSlackLog;
-  const binding = buildSlackBinding({
-    botToken: args.credentials?.botToken,
-    channelId: message.channelId,
-    threadTs: message.threadTs,
-    host: args.host,
-    artifacts: args.artifacts,
-    log,
-    teamId: message.teamId,
-  });
-
-  log.info("inbound", {
-    kind,
-    event_id: args.eventId,
-    channel: message.channelId,
-    thread_ts: message.threadTs,
-    message_ts: message.ts,
-    user: message.author?.userId,
-    team: message.teamId,
-  });
-
-  const handoff = args.platformHandoff?.slackPlaceholder;
-  const handoffInThread =
-    kind !== "channel_post" &&
-    handoff !== undefined &&
-    handoff.channelId === message.channelId &&
-    handoff.threadTs === message.threadTs
-      ? handoff
-      : undefined;
-  const matchedHandoff = args.placeholder !== undefined ? handoffInThread : 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,
-        message_ts: matchedHandoff.messageTs,
-      });
-      return;
-    }
-    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,
-        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,
-      thread_ts: message.threadTs,
-      continuation,
-      event_id: args.eventId,
-    });
-    await args.host.slackNudges?.clear(continuation);
-    const interrupted =
-      args.interruptContinuation === undefined
-        ? false
-        : await args.interruptContinuation(continuation);
-    try {
-      await binding.thread.startTyping(interrupted ? "Stopped." : "Nothing to stop.");
-    } catch {
-      // best-effort status
-    }
-    await retractUnadoptedHandoff();
-    return;
-  }
-
-  // Built-in eval directive: run playground batches without an agent turn.
-  // 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,
-      thread_ts: message.threadTs,
-      continuation,
-      event_id: args.eventId,
-      directive: evalDirective.kind,
-    });
-    await handleSlackEvalDirective({
-      directive: evalDirective,
-      evals: args.host.evals,
-      binding,
-    });
-    await retractUnadoptedHandoff();
-    return;
-  }
-
-  let decision: SlackDispatchDecision | null | undefined;
-  try {
-    decision = await args.handler(binding, message);
-  } catch (error) {
-    log.error(`${kind} handler failed`, {
-      error: error instanceof Error ? error.message : String(error),
-      channel: message.channelId,
-      thread_ts: message.threadTs,
-      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) {
-    log.info("inbound skipped (handler returned null)", {
-      kind,
-      channel: message.channelId,
-      thread_ts: message.threadTs,
-      event_id: args.eventId,
-    });
-    await retractUnadoptedHandoff();
-    return;
-  }
-
-  // Reply-once / delayed parent: claim channel:ts after the handler accepts.
-  const claimed = await args.host.slackNudges?.tryClaimAsk(message.channelId, message.ts);
-  if (claimed === false) {
-    log.info("inbound ask dedupe drop", {
-      kind,
-      channel: message.channelId,
-      message_ts: message.ts,
-      continuation,
-      event_id: args.eventId,
-    });
-    return;
-  }
-
-  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,
-    });
-  }
-
-  // A control-plane placeholder is turn scaffolding, not thread history: the
-  // guest posts the reply over that exact ts, so hydrating it would feed the
-  // model its own "still working" line as an already-sent reply.
-  const excludeThreadTimestamps = [
-    message.ts,
-    ...(handoffInThread === undefined ? [] : [handoffInThread.messageTs]),
-    ...(decision.excludeThreadTimestamps ?? []),
-  ];
-  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 =
-    loadThread && hasSession && args.getContinuationLastBotMessageTs !== undefined
-      ? await args.getContinuationLastBotMessageTs(continuation)
-      : undefined;
-
-  // 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,
-        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,
-      channel: message.channelId,
-      thread_ts: message.threadTs,
-      chars: threadContext.length,
-      event_id: args.eventId,
-      ...(afterTs === undefined ? {} : { after_ts: afterTs }),
-    });
-  }
-
-  const prompt = [
-    formatSlackContextBlock({
-      userId: message.author?.userId ?? "",
-      channelId: message.channelId,
-      threadTs: message.threadTs,
-      ...(message.author?.userName === undefined ? {} : { userName: message.author.userName }),
-      ...(message.teamId === undefined ? {} : { teamId: message.teamId }),
-    }),
-    ...(threadContext === undefined ? [] : [threadContext]),
-    ...(decision.context ?? []),
-    "",
-    media.userText,
-  ]
-    .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: state as unknown as JsonValue,
-    refreshState: slackWakeChannelState({
-      channelId: message.channelId,
-      threadTs: message.threadTs,
-      teamId: message.teamId ?? null,
-      triggeringUserId: message.author?.userId ?? null,
-      startPainted: paintedStart,
-      placeholderPosted: posted,
-    }),
-    title: decision.title ?? `slack:${message.channelId}:${message.threadTs}`,
-    workspaceDir: decision.workspaceDir,
-    workspaceFiles: media.workspaceFiles,
-    images: media.images,
-    cloud: decision.cloud,
-    sdkAgentId: decision.sdkAgentId,
-  };
-
-  try {
-    const session = await args.send(prompt, sendOptions);
-    if (isDeferredChannelSession(session)) {
-      log.info("session send captured (hosted admission)", {
-        kind,
-        continuation,
-        channel: message.channelId,
-        thread_ts: message.threadTs,
-        event_id: args.eventId,
-      });
-      return;
-    }
-    log.info(session.coalesced === true ? "session coalesced" : "session start", {
-      kind,
-      session: session.id,
-      is_new: session.isNew,
-      coalesced: session.coalesced === true,
-      continuation,
-      channel: message.channelId,
-      thread_ts: message.threadTs,
-      event_id: args.eventId,
-    });
-    // 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,
-        channel: message.channelId,
-        thread_ts: message.threadTs,
-        continuation,
-        event_id: args.eventId,
-      });
-      if (!steeringEnabled()) {
-        try {
-          await args.host.slackNudges?.append({
-            continuationKey: continuation,
-            sourceTs: message.ts,
-            text: media.userText,
-            author: message.author?.userName,
-          });
-        } catch (nudgeError) {
-          log.warn("nudge append failed", {
-            error: nudgeError instanceof Error ? nudgeError.message : String(nudgeError),
-            continuation,
-            event_id: args.eventId,
-          });
-        }
-      }
-      try {
-        if (args.followUpStatus !== false) {
-          await binding.thread.startTyping(FOLLOWUP_TYPING);
-        }
-      } catch (typingError) {
-        log.error(
-          `follow-up typing failed: ${
-            typingError instanceof Error ? typingError.message : String(typingError)
-          }`,
-          {
-            channel: message.channelId,
-            thread_ts: message.threadTs,
-            event_id: args.eventId,
-          },
-        );
-      }
-    }
-  } 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)}`,
-      {
-        channel: message.channelId,
-        thread_ts: message.threadTs,
-        continuation,
-        event_id: args.eventId,
-      },
-    );
-  } finally {
-    if (placeholder !== undefined) {
-      await placeholder.done;
-    }
-  }
-}
-
-/**
- * Parse an Events API body (or Socket Mode `events_api` payload) and dispatch
- * app_mention / DM / reaction handlers. Deduplicates by `event_id` when
- * present. Returns true when a handler was scheduled.
- */
-export function dispatchInboundFromEventBody(
-  body: unknown,
-  deps: SlackInboundDispatchDeps,
-): 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 };
-    if (typeof root.event_id === "string" && root.event_id.length > 0) {
-      eventId = root.event_id;
-      if (!deps.eventIds.tryHandle(root.event_id)) {
-        log.debug("inbound dedupe drop", { event_id: eventId });
-        retractUnscheduledHandoff();
-        return false;
-      }
-    }
-  }
-
-  const mention = parseAppMentionEvent(body, {
-    includeBotAuthored: deps.botMentionGate !== undefined,
-  });
-  if (mention !== null) {
-    if (deps.mentionsEnabled === false) {
-      log.debug("inbound ignored (mentions disabled)", { event_id: eventId });
-      retractUnscheduledHandoff();
-      return false;
-    }
-    if (mention.author?.isBot === true) {
-      // Parse only admits bot-authored mentions when a gate exists, so the
-      // fallback is defensive.
-      const verdict = deps.botMentionGate?.evaluate(mention) ?? {
-        allow: false as const,
-        reason: "bot mentions not enabled",
-      };
-      if (!verdict.allow) {
-        log.info("bot mention dropped", {
-          event_id: eventId,
-          channel: mention.channelId,
-          thread_ts: mention.threadTs,
-          from_bot: mention.author.botId ?? mention.author.userId,
-          reason: verdict.reason,
-        });
-        retractUnscheduledHandoff();
-        return false;
-      }
-    }
-    scheduleInbound(deps, log, {
-      kind: "app_mention",
-      message: mention,
-      handler: deps.onAppMention,
-      evalCommandsEnabled: deps.evalCommandsEnabled,
-      eventId,
-      platformHandoff: deps.platformHandoff,
-    });
-    return true;
-  }
-
-  const dm = parseDirectMessageEvent(body);
-  if (dm !== null) {
-    if (deps.directMessagesEnabled === false) {
-      log.debug("inbound ignored (direct messages disabled)", {
-        event_id: eventId,
-      });
-      retractUnscheduledHandoff();
-      return false;
-    }
-    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) {
-    retractUnscheduledHandoff();
-    scheduleInbound(deps, log, {
-      kind: "reaction_added",
-      message: reaction,
-      handler: deps.onReactionAdded,
-      evalCommandsEnabled: false,
-      eventId,
-    });
-    return true;
-  }
-
-  const home = parseAppHomeOpened(body);
-  if (home !== null) {
-    const prompts = deps.suggestedPrompts ?? [];
-    log.info("app home opened", {
-      channel: home.channelId,
-      tab: home.tab,
-      user: home.userId,
-      event_id: eventId,
-    });
-    if (home.tab === "messages" && prompts.length > 0) {
-      deps.waitUntil(
-        maybeSetSuggestedPrompts({
-          botToken: deps.credentials?.botToken,
-          channelId: home.channelId,
-          prompts,
-          title: deps.suggestedPromptsTitle,
-          log,
-        }),
-      );
-    }
-    return true;
-  }
-
-  const assistantThread = parseAssistantThreadStarted(body);
-  if (assistantThread !== null) {
-    const prompts = deps.suggestedPrompts ?? [];
-    log.info("assistant thread started", {
-      channel: assistantThread.channelId,
-      thread_ts: assistantThread.threadTs,
-      user: assistantThread.userId,
-      event_id: eventId,
-    });
-    if (prompts.length > 0) {
-      deps.waitUntil(
-        maybeSetSuggestedPrompts({
-          botToken: deps.credentials?.botToken,
-          channelId: assistantThread.channelId,
-          threadTs: assistantThread.threadTs,
-          prompts,
-          title: deps.suggestedPromptsTitle,
-          log,
-        }),
-      );
-    }
-    return true;
-  }
-
-  if (deps.channelWatch !== undefined) {
-    // Parse keeps bot-authored posts; the watcher enforces the per-channel
-    // policy (includeBotPosts, own-post loop safety) with skip logging.
-    const channelEvent = parseChannelMessageEvent(body, {
-      includeBotAuthored: true,
-    });
-    if (channelEvent !== null) {
-      retractUnscheduledHandoff();
-      return deps.channelWatch.handle(channelEvent, eventId);
-    }
-  }
-
-  log.debug("inbound ignored (unhandled event shape)", {
-    ...describeSlackEventShape(body),
-    event_id: eventId,
-  });
-  retractUnscheduledHandoff();
-  return false;
-}