@cursor/july 0.1.6 → 0.1.8

package/src/channels/slack/dispatch.ts

@@ -2,7 +2,6 @@
  * Shared inbound dispatch for Slack Events API bodies and Socket Mode.
  */
 
-import { SessionBusyError } from "../../internal/session-engine.js";
 import type { HostContext, JsonValue, SendMessageFn } from "../../types.js";
 import { buildSlackBinding, slackContinuationKey } from "./api.js";
 import { firstLineTitle, maybeSetThreadTitle } from "./assistant.js";
@@ -15,6 +14,11 @@ import {
   parseDirectMessageEvent,
 } from "./inbound.js";
 import { defaultSlackLog, type SlackLog } from "./log.js";
+import { isWholeMessageStop } from "./stop.js";
+import {
+  loadSlackThreadContextBlock,
+  loadSlackThreadDeltaBlock,
+} from "./thread-context.js";
 import type {
   SlackChannelState,
   SlackCredentials,
@@ -23,8 +27,7 @@ import type {
   SlackMessageHandler,
 } from "./types.js";
 
-const BUSY_REPLY =
-  "I'm still working on your previous message in this thread — I'll reply when that finishes. Send another message after that.";
+const FOLLOWUP_TYPING = "Saw your follow-up…";
 
 /** Blank per-session adapter state. */
 export function emptySlackChannelState(
@@ -41,6 +44,7 @@ export function emptySlackChannelState(
     streamTs: null,
     streamChannelId: null,
     lastPostedText: null,
+    lastBotMessageTs: null,
     streamingUnavailable: false,
     approvalMessageByCallId: {},
     ...patch,
@@ -62,6 +66,37 @@ export interface SlackInboundDispatchDeps {
   directMessagesEnabled?: boolean;
   /** Opt-in channel watch; absent = channel posts are ignored. */
   channelWatch?: ChannelPostWatcher;
+  /**
+   * When set, full-thread hydration runs only for cold-start turns (no
+   * existing session). Warm turns load a `<slack_thread_delta>` instead.
+   */
+  hasContinuationSession?: (continuationToken: string) => Promise<boolean>;
+  /** True when a turn is already running for this Slack continuation. */
+  isContinuationBusy?: (continuationToken: string) => Promise<boolean>;
+  /**
+   * Warm-delta watermark from session channel state (`lastBotMessageTs`).
+   * When absent, delta falls back to the last matching bot post in-thread.
+   */
+  getContinuationLastBotMessageTs?: (
+    continuationToken: string
+  ) => Promise<string | undefined>;
+  /** Cancel the active turn + clear coalesced nudges for this continuation. */
+  interruptContinuation?: (continuationToken: string) => Promise<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 }),
+    text: message.text,
+  };
 }
 
 export async function dispatchInboundMessage(args: {
@@ -71,6 +106,12 @@ export async function dispatchInboundMessage(args: {
   send: SendMessageFn;
   credentials: SlackCredentials | undefined;
   host: HostContext;
+  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;
 }): Promise<void> {
@@ -95,6 +136,38 @@ export async function dispatchInboundMessage(args: {
     team: message.teamId,
   });
 
+  const continuation = slackContinuationKey(
+    message.channelId,
+    message.threadTs
+  );
+
+  // Whole-message stop: cancel active turn + clear nudges (Benny parity).
+  if (
+    isWholeMessageStop(message.text) ||
+    isWholeMessageStop(message.markdown)
+  ) {
+    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
+    }
+    return;
+  }
+
   if (message.ts === message.threadTs) {
     await maybeSetThreadTitle({
       botToken: args.credentials?.botToken,
@@ -127,7 +200,67 @@ export async function dispatchInboundMessage(args: {
     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;
+  }
+
   const userText = decision.message ?? message.markdown;
+  const excludeThreadTimestamps = [
+    message.ts,
+    ...(decision.excludeThreadTimestamps ?? []),
+  ];
+  const hasSession =
+    args.hasContinuationSession === undefined
+      ? false
+      : await args.hasContinuationSession(continuation);
+  const mergeMessages = [triggeringMergeMessage(message)];
+  const afterTs =
+    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({
+        botToken: args.credentials?.botToken,
+        channelId: message.channelId,
+        threadTs: message.threadTs,
+        excludeTs: excludeThreadTimestamps,
+        mergeMessages,
+        log,
+      });
+  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 ?? "",
@@ -138,6 +271,7 @@ export async function dispatchInboundMessage(args: {
         : { userName: message.author.userName }),
       ...(message.teamId === undefined ? {} : { teamId: message.teamId }),
     }),
+    ...(threadContext === undefined ? [] : [threadContext]),
     ...(decision.context ?? []),
     "",
     userText,
@@ -145,39 +279,43 @@ export async function dispatchInboundMessage(args: {
     .filter((part) => part.length > 0)
     .join("\n");
 
-  const continuation = slackContinuationKey(
-    message.channelId,
-    message.threadTs
-  );
+  const sendOptions = {
+    auth: decision.auth,
+    continuationToken: continuation,
+    admission: "coalesce" as const,
+    coalesceSourceTs: message.ts,
+    state: emptySlackChannelState({
+      channelId: message.channelId,
+      threadTs: message.threadTs,
+      teamId: message.teamId ?? null,
+      triggeringUserId: message.author?.userId ?? null,
+    }) as unknown as JsonValue,
+    title: decision.title ?? `slack:${message.channelId}:${message.threadTs}`,
+    workspaceDir: decision.workspaceDir,
+    workspaceFiles: decision.workspaceFiles,
+    cloud: decision.cloud,
+    sdkAgentId: decision.sdkAgentId,
+  };
 
   try {
-    const session = await args.send(prompt, {
-      auth: decision.auth,
-      continuationToken: continuation,
-      state: emptySlackChannelState({
-        channelId: message.channelId,
-        threadTs: message.threadTs,
-        teamId: message.teamId ?? null,
-        triggeringUserId: message.author?.userId ?? null,
-      }) as unknown as JsonValue,
-      title: decision.title ?? `slack:${message.channelId}:${message.threadTs}`,
-      workspaceDir: decision.workspaceDir,
-      workspaceFiles: decision.workspaceFiles,
-      cloud: decision.cloud,
-      sdkAgentId: decision.sdkAgentId,
-    });
-    log.info("session start", {
-      kind,
-      session: session.id,
-      is_new: session.isNew,
-      continuation,
-      channel: message.channelId,
-      thread_ts: message.threadTs,
-      event_id: args.eventId,
-    });
-  } catch (error) {
-    if (error instanceof SessionBusyError) {
-      log.info("session busy; notifying thread", {
+    const session = await args.send(prompt, sendOptions);
+    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; follow-ups drain into one
+    // boundary turn when it finishes (no mid-turn tool/hook inject).
+    if (session.coalesced === true) {
+      log.info("session busy; coalescing follow-up", {
         kind,
         channel: message.channelId,
         thread_ts: message.threadTs,
@@ -185,11 +323,13 @@ export async function dispatchInboundMessage(args: {
         event_id: args.eventId,
       });
       try {
-        await binding.thread.post(BUSY_REPLY);
-      } catch (postError) {
+        await binding.thread.startTyping(FOLLOWUP_TYPING);
+      } catch (typingError) {
         log.error(
-          `busy reply failed: ${
-            postError instanceof Error ? postError.message : String(postError)
+          `follow-up typing failed: ${
+            typingError instanceof Error
+              ? typingError.message
+              : String(typingError)
           }`,
           {
             channel: message.channelId,
@@ -198,8 +338,9 @@ export async function dispatchInboundMessage(args: {
           }
         );
       }
-      return;
     }
+  } catch (error) {
+    await args.host.slackNudges?.releaseAsk(message.channelId, message.ts);
     log.error(
       `${kind} delivery failed: ${
         error instanceof Error ? error.message : String(error)
@@ -252,6 +393,21 @@ export function dispatchInboundFromEventBody(
         credentials: deps.credentials,
         host: deps.host,
         log,
+        ...(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 }),
       })
     );
@@ -275,6 +431,21 @@ export function dispatchInboundFromEventBody(
         credentials: deps.credentials,
         host: deps.host,
         log,
+        ...(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 }),
       })
     );
@@ -282,7 +453,11 @@ export function dispatchInboundFromEventBody(
   }
 
   if (deps.channelWatch !== undefined) {
-    const channelEvent = parseChannelMessageEvent(body);
+    // 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) {
       return deps.channelWatch.handle(channelEvent, eventId);
     }

package/src/channels/slack/inbound.ts

@@ -31,15 +31,19 @@ export function slackTextToMarkdown(text: string): string {
 
 function parseAuthor(event: JsonRecord): SlackAuthor | undefined {
   const userId = asString(event.user);
-  if (userId === undefined || userId === "") {
+  const botId = asString(event.bot_id);
+  const isBot = botId !== undefined && botId.length > 0;
+  // Webhook-style bot posts can lack `user`; keep a bot author so the
+  // channel watch can attribute (and self-filter) them by `bot_id`.
+  if ((userId === undefined || userId === "") && !isBot) {
     return undefined;
   }
-  const botId = asString(event.bot_id);
   const userName = asString(event.username);
   return {
-    userId,
+    userId: userId ?? "",
     ...(userName === undefined ? {} : { userName }),
-    isBot: botId !== undefined && botId.length > 0,
+    isBot,
+    ...(isBot ? { botId } : {}),
   };
 }
 
@@ -131,15 +135,27 @@ export type SlackChannelMessageEvent =
   | { kind: "edited"; message: SlackMessage }
   | { kind: "deleted"; channelId: string; ts: string };
 
+export interface ParseChannelMessageOptions {
+  /**
+   * Keep bot-authored posts (including `subtype: "bot_message"` webhook
+   * posts) instead of dropping them at parse time. The channel watch
+   * enforces its own per-channel policy ({@link SlackChannelPostsOptions.includeBotPosts})
+   * and always drops the watching bot's own posts.
+   */
+  includeBotAuthored?: boolean;
+}
+
 /**
  * Parse channel / private-channel message events for the opt-in channel
  * watch. Accepts `channel_type === "channel" | "group"` (or `C…`/`G…`
  * channel ids when the type is absent). Bot-authored messages are dropped
- * (loop safety); edits and deletions are surfaced so a debounce window can
- * update or cancel a pending dispatch.
+ * (loop safety) unless `options.includeBotAuthored` is set; edits and
+ * deletions are surfaced so a debounce window can update or cancel a
+ * pending dispatch.
  */
 export function parseChannelMessageEvent(
-  body: unknown
+  body: unknown,
+  options?: ParseChannelMessageOptions
 ): SlackChannelMessageEvent | null {
   const root = asRecord(body);
   if (root === null || root.type !== "event_callback") {
@@ -163,6 +179,7 @@ export function parseChannelMessageEvent(
 
   const teamId = asString(root.team_id);
   const subtype = asString(event.subtype) ?? "";
+  const includeBots = options?.includeBotAuthored === true;
 
   if (subtype === "message_deleted") {
     const deletedTs = asString(event.deleted_ts) ?? "";
@@ -177,7 +194,7 @@ export function parseChannelMessageEvent(
       return null;
     }
     const botId = asString(nested.bot_id);
-    if (botId !== undefined && botId.length > 0) {
+    if (!includeBots && botId !== undefined && botId.length > 0) {
       return null;
     }
     const message = buildSlackMessage(
@@ -187,11 +204,14 @@ export function parseChannelMessageEvent(
     return message === null ? null : { kind: "edited", message };
   }
 
-  if (subtype !== "" && subtype !== "file_share") {
+  const allowedSubtypes = includeBots
+    ? ["", "file_share", "bot_message"]
+    : ["", "file_share"];
+  if (!allowedSubtypes.includes(subtype)) {
     return null;
   }
   const botId = asString(event.bot_id);
-  if (botId !== undefined && botId.length > 0) {
+  if (!includeBots && botId !== undefined && botId.length > 0) {
     return null;
   }
   const message = buildSlackMessage(event, teamId);

package/src/channels/slack/index.ts

@@ -36,10 +36,14 @@ export * from "./interactive.js";
 export * from "./links.js";
 export * from "./log.js";
 export * from "./manifest.js";
+export * from "./nudge-carrier.js";
+export * from "./nudge-store.js";
 export * from "./pr-ref.js";
 export * from "./setup.js";
 export * from "./slack-channel.js";
 export * from "./socket-mode.js";
+export * from "./stop.js";
 export * from "./stream.js";
+export * from "./thread-context.js";
 export * from "./tool-approval-events.js";
 export * from "./types.js";

package/src/channels/slack/live-delivery.ts

@@ -153,6 +153,7 @@ export function createStreamDeliveryStrategy(
       if (stopped.ok) {
         channel.state.streamTs = null;
         channel.state.lastPostedText = text;
+        channel.state.lastBotMessageTs = streamTs;
         log.info("reply delivered via stream", {
           channel: channelId,
           stream_ts: streamTs,

package/src/channels/slack/manifest.ts

@@ -56,6 +56,9 @@ const BOT_SCOPES = [
   "im:read",
   "im:write",
   "mpim:history",
+  // Emoji acknowledgements (e.g. an agent reacting 👀 when it locks onto
+  // a watched-channel post before investigating).
+  "reactions:write",
   "users:read",
 ] as const;
 

package/src/channels/slack/nudge-carrier.ts

@@ -0,0 +1,182 @@
+/**
+ * Harness-side nudge carrier: a small Cursor hooks.json + script that drains
+ * the durable Slack nudge store at tool boundaries (MCP / builtin tools).
+ */
+
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+export const SLACK_NUDGE_ROOT_REL = ".agent-serve/slack-nudge-root";
+export const SLACK_NUDGE_CONTINUATION_REL =
+  ".agent-serve/slack-nudge-continuation";
+export const SLACK_NUDGE_CARRIER_REL = ".agent-serve/slack-nudge-carrier.mjs";
+
+/** Carrier script body — reads nudge-root + continuation, drains pending. */
+export const SLACK_NUDGE_CARRIER_SCRIPT: string = `#!/usr/bin/env node
+import { mkdir, readdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const workspace = dirname(here);
+
+function safeKey(value) {
+  const trimmed = String(value ?? "").trim();
+  if (trimmed === "" || trimmed === "." || trimmed === "..") return "_empty";
+  const sanitized = trimmed
+    .replace(/[^a-zA-Z0-9._-]+/g, "_")
+    .replace(/^\\.+/, "")
+    .replace(/\\.+/g, "_")
+    .slice(0, 180);
+  if (sanitized === "" || sanitized === "." || sanitized === "..") return "_empty";
+  return sanitized;
+}
+
+async function readText(rel) {
+  try {
+    return (await readFile(join(workspace, rel), "utf8")).trim();
+  } catch {
+    return "";
+  }
+}
+
+async function main() {
+  const root = await readText(${JSON.stringify(SLACK_NUDGE_ROOT_REL)});
+  const continuation = await readText(
+    ${JSON.stringify(SLACK_NUDGE_CONTINUATION_REL)}
+  );
+  if (root === "" || continuation === "") {
+    process.stdout.write("{}\\n");
+    return;
+  }
+  const pendingDir = join(root, safeKey(continuation), "pending");
+  const deliveredDir = join(root, safeKey(continuation), "delivered");
+  let names = [];
+  try {
+    names = await readdir(pendingDir);
+  } catch {
+    process.stdout.write("{}\\n");
+    return;
+  }
+  const nudges = [];
+  await mkdir(deliveredDir, { recursive: true });
+  for (const name of names) {
+    if (!name.endsWith(".json")) continue;
+    const pendingPath = join(pendingDir, name);
+    let record;
+    try {
+      record = JSON.parse(await readFile(pendingPath, "utf8"));
+    } catch {
+      continue;
+    }
+    const sourceTs = typeof record.sourceTs === "string" ? record.sourceTs : "";
+    if (sourceTs === "") continue;
+    const dest = join(deliveredDir, safeKey(sourceTs));
+    try {
+      await readFile(dest, "utf8");
+      await rm(pendingPath, { force: true });
+      continue;
+    } catch {
+      // not delivered yet
+    }
+    const tmp = dest + "." + process.pid + ".tmp";
+    try {
+      await writeFile(tmp, JSON.stringify(record) + "\\n", "utf8");
+      await rename(tmp, dest);
+      await rm(pendingPath, { force: true });
+      nudges.push(record);
+    } catch {
+      await rm(tmp, { force: true }).catch(() => {});
+      await rm(pendingPath, { force: true }).catch(() => {});
+    }
+  }
+  if (nudges.length === 0) {
+    process.stdout.write("{}\\n");
+    return;
+  }
+  const lines = [
+    "<slack_followup>",
+    "New Slack follow-up(s) arrived while you were working. Incorporate them before your final reply. If an ask was already answered in-thread, ack briefly instead of re-answering.",
+    "",
+  ];
+  for (const nudge of nudges) {
+    const who =
+      typeof nudge.author === "string" && nudge.author !== ""
+        ? nudge.author
+        : "someone";
+    lines.push("- " + who + " @ " + nudge.sourceTs + ":");
+    lines.push(
+      typeof nudge.text === "string" && nudge.text.trim() !== ""
+        ? nudge.text.trim()
+        : "(empty)"
+    );
+    lines.push("");
+  }
+  lines.push("</slack_followup>");
+  process.stdout.write(
+    JSON.stringify({ additional_context: lines.join("\\n").trimEnd() }) + "\\n"
+  );
+}
+
+main().catch(() => {
+  process.stdout.write("{}\\n");
+});
+`;
+
+type HooksConfig = {
+  version?: number;
+  hooks?: Record<string, Array<{ command: string; failClosed?: boolean }>>;
+};
+
+/**
+ * Write carrier script + pointer files and ensure pre/postToolUse hooks invoke it.
+ * Safe to call every turn (idempotent overwrite of carrier + pointers).
+ */
+export async function materializeSlackNudgeCarrier(args: {
+  harnessCwd: string;
+  nudgeRootDir: string;
+  continuationKey: string;
+}): Promise<void> {
+  if (args.continuationKey.trim() === "") {
+    return;
+  }
+  await mkdir(join(args.harnessCwd, ".agent-serve"), { recursive: true });
+  await mkdir(join(args.harnessCwd, ".cursor"), { recursive: true });
+  await writeFile(
+    join(args.harnessCwd, SLACK_NUDGE_ROOT_REL),
+    `${args.nudgeRootDir}\n`,
+    "utf8"
+  );
+  await writeFile(
+    join(args.harnessCwd, SLACK_NUDGE_CONTINUATION_REL),
+    `${args.continuationKey}\n`,
+    "utf8"
+  );
+  await writeFile(
+    join(args.harnessCwd, SLACK_NUDGE_CARRIER_REL),
+    SLACK_NUDGE_CARRIER_SCRIPT,
+    "utf8"
+  );
+
+  const hooksPath = join(args.harnessCwd, ".cursor", "hooks.json");
+  let existing: HooksConfig = { version: 1, hooks: {} };
+  try {
+    existing = JSON.parse(await readFile(hooksPath, "utf8")) as HooksConfig;
+  } catch {
+    // fresh
+  }
+  const hooks = { ...(existing.hooks ?? {}) };
+  const command = `node ${SLACK_NUDGE_CARRIER_REL}`;
+  for (const step of ["preToolUse", "postToolUse"] as const) {
+    const list = [...(hooks[step] ?? [])].filter(
+      (entry) => !entry.command.includes("slack-nudge-carrier")
+    );
+    list.push({ command, failClosed: false });
+    hooks[step] = list;
+  }
+  const next: HooksConfig = {
+    version: existing.version ?? 1,
+    hooks,
+  };
+  await writeFile(hooksPath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+}