@cursor/july 0.1.108 → 0.1.111

package/src/channels/slack/reply-options.ts

@@ -4,7 +4,9 @@
  * the default event handlers read.
  */
 
+import { emojiName } from "./agentic-signals.js";
 import { SLACK_DEFAULT_LOADING_MESSAGES } from "./constants.js";
+import type { SlackReplyFooter } from "./footer.js";
 import { defaultToolCardDetails } from "./tool-cards.js";
 import type {
   SlackChannelOptions,
@@ -16,7 +18,7 @@ import type {
   SlackToolResult,
 } from "./types.js";
 
-export type SlackReplyMode = "post" | "stream";
+export type SlackReplyMode = "post" | "stream" | "agentic";
 
 export interface ResolvedSlackStatus {
   reasoning: boolean;
@@ -38,14 +40,50 @@ export interface ResolvedSlackReasoningCard {
 
 export interface ResolvedSlackReply {
   mode: SlackReplyMode;
+  /** Parent reaction at turn start. Set for `agentic`. */
+  ack?: string;
+  /** Exact replaceable first line. Set when `reply.placeholder` is authored. */
+  placeholder?: string;
   status: ResolvedSlackStatus;
   toolCards: false | ResolvedSlackToolCards;
   reasoningCard: false | ResolvedSlackReasoningCard;
   toolLabel: (toolName: string) => string;
+  footer?: SlackReplyFooter;
   /** Author-facing notices about deprecated options that were honored. */
   deprecations: string[];
 }
 
+export const DEFAULT_ACK = "eyes";
+const STATIC_PLACEHOLDER_ERROR =
+  "slackChannel reply.placeholder must be one static 2-80 character line without mentions.";
+
+function resolveAck(raw: string | undefined): string {
+  if (raw === undefined) {
+    return DEFAULT_ACK;
+  }
+  return emojiName(raw) ?? DEFAULT_ACK;
+}
+
+function resolvePlaceholder(option: string | undefined): string | undefined {
+  if (option === undefined) {
+    return undefined;
+  }
+  if (typeof option !== "string") {
+    throw new Error(STATIC_PLACEHOLDER_ERROR);
+  }
+  const line = option.trim();
+  if (
+    line.length < 2 ||
+    line.length > 80 ||
+    line.includes("\n") ||
+    line.includes("\r") ||
+    /<!|<@/.test(line)
+  ) {
+    throw new Error(STATIC_PLACEHOLDER_ERROR);
+  }
+  return line;
+}
+
 export const DEFAULT_REASONING_CARD_TITLE = "Thinking";
 /** A modest share of `SLACK_MARKDOWN_TEXT_MAX_LEN`, which the whole streamed message shares. */
 export const DEFAULT_REASONING_CARD_MAX_CHARS = 1500;
@@ -59,11 +97,11 @@ function resolveToolLabel(
   labels: SlackToolLabels | undefined
 ): (toolName: string) => string {
   if (labels === undefined) {
-    return (toolName) => toolName;
+    return toolName => toolName;
   }
   const lookup =
     typeof labels === "function" ? labels : (name: string) => labels[name];
-  return (toolName) => {
+  return toolName => {
     const label = lookup(toolName);
     return label === undefined || label === "" ? toolName : label;
   };
@@ -72,14 +110,14 @@ function resolveToolLabel(
 function defaultToolStatusLine(
   toolLabel: (toolName: string) => string
 ): (calls: readonly SlackToolCall[]) => string {
-  return (calls) => {
-    const names = [...new Set(calls.map((call) => toolLabel(call.toolName)))];
+  return calls => {
+    const names = [...new Set(calls.map(call => toolLabel(call.toolName)))];
     return `Running ${names.join(", ")}…`;
   };
 }
 
 function resolveIdle(idle: readonly string[] | undefined): string[] {
-  const cleaned = (idle ?? []).filter((line) => line.trim() !== "");
+  const cleaned = (idle ?? []).filter(line => line.trim() !== "");
   return cleaned.length > 0 ? cleaned : [...SLACK_DEFAULT_LOADING_MESSAGES];
 }
 
@@ -185,7 +223,7 @@ export function resolveSlackReply(options: ReplyInputs): ResolvedSlackReply {
     if (legacy !== null) {
       const ignored = (
         ["streaming", "thinkingSteps", "loadingMessages"] as const
-      ).filter((key) => options[key] !== undefined);
+      ).filter(key => options[key] !== undefined);
       deprecations.push(
         `slackChannel({ ${ignored.join(", ")} }) is ignored because reply is set; remove the deprecated option${ignored.length === 1 ? "" : "s"}.`
       );
@@ -197,15 +235,31 @@ export function resolveSlackReply(options: ReplyInputs): ResolvedSlackReply {
 
   const toolLabel = resolveToolLabel(options.toolLabels);
   const statusInput = reply.status ?? {};
+  const tools =
+    statusInput.tools === false
+      ? false
+      : typeof statusInput.tools === "function"
+        ? statusInput.tools
+        : defaultToolStatusLine(toolLabel);
+  const reasoning = statusInput.reasoning !== false;
+  if (reply.mode === "agentic") {
+    return {
+      mode: "agentic",
+      ack: resolveAck(reply.ack),
+      placeholder: resolvePlaceholder(reply.placeholder),
+      status: { reasoning, tools, idle: [] },
+      toolCards: false,
+      reasoningCard: false,
+      toolLabel,
+      footer: reply.footer,
+      deprecations,
+    };
+  }
+
   const status: ResolvedSlackStatus = {
-    reasoning: statusInput.reasoning !== false,
-    tools:
-      statusInput.tools === false
-        ? false
-        : typeof statusInput.tools === "function"
-          ? statusInput.tools
-          : defaultToolStatusLine(toolLabel),
-    idle: resolveIdle(statusInput.idle),
+    reasoning,
+    tools,
+    idle: resolveIdle(reply.status?.idle),
   };
 
   if (reply.mode === "post") {
@@ -215,6 +269,7 @@ export function resolveSlackReply(options: ReplyInputs): ResolvedSlackReply {
       toolCards: false,
       reasoningCard: false,
       toolLabel,
+      footer: reply.footer,
       deprecations,
     };
   }
@@ -224,6 +279,7 @@ export function resolveSlackReply(options: ReplyInputs): ResolvedSlackReply {
     toolCards: resolveToolCards(reply),
     reasoningCard: resolveReasoningCard(reply.reasoningCard),
     toolLabel,
+    footer: reply.footer,
     deprecations,
   };
 }

package/src/channels/slack/setup.ts

@@ -97,7 +97,7 @@ export function initialSlackSetupStatus(options: {
     envPrefix: options.envPrefix ?? null,
     envKeys: options.envKeys,
     phases: Object.fromEntries(
-      SLACK_SETUP_PHASES.map((phase) => [phase.id, phase.id === completed])
+      SLACK_SETUP_PHASES.map(phase => [phase.id, phase.id === completed])
     ),
   };
 }

package/src/channels/slack/slack-channel.ts

@@ -1,17 +1,30 @@
 /**
- * `slackChannel()` — platform channel pack for Slack (Socket Mode).
+ * `slackChannel()` — platform channel pack for Slack.
  *
- * Inbound events arrive over a WebSocket (`SLACK_APP_TOKEN`); no public
- * Request URL or Events HTTP route is required. When `toolApprovals`
- * is enabled, Approve/Deny buttons arrive as Socket Mode `interactive`
- * envelopes.
+ * Local / self-hosted transport is Socket Mode: inbound events arrive over
+ * a WebSocket (`SLACK_APP_TOKEN`); no public Request URL or Events HTTP
+ * route is required. When `toolApprovals` is enabled, Approve/Deny buttons
+ * arrive as Socket Mode `interactive` envelopes.
+ *
+ * Hosted v2 transport is the control plane's Events API ingest: the CP
+ * verifies the managed app's signature, fans out on the declared
+ * `slackEventTypes` (`app_mention`, `message`), and delivers the full
+ * `event_callback` body through hosted admission — the attached adapter
+ * routes it through the same inbound dispatch as Socket Mode. Hosted pods
+ * skip Socket Mode entirely, so they never need an app token.
  */
 
 import { allowAll, defineChannel } from "../../channels.js";
+import {
+  skipped,
+  withPropagatingBackgroundErrors,
+} from "../../internal/channel-dispatch.js";
 import {
   continuationSource,
   normalizeIdentity,
 } from "../../internal/continuation-identity.js";
+import { AGENT_SERVE_GENERATION_ENV_VAR } from "../../internal/cursor-relay-core.js";
+import { attachHostedAdmissionAdapter } from "../../internal/hosted-admission-adapter.js";
 import type {
   ArtifactsApi,
   ChannelDefinition,
@@ -22,6 +35,7 @@ import type {
   SendMessageFn,
 } from "../../types.js";
 import { slackContinuationKey } from "./api.js";
+import { defaultSlackAuth } from "./auth.js";
 import {
   normalizeBotMentionAllowlist,
   SLACK_BOT_MENTION_DEFAULTS,
@@ -44,20 +58,22 @@ import {
   createDefaultOnChannelPost,
   createDefaultOnInbound,
   resolveSlackBlockExternals,
+  resolveSlackRespondTo,
 } from "./defaults.js";
 import {
   dispatchInboundFromEventBody,
   dispatchInboundMessage,
   emptySlackChannelState,
   type SlackInboundDispatchDeps,
+  slackWakeChannelState,
 } from "./dispatch.js";
-import { createEventIdDedupe } from "./event-id-dedupe.js";
+import { createEventIdDedupe, type EventIdDedupe } from "./event-id-dedupe.js";
 import {
   dispatchBlockAction,
   dispatchInteractiveFromPayload,
 } from "./interactive.js";
 import { createSlackLogger, type SlackLog } from "./log.js";
-import { resolveSlackReply } from "./reply-options.js";
+import { DEFAULT_ACK, resolveSlackReply } from "./reply-options.js";
 import {
   type SlackSocketModeHandle,
   type SlackSocketModeOptions,
@@ -65,9 +81,11 @@ import {
 } from "./socket-mode.js";
 import { buildToolApprovalEvents } from "./tool-approval-events.js";
 import type {
+  SlackAccessPolicy,
   SlackChannelOptions,
   SlackChannelState,
   SlackCredentials,
+  SlackMessageHandler,
 } from "./types.js";
 
 /** Options used to construct a slack channel — for host-level credential binding. */
@@ -112,6 +130,17 @@ export function resolveDedicatedSlackHostBinding(
   return undefined;
 }
 
+function authOnlyInbound(
+  policy: SlackAccessPolicy | undefined,
+  engagement?: "channel_post"
+): SlackMessageHandler {
+  const respondTo = resolveSlackRespondTo(policy);
+  return async (ctx, message) => {
+    const auth = defaultSlackAuth(message, ctx, { engagement, respondTo });
+    return auth === null ? null : { auth };
+  };
+}
+
 /**
  * Create a Slack channel. Author as `agent/channels/slack.ts` default export.
  *
@@ -133,21 +162,26 @@ export function slackChannel(
   const loadingMessages = reply.status.idle;
   const policy = options.policy;
   const blockExternals = resolveSlackBlockExternals(policy);
-  const defaultInbound = createDefaultOnInbound(loadingMessages, policy);
+  const silent = reply.mode === "agentic";
+  const defaultInbound = silent
+    ? authOnlyInbound(policy)
+    : createDefaultOnInbound(loadingMessages, policy);
   const onAppMention = options.onAppMention ?? defaultInbound;
   const onDirectMessage = options.onDirectMessage ?? defaultInbound;
   const onReactionAdded = options.onReactionAdded;
   const onChannelPost =
     options.onChannelPost ??
-    createDefaultOnChannelPost(loadingMessages, policy);
+    (silent
+      ? authOnlyInbound(policy, "channel_post")
+      : createDefaultOnChannelPost(loadingMessages, policy));
   const engagement = options.engagement ?? {};
   const mentionsEnabled = engagement.mentions !== false;
   const directMessagesEnabled = engagement.directMessages !== false;
   const evalCommandsEnabled = options.evalCommands !== false;
-  const followUpStatus = options.followUpStatus !== false;
+  const followUpStatus = options.followUpStatus ?? !silent;
   const channelPosts = engagement.channelPosts;
   if (channelPosts !== undefined) {
-    const entries = channelPosts.allow.filter((entry) => entry.trim() !== "");
+    const entries = channelPosts.allow.filter(entry => entry.trim() !== "");
     if (entries.length === 0) {
       throw new Error(
         'slackChannel engagement.channelPosts.allow must list at least one channel (id, #name, or "*").'
@@ -159,6 +193,18 @@ export function slackChannel(
     normalizeBotMentionAllowlist(botMentions.allowFrom);
   }
   const eventIds = createEventIdDedupe();
+  // Hosted v2 event capability, matching what the engagement flags can
+  // dispatch: mentions ride `app_mention`; DMs and watched channel posts
+  // both arrive as `message`. Membership of `slack.thread/v2` admits
+  // exactly these two, so `reaction_added` (hosted follow-up only inside
+  // an existing thread) is deliberately not declared.
+  const slackEventTypes: string[] = [];
+  if (mentionsEnabled) {
+    slackEventTypes.push("app_mention");
+  }
+  if (directMessagesEnabled || channelPosts !== undefined) {
+    slackEventTypes.push("message");
+  }
   const toolApprovals = options.toolApprovals === true;
   const interactivity = options.interactivity === true;
   const onBlockAction = options.onBlockAction;
@@ -188,7 +234,10 @@ export function slackChannel(
     );
   }
   if (toolApprovals) {
-    Object.assign(events, buildToolApprovalEvents({ credentials, getLog }));
+    Object.assign(
+      events,
+      buildToolApprovalEvents({ credentials, getLog, status: !silent })
+    );
   }
   Object.assign(events, options.events);
 
@@ -201,6 +250,9 @@ export function slackChannel(
     waitUntil: (promise: Promise<unknown>) => void;
     host: HostContext;
     artifacts: ArtifactsApi;
+    /** Override the channel-level dedupe (hosted admission passes a fresh one). */
+    eventIds?: EventIdDedupe;
+    propagateHandlerErrors?: boolean;
     hasContinuationSession?: (continuationToken: string) => Promise<boolean>;
     isContinuationBusy?: (continuationToken: string) => Promise<boolean>;
     getContinuationLastBotMessageTs?: (
@@ -216,7 +268,8 @@ export function slackChannel(
       onDirectMessage,
       ...(onReactionAdded === undefined ? {} : { onReactionAdded }),
       credentials,
-      eventIds,
+      eventIds: args.eventIds ?? eventIds,
+      propagateHandlerErrors: args.propagateHandlerErrors,
       host: args.host,
       artifacts: args.artifacts,
       log: getLog(),
@@ -224,6 +277,8 @@ export function slackChannel(
       directMessagesEnabled,
       evalCommandsEnabled,
       followUpStatus,
+      ack: reply.ack,
+      placeholder: reply.placeholder,
       blockExternals,
       ...(args.hasContinuationSession === undefined
         ? {}
@@ -253,6 +308,21 @@ export function slackChannel(
     routes: [],
     meta: {
       kind: "slack",
+      // Omitted (not empty) when nothing dispatches, so fanout never
+      // materializes a subscription with no event types.
+      slackEventTypes:
+        slackEventTypes.length === 0 ? undefined : slackEventTypes,
+      ...(reply.mode === "agentic"
+        ? {
+            slackReply: {
+              mode: "agentic" as const,
+              ack: reply.ack ?? DEFAULT_ACK,
+              ...(reply.placeholder === undefined
+                ? {}
+                : { placeholder: reply.placeholder }),
+            },
+          }
+        : {}),
       ...(channelPosts === undefined
         ? {}
         : { slackChannelPosts: [...channelPosts.allow] }),
@@ -283,6 +353,11 @@ export function slackChannel(
         team: teamId,
       });
 
+      const state = emptySlackChannelState({
+        channelId,
+        threadTs,
+        teamId: teamId ?? null,
+      }) as unknown as JsonValue;
       return send(input.message, {
         auth: input.auth,
         admission: "coalesce",
@@ -297,17 +372,29 @@ export function slackChannel(
           : {
               continuationToken: slackContinuationKey(channelId, threadTs),
             }),
-        state: emptySlackChannelState({
+        state,
+        refreshState: slackWakeChannelState({
           channelId,
           threadTs,
           teamId: teamId ?? null,
-        }) as unknown as JsonValue,
+        }),
       });
     },
     events,
     async onStart(args) {
       runtime.log = createSlackLogger(args.logger ?? options.logger);
 
+      // Cursor-managed v2 receives inbound events through the control-plane
+      // adapter attached below. Do not also start (or warn about) the local
+      // Socket Mode transport: hosted outbound replies need only the bot token.
+      if (
+        args.architecture === "v2" &&
+        process.env[AGENT_SERVE_GENERATION_ENV_VAR] !== undefined
+      ) {
+        getLog().info("channel start", { transport: "events-api" });
+        return;
+      }
+
       getLog().info("channel start", { transport: "socket" });
 
       const appToken = await tryResolveAppToken(credentials);
@@ -417,6 +504,7 @@ export function slackChannel(
                   log: getLog(),
                   evalCommandsEnabled,
                   followUpStatus,
+                  ack: reply.ack,
                   blockExternals,
                   continuation: options.continuation,
                   ...(args.hasContinuationSession === undefined
@@ -453,8 +541,8 @@ export function slackChannel(
 
       const socketOptions: SlackSocketModeOptions = {
         appToken,
-        logger: (line) => getLog().write(line),
-        onEvent: (payload) => {
+        logger: line => getLog().write(line),
+        onEvent: payload => {
           dispatchInboundFromEventBody(
             payload,
             inboundDeps({
@@ -482,7 +570,7 @@ export function slackChannel(
         },
       };
       if (routeInteractive) {
-        socketOptions.onInteractive = async (payload) => {
+        socketOptions.onInteractive = async payload => {
           // Framework tool-approval Approve/Deny clicks resolve first;
           // anything else (including approval-shaped clicks whose value
           // fails to parse) falls through to the author's block-action hook.
@@ -551,6 +639,40 @@ export function slackChannel(
   });
 
   slackChannelOptionsByDefinition.set(definition, options);
+  attachHostedAdmissionAdapter(definition, {
+    kind: "slack",
+    prepareArgs: withPropagatingBackgroundErrors,
+    // The payload is the full `event_callback` body the CP verified — the
+    // same shape Socket Mode unwraps — so it routes through the same
+    // inbound dispatch. Outcomes: a captured `send` overrides the fallback
+    // tag below, so `skipped` surfaces when the engagement rules declined
+    // (`not_engaged`) or no handler takes the shape (`not_dispatchable`);
+    // a throwing handler rejects `waitUntil` (propagateHandlerErrors) and
+    // hosted admission answers a retryable 503, like the PR adapters.
+    // The channel-level event_id dedupe is deliberately bypassed with a
+    // fresh instance per delivery: the control plane's app-scoped ingress
+    // claim already dedupes Slack retries, and on a warm pod the local set
+    // would otherwise swallow the control plane's own retry of a delivery
+    // that failed after the id was marked handled.
+    dispatch: async ({ payload, args }) => {
+      const dispatched = dispatchInboundFromEventBody(
+        payload,
+        inboundDeps({
+          send: args.send,
+          waitUntil: args.waitUntil,
+          host: args.host,
+          artifacts: args.artifacts,
+          eventIds: createEventIdDedupe(),
+          propagateHandlerErrors: true,
+          hasContinuationSession: args.hasContinuationSession,
+          isContinuationBusy: args.isContinuationBusy,
+          getContinuationLastBotMessageTs: args.getContinuationLastBotMessageTs,
+          interruptContinuation: args.interruptContinuation,
+        })
+      );
+      return skipped(dispatched ? "not_engaged" : "not_dispatchable");
+    },
+  });
 
   return definition;
 }

package/src/channels/slack/socket-mode.ts

@@ -38,7 +38,7 @@ function createBridgeLogger(write: (line: string) => void): Logger {
       return;
     }
     const text = msgs
-      .map((m) => (typeof m === "string" ? m : JSON.stringify(m)))
+      .map(m => (typeof m === "string" ? m : JSON.stringify(m)))
       .join(" ");
     write(`${SLACK_LOG_PREFIX} Socket Mode ${text}`);
   };
@@ -69,7 +69,7 @@ function invokeHandler(
       result !== undefined &&
       typeof (result as Promise<void>).then === "function"
     ) {
-      void Promise.resolve(result).catch((error) => {
+      void Promise.resolve(result).catch(error => {
         log(
           `${SLACK_LOG_PREFIX} Socket Mode ${label} failed: ${errorMessage(error)}`
         );

package/src/channels/slack/thread-context.ts

@@ -47,7 +47,7 @@ export function trimThreadMessagesForPrompt(
   }
 ): JsonRecord[] {
   const exclude = excludeTimestampSet(options.excludeTs);
-  const filtered = messages.filter((message) => {
+  const filtered = messages.filter(message => {
     const ts = asString(message.ts);
     if (ts === undefined || ts === "") {
       return false;
@@ -61,7 +61,7 @@ export function trimThreadMessagesForPrompt(
     return filtered;
   }
   const parentIndex = filtered.findIndex(
-    (message) => asString(message.ts) === options.threadTs
+    message => asString(message.ts) === options.threadTs
   );
   const parent = parentIndex >= 0 ? filtered[parentIndex]! : undefined;
   const withoutParent =
@@ -77,7 +77,7 @@ export function trimThreadMessagesForPrompt(
   if (parent === undefined) {
     return tail;
   }
-  if (tail.some((message) => asString(message.ts) === options.threadTs)) {
+  if (tail.some(message => asString(message.ts) === options.threadTs)) {
     return tail;
   }
   return [parent, ...tail];
@@ -227,7 +227,7 @@ export function selectThreadDeltaMessages(
 ): JsonRecord[] {
   const exclude = excludeTimestampSet(options.excludeTs);
   const afterTs = options.afterTs?.trim() ?? "";
-  return messages.filter((message) => {
+  return messages.filter(message => {
     const ts = asString(message.ts);
     if (ts === undefined || ts === "") {
       return false;
@@ -259,7 +259,7 @@ export function formatSlackThreadContextBlock(
           limit: DEFAULT_REPLY_LIMIT,
           excludeTs: options?.excludeTs,
         })
-      : messages.filter((message) => {
+      : messages.filter(message => {
           const ts = asString(message.ts);
           if (ts === undefined || ts === "") {
             return false;

package/src/channels/slack/tool-approval-events.ts

@@ -35,6 +35,11 @@ export interface BuildToolApprovalEventsOptions {
   credentials?: SlackCredentials;
   /** Resolved per-call so channel onStart can rebind the server logger. */
   getLog?: () => SlackLog;
+  /**
+   * Progress chip around park/resume. Defaults to `true`.
+   * When false, park writes no chip and resolve clears it.
+   */
+  status?: boolean;
 }
 
 /**
@@ -46,6 +51,29 @@ export function buildToolApprovalEvents(
 ): ChannelEventHandlers<SlackChannelState> {
   const botToken = options.credentials?.botToken;
   const getLog = options.getLog ?? (() => defaultSlackLog);
+  const status = options.status !== false;
+
+  async function resolveChip(state: SlackChannelState): Promise<void> {
+    if (state.channelId === null || state.threadTs === null) {
+      return;
+    }
+    if (status) {
+      await setThreadStatus({
+        botToken,
+        channelId: state.channelId,
+        threadTs: state.threadTs,
+        status: "Working…",
+        loadingMessages: [...SLACK_DEFAULT_LOADING_MESSAGES],
+      });
+      return;
+    }
+    await setThreadStatus({
+      botToken,
+      channelId: state.channelId,
+      threadTs: state.threadTs,
+      status: "",
+    });
+  }
 
   return {
     async "action.approval_requested"(event, channel, ctx) {
@@ -72,16 +100,18 @@ export function buildToolApprovalEvents(
           ...(state.approvalMessageByCallId ?? {}),
           [event.data.callId]: posted.ts,
         };
-        await setThreadStatus({
-          botToken,
-          channelId: state.channelId,
-          threadTs: state.threadTs,
-          status: "Awaiting approval…",
-          loadingMessages: [
-            "Awaiting approval…",
-            ...SLACK_DEFAULT_LOADING_MESSAGES,
-          ],
-        });
+        if (status) {
+          await setThreadStatus({
+            botToken,
+            channelId: state.channelId,
+            threadTs: state.threadTs,
+            status: "Awaiting approval…",
+            loadingMessages: [
+              "Awaiting approval…",
+              ...SLACK_DEFAULT_LOADING_MESSAGES,
+            ],
+          });
+        }
         log.info("approval card posted", {
           call_id: event.data.callId,
           tool: event.data.toolName,
@@ -121,15 +151,7 @@ export function buildToolApprovalEvents(
         delete next[event.data.callId];
         channel.state.approvalMessageByCallId = next;
       }
-      if (state.channelId !== null && state.threadTs !== null) {
-        await setThreadStatus({
-          botToken,
-          channelId: state.channelId,
-          threadTs: state.threadTs,
-          status: "Working…",
-          loadingMessages: [...SLACK_DEFAULT_LOADING_MESSAGES],
-        });
-      }
+      await resolveChip(state);
       log.info("approval resolved in slack", {
         call_id: event.data.callId,
         decision: event.data.decision,
@@ -161,16 +183,18 @@ export function buildToolApprovalEvents(
           ...(state.approvalMessageByCallId ?? {}),
           [event.data.callId]: posted.ts,
         };
-        await setThreadStatus({
-          botToken,
-          channelId: state.channelId,
-          threadTs: state.threadTs,
-          status: authThreadStatus(event.data.connection),
-          loadingMessages: [
-            authThreadStatus(event.data.connection),
-            ...SLACK_DEFAULT_LOADING_MESSAGES,
-          ],
-        });
+        if (status) {
+          await setThreadStatus({
+            botToken,
+            channelId: state.channelId,
+            threadTs: state.threadTs,
+            status: authThreadStatus(event.data.connection),
+            loadingMessages: [
+              authThreadStatus(event.data.connection),
+              ...SLACK_DEFAULT_LOADING_MESSAGES,
+            ],
+          });
+        }
         log.info("auth card posted", {
           call_id: event.data.callId,
           connection: event.data.connection,
@@ -211,15 +235,7 @@ export function buildToolApprovalEvents(
         delete next[event.data.callId];
         channel.state.approvalMessageByCallId = next;
       }
-      if (state.channelId !== null && state.threadTs !== null) {
-        await setThreadStatus({
-          botToken,
-          channelId: state.channelId,
-          threadTs: state.threadTs,
-          status: "Working…",
-          loadingMessages: [...SLACK_DEFAULT_LOADING_MESSAGES],
-        });
-      }
+      await resolveChip(state);
       log.info("auth resolved in slack", {
         call_id: event.data.callId,
         decision: event.data.decision,