@cursor/july 0.1.109 → 0.1.111

package/src/channels/slack/dispatch.ts

@@ -10,6 +10,7 @@ import {
 } from "../../internal/continuation-identity.js";
 import { isDeferredChannelSession } from "../../internal/deferred-channel-session.js";
 import { routeLocalIngressContinuation } from "../../internal/local-ingress.js";
+import { isSlackImChannel } from "../../internal/slack-thread-key.js";
 import { steeringEnabled } from "../../internal/steering.js";
 import type {
   ArtifactsApi,
@@ -47,6 +48,8 @@ import {
   parseReactionAddedEvent,
 } from "./inbound.js";
 import { defaultSlackLog, type SlackLog } from "./log.js";
+import { paintTurnStart, retractTurnStart } from "./paint-start.js";
+import { startPlaceholder } from "./placeholder.js";
 import { isWholeMessageStop } from "./stop.js";
 import {
   loadSlackThreadContextBlock,
@@ -138,10 +141,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 +210,21 @@ 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`. Overlay claims that slot.
+   */
+  placeholder?: string;
   /**
    * 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 +272,65 @@ 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;
+  }
+): 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 }),
+    })
+  );
+}
+
 function slackSessionContinuation(
   identity: ContinuationIdentity | undefined,
   channelId: string,
@@ -276,6 +384,10 @@ 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.propagateHandlerErrors}. */
   propagateHandlerErrors?: boolean;
 }): Promise<void> {
@@ -301,9 +413,10 @@ export async function dispatchInboundMessage(args: {
     team: message.teamId,
   });
 
+  const userId = message.author?.userId ?? "";
+  const teamId = message.teamId;
+  let membership: Promise<boolean> | undefined;
   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,
@@ -314,36 +427,44 @@ export async function dispatchInboundMessage(args: {
       });
       return;
     }
-    if (
-      await isExternalSlackSender({
-        botToken: args.credentials?.botToken,
-        slackTeamId: teamId,
-        userId,
-      })
-    ) {
-      log.info("inbound dropped (external sender)", {
-        kind,
-        channel: message.channelId,
-        thread_ts: message.threadTs,
-        user: userId,
-        team: teamId,
-        event_id: args.eventId,
-      });
-      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();
+      return;
+    }
     log.info("stop directive", {
       kind,
       channel: message.channelId,
@@ -367,13 +488,21 @@ export async function dispatchInboundMessage(args: {
   }
 
   // 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();
+      return;
+    }
     log.info("eval directive", {
       kind,
       channel: message.channelId,
@@ -390,16 +519,6 @@ export async function dispatchInboundMessage(args: {
     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);
@@ -441,56 +560,97 @@ 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,
+  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);
+    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 +677,52 @@ 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);
+  const placeholder =
+    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 = 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 +734,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 +759,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 +808,19 @@ export async function dispatchInboundMessage(args: {
     }
   } catch (error) {
     await args.host.slackNudges?.releaseAsk(message.channelId, message.ts);
+    if (placeholder !== undefined) {
+      await placeholder.retract();
+    }
+    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 +832,10 @@ export async function dispatchInboundMessage(args: {
         event_id: args.eventId,
       }
     );
+  } finally {
+    if (placeholder !== undefined) {
+      await placeholder.done;
+    }
   }
 }
 
@@ -681,39 +888,13 @@ export function dispatchInboundFromEventBody(
         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,
+    });
     return true;
   }
 
@@ -725,77 +906,25 @@ export function dispatchInboundFromEventBody(
       });
       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,
+    });
     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 }),
-      })
-    );
+    scheduleInbound(deps, log, {
+      kind: "reaction_added",
+      message: reaction,
+      handler: deps.onReactionAdded,
+      evalCommandsEnabled: false,
+      eventId,
+    });
     return true;
   }
 

package/src/channels/slack/doctor.ts

@@ -340,7 +340,7 @@ export async function runSlackDoctor(
   }
 
   return {
-    ok: checks.every((check) => check.ok),
+    ok: checks.every(check => check.ok),
     checks,
     envKeys,
     notes: [eventSubscriptionNote()],

package/src/channels/slack/eval-directive.ts

@@ -53,7 +53,7 @@ export function parseSlackEvalDirective(
   if (body.length === 0) {
     return null;
   }
-  const tokens = body.split(/\s+/).filter((t) => t.length > 0);
+  const tokens = body.split(/\s+/).filter(t => t.length > 0);
   if (tokens.length === 0 || !/^eval$/i.test(tokens[0] ?? "")) {
     return null;
   }