@cursor/july 0.1.95 → 0.1.97

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

@@ -4,12 +4,16 @@
  * Cursor-account channels do not use this path — they reply with a single
  * final `chat.postMessage` and put thinking on `assistant.threads.setStatus`
  * (no message edits).
+ *
+ * Assistant-pane threads only render stream APIs. Start lazily with the
+ * first real markdown/chunks plus recipient ids — empty startStream is
+ * rejected or never attaches.
  */
 
 import type { ChannelEventContext } from "../../types.js";
 import { appendChatStream, startChatStream, stopChatStream } from "./api.js";
 import type { SlackLog } from "./log.js";
-import { computeStreamAppend } from "./stream.js";
+import { computeStreamAppend, type StreamTaskChunk } from "./stream.js";
 import type { SlackBotToken, SlackChannelState } from "./types.js";
 
 type SlackChannel = ChannelEventContext<SlackChannelState>;
@@ -19,96 +23,195 @@ export interface LiveDeliveryDeps {
   getLog: () => SlackLog;
 }
 
+type OpenArgs = {
+  channel: SlackChannel;
+  channelId: string;
+  threadTs: string;
+  sessionId: string;
+  markdown_text?: string;
+  chunks?: StreamTaskChunk[];
+};
+
+type StreamArgs = {
+  channel: SlackChannel;
+  channelId: string;
+  sessionId: string;
+};
+
 /**
  * How the default handlers deliver an in-progress reply. Methods write live
  * delivery state (`streamTs`, `streamChannelId`, `lastPostedText`,
  * `streamingUnavailable`) on `channel.state` directly.
  */
 export interface LiveDeliveryStrategy {
-  /** True when tool-call thinking steps can be appended to the live message. */
   readonly inlineToolSteps: boolean;
-  /** Open the live message (stream start). */
-  start(args: {
-    channel: SlackChannel;
-    channelId: string;
-    threadTs: string;
-    sessionId: string;
-  }): Promise<void>;
-  /** Push the latest cumulative text to the live message (throttled). */
-  append(args: {
-    channel: SlackChannel;
-    channelId: string;
-    streamTs: string;
-    text: string;
-    sessionId: string;
-  }): Promise<void>;
+  /** Open the live message with the first real markdown or task chunks. */
+  open(args: OpenArgs): Promise<boolean>;
+  append(args: StreamArgs & { text: string }): Promise<void>;
+  appendChunks(
+    args: StreamArgs & { chunks: StreamTaskChunk[] }
+  ): Promise<boolean>;
   /**
    * Flush the final reply text. `delivered` is false only when the caller must
    * post the full reply as a fresh message (finalize failed on partial text).
    */
-  finalize(args: {
-    channel: SlackChannel;
-    channelId: string;
-    streamTs: string;
-    text: string;
-    sessionId: string;
-  }): Promise<{ delivered: boolean }>;
-  /** Close the live message when the turn produced no final text. */
-  finalizeEmpty(args: {
-    channel: SlackChannel;
-    channelId: string;
-    streamTs: string;
-  }): Promise<void>;
-  /** Best-effort remove a live message left open after the turn ended. */
+  finalize(
+    args: StreamArgs & { text: string }
+  ): Promise<{ delivered: boolean }>;
+  finalizeEmpty(args: { channel: SlackChannel }): Promise<void>;
   cleanupOrphan(args: { channel: SlackChannel }): Promise<void>;
-  /** Deliver the error text into the live message; `delivered` gates a fallback post. */
-  fail(args: {
-    channel: SlackChannel;
-    channelId: string;
-    streamTs: string;
-    errorText: string;
-    sessionId: string;
-  }): Promise<{ delivered: boolean }>;
+  fail(
+    args: StreamArgs & { errorText: string }
+  ): Promise<{ delivered: boolean }>;
+}
+
+function streamRecipients(channel: SlackChannel): {
+  recipient_user_id: string | undefined;
+  recipient_team_id: string | undefined;
+} {
+  const user = channel.state.triggeringUserId;
+  const team = channel.state.teamId;
+  return {
+    recipient_user_id: user === null || user === "" ? undefined : user,
+    recipient_team_id: team === null || team === "" ? undefined : team,
+  };
+}
+
+function activeStreamTs(channel: SlackChannel): string | null {
+  const ts = channel.state.streamTs;
+  return ts === null || ts === "" ? null : ts;
 }
 
 export function createStreamDeliveryStrategy(
   deps: LiveDeliveryDeps
 ): LiveDeliveryStrategy {
   const { botToken, getLog } = deps;
-  return {
-    inlineToolSteps: true,
 
-    async start({ channel, channelId, threadTs, sessionId }) {
-      const log = getLog();
-      const started = await startChatStream({
-        botToken,
+  const open: LiveDeliveryStrategy["open"] = async ({
+    channel,
+    channelId,
+    threadTs,
+    sessionId,
+    markdown_text,
+    chunks,
+  }) => {
+    if (activeStreamTs(channel) !== null) {
+      return true;
+    }
+    const hasMarkdown = markdown_text !== undefined && markdown_text !== "";
+    const hasChunks = chunks !== undefined && chunks.length > 0;
+    if (!hasMarkdown && !hasChunks) {
+      return false;
+    }
+    const log = getLog();
+    const started = await startChatStream({
+      botToken,
+      channel: channelId,
+      thread_ts: threadTs,
+      markdown_text: hasMarkdown ? markdown_text : undefined,
+      chunks: hasChunks ? chunks : undefined,
+      ...streamRecipients(channel),
+    });
+    if (!started.ok) {
+      log.warn("chat.startStream unavailable", {
+        error: started.error,
         channel: channelId,
         thread_ts: threadTs,
-        markdown_text: "",
-      });
-      if (!started.ok) {
-        log.warn("chat.startStream unavailable", {
-          error: started.error,
-          channel: channelId,
-          thread_ts: threadTs,
-          session: sessionId,
-        });
-        if (started.unsupported === true) {
-          channel.state.streamingUnavailable = true;
-        }
-        return;
-      }
-      channel.state.streamTs = started.ts;
-      channel.state.streamChannelId = started.channel;
-      channel.state.lastPostedText = "";
-      log.info("chat.startStream ok", {
-        channel: started.channel,
-        stream_ts: started.ts,
         session: sessionId,
       });
-    },
+      if (started.unsupported === true) {
+        channel.state.streamingUnavailable = true;
+      }
+      return false;
+    }
+    channel.state.streamTs = started.ts;
+    channel.state.streamChannelId = started.channel;
+    channel.state.lastPostedText = hasMarkdown ? (markdown_text ?? "") : "";
+    log.info("chat.startStream ok", {
+      channel: started.channel,
+      stream_ts: started.ts,
+      session: sessionId,
+    });
+    return true;
+  };
+
+  const ensureOpen = async (
+    args: StreamArgs & {
+      markdown_text?: string;
+      chunks?: StreamTaskChunk[];
+    }
+  ): Promise<string | null> => {
+    const existing = activeStreamTs(args.channel);
+    if (existing !== null) {
+      return existing;
+    }
+    const threadTs = args.channel.state.threadTs;
+    if (threadTs === null || threadTs === "") {
+      return null;
+    }
+    const opened = await open({
+      channel: args.channel,
+      channelId: args.channelId,
+      threadTs,
+      sessionId: args.sessionId,
+      markdown_text: args.markdown_text,
+      chunks: args.chunks,
+    });
+    return opened ? activeStreamTs(args.channel) : null;
+  };
+
+  const stopWithSuffix = async (args: {
+    channel: SlackChannel;
+    channelId: string;
+    ts: string;
+    text: string;
+  }): Promise<{ ok: boolean; error?: string }> => {
+    const appendText = computeStreamAppend(
+      args.channel.state.lastPostedText,
+      args.text
+    );
+    const stopped = await stopChatStream({
+      botToken,
+      channel: args.channelId,
+      ts: args.ts,
+      markdown_text: appendText === "" ? undefined : appendText,
+    });
+    args.channel.state.streamTs = null;
+    if (stopped.ok) {
+      args.channel.state.lastPostedText = args.text;
+      args.channel.state.lastBotMessageTs = args.ts;
+      return { ok: true };
+    }
+    if (stopped.unsupported === true) {
+      args.channel.state.streamingUnavailable = true;
+    }
+    return { ok: false, error: stopped.error };
+  };
 
-    async append({ channel, channelId, streamTs, text, sessionId }) {
+  const closeOrphan = async (channel: SlackChannel): Promise<void> => {
+    const orphanTs = activeStreamTs(channel);
+    const channelId = channel.state.streamChannelId ?? channel.state.channelId;
+    if (orphanTs === null || channelId === null || channelId === "") {
+      return;
+    }
+    await stopChatStream({ botToken, channel: channelId, ts: orphanTs });
+    channel.state.streamTs = null;
+  };
+
+  return {
+    inlineToolSteps: true,
+    open,
+
+    async append({ channel, channelId, text, sessionId }) {
+      const ts = await ensureOpen({
+        channel,
+        channelId,
+        sessionId,
+        markdown_text: text,
+      });
+      if (ts === null) {
+        return;
+      }
       const appendText = computeStreamAppend(
         channel.state.lastPostedText,
         text
@@ -119,14 +222,14 @@ export function createStreamDeliveryStrategy(
       const result = await appendChatStream({
         botToken,
         channel: channelId,
-        ts: streamTs,
+        ts,
         markdown_text: appendText,
       });
       if (!result.ok) {
         getLog().warn("appendStream failed", {
           error: result.error,
           channel: channelId,
-          stream_ts: streamTs,
+          stream_ts: ts,
           session: sessionId,
         });
         if (result.unsupported === true) {
@@ -137,26 +240,50 @@ export function createStreamDeliveryStrategy(
       channel.state.lastPostedText = text;
     },
 
-    async finalize({ channel, channelId, streamTs, text, sessionId }) {
-      const log = getLog();
-      // Only send the unsent suffix — full text was already appended.
-      const appendText = computeStreamAppend(
-        channel.state.lastPostedText,
-        text
-      );
-      const stopped = await stopChatStream({
+    async appendChunks({ channel, channelId, chunks, sessionId }) {
+      const hadStream = activeStreamTs(channel) !== null;
+      const ts = await ensureOpen({
+        channel,
+        channelId,
+        sessionId,
+        chunks,
+      });
+      if (ts === null) {
+        return false;
+      }
+      if (!hadStream) {
+        return true;
+      }
+      const result = await appendChatStream({
         botToken,
         channel: channelId,
-        ts: streamTs,
-        markdown_text: appendText === "" ? undefined : appendText,
+        ts,
+        chunks,
+      });
+      return result.ok;
+    },
+
+    async finalize({ channel, channelId, text, sessionId }) {
+      const log = getLog();
+      const ts = await ensureOpen({
+        channel,
+        channelId,
+        sessionId,
+        markdown_text: text,
+      });
+      if (ts === null) {
+        return { delivered: false };
+      }
+      const stopped = await stopWithSuffix({
+        channel,
+        channelId,
+        ts,
+        text,
       });
       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,
+          stream_ts: ts,
           session: sessionId,
           chars: text.length,
         });
@@ -165,52 +292,46 @@ export function createStreamDeliveryStrategy(
       log.warn("chat.stopStream failed; falling back to postMessage", {
         error: stopped.error,
         channel: channelId,
-        stream_ts: streamTs,
+        stream_ts: ts,
         session: sessionId,
       });
-      if (stopped.unsupported === true) {
-        channel.state.streamingUnavailable = true;
-      }
-      channel.state.streamTs = null;
-      // If we already streamed content, do not post the full reply again.
       const alreadyStreamed =
         typeof channel.state.lastPostedText === "string" &&
         channel.state.lastPostedText.length > 0;
       return { delivered: alreadyStreamed };
     },
 
-    async finalizeEmpty({ channelId, streamTs }) {
-      await stopChatStream({ botToken, channel: channelId, ts: streamTs });
+    async finalizeEmpty({ channel }) {
+      await closeOrphan(channel);
     },
 
     async cleanupOrphan({ channel }) {
-      // message.completed / turn.failed already stop the stream. If the
-      // turn ended without a final assistant message, close it here so
-      // Slack does not leave the live reply in a streaming state.
-      const streamTs = channel.state.streamTs;
-      const channelId =
-        channel.state.streamChannelId ?? channel.state.channelId;
-      if (
-        streamTs === null ||
-        streamTs === "" ||
-        channelId === null ||
-        channelId === ""
-      ) {
-        return;
-      }
-      await stopChatStream({ botToken, channel: channelId, ts: streamTs });
-      channel.state.streamTs = null;
+      await closeOrphan(channel);
     },
 
-    async fail({ channel, channelId, streamTs, errorText }) {
-      const stopped = await stopChatStream({
-        botToken,
-        channel: channelId,
-        ts: streamTs,
+    async fail({ channel, channelId, errorText, sessionId }) {
+      const ts = await ensureOpen({
+        channel,
+        channelId,
+        sessionId,
         markdown_text: errorText,
       });
-      channel.state.streamTs = null;
-      return { delivered: stopped.ok };
+      if (ts === null) {
+        return { delivered: false };
+      }
+      const stopped = await stopWithSuffix({
+        channel,
+        channelId,
+        ts,
+        text: errorText,
+      });
+      if (stopped.ok) {
+        return { delivered: true };
+      }
+      const alreadyStreamed =
+        typeof channel.state.lastPostedText === "string" &&
+        channel.state.lastPostedText.length > 0;
+      return { delivered: alreadyStreamed };
     },
   };
 }

package/src/channels/slack/manifest.ts

@@ -81,7 +81,11 @@ const BOT_SCOPES = [
   "users:read",
 ] as const;
 
-const BOT_EVENTS = ["app_mention", "message.im"] as const;
+const BOT_EVENTS = [
+  "app_mention",
+  "message.im",
+  "assistant_thread_started",
+] as const;
 
 /** Slack's display_information.description bound. */
 const MAX_DESCRIPTION_LENGTH = 140;
@@ -218,7 +222,7 @@ export function buildSlackManifestPair(
   };
 }
 
-/** Relative names under `.agent-serve/slack/`. */
+/** Manifest filenames written under `.slack/`. */
 export function slackManifestFileEntries(
   pair: { dev: SlackAppManifest; prod: SlackAppManifest },
   env: "dev" | "prod" | "both" = "both"

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

@@ -3,13 +3,15 @@
  * the durable Slack nudge store at tool boundaries (MCP / builtin tools).
  */
 
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, readFile, rm, 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";
+/** Conversation allowed to claim nudges; subagents share the cwd and would otherwise take the parent's. */
+export const SLACK_NUDGE_OWNER_REL = ".agent-serve/slack-nudge-owner";
 
 /** Carrier script body — reads nudge-root + continuation, drains pending. */
 export const SLACK_NUDGE_CARRIER_SCRIPT: string = `#!/usr/bin/env node
@@ -40,7 +42,46 @@ async function readText(rel) {
   }
 }
 
+async function readStdin() {
+  const chunks = [];
+  const read = (async () => {
+    for await (const chunk of process.stdin) chunks.push(chunk);
+  })().catch(() => {});
+  await Promise.race([
+    read,
+    new Promise((resolve) => setTimeout(resolve, 250).unref?.()),
+  ]);
+  process.stdin.destroy();
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+/** First caller pins ownership; a subagent cannot call a tool before its parent's Task call. */
+async function ownsStore(caller) {
+  if (caller === "") return true;
+  const ownerPath = join(workspace, ${JSON.stringify(SLACK_NUDGE_OWNER_REL)});
+  try {
+    // wx is O_CREAT|O_EXCL, so creating the file is the claim: concurrent hooks cannot both win.
+    await writeFile(ownerPath, caller + "\\n", { encoding: "utf8", flag: "wx" });
+    return true;
+  } catch (error) {
+    if (error && error.code !== "EEXIST") return false;
+  }
+  // Claimed already — the only question left is whether we are the claimant.
+  const owner = await readText(${JSON.stringify(SLACK_NUDGE_OWNER_REL)});
+  return owner === "" || owner === caller;
+}
+
 async function main() {
+  const raw = await readStdin();
+  let caller = "";
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed.conversation_id === "string") {
+      caller = parsed.conversation_id.trim();
+    }
+  } catch {
+    // Fail open: an unparseable payload must not strand the follow-up.
+  }
   const root = await readText(${JSON.stringify(SLACK_NUDGE_ROOT_REL)});
   const continuation = await readText(
     ${JSON.stringify(SLACK_NUDGE_CONTINUATION_REL)}
@@ -49,6 +90,11 @@ async function main() {
     process.stdout.write("{}\\n");
     return;
   }
+  // Not ours: leave it pending for the parent or the turn-boundary drain.
+  if (!(await ownsStore(caller))) {
+    process.stdout.write("{}\\n");
+    return;
+  }
   const pendingDir = join(root, safeKey(continuation), "pending");
   const deliveredDir = join(root, safeKey(continuation), "delivered");
   let names = [];
@@ -157,6 +203,7 @@ export async function materializeSlackNudgeCarrier(args: {
     SLACK_NUDGE_CARRIER_SCRIPT,
     "utf8"
   );
+  await rm(join(args.harnessCwd, SLACK_NUDGE_OWNER_REL), { force: true });
 
   const hooksPath = join(args.harnessCwd, ".cursor", "hooks.json");
   let existing: HooksConfig = { version: 1, hooks: {} };

package/src/channels/slack/setup.ts

@@ -2,7 +2,7 @@
  * Slack setup guide printed by `agent-serve slack setup`.
  *
  * Dedicated Socket Mode app via `slack create` (dashboard wizard).
- * `slack init --manual` is the unmanaged paste-at-api.slack.com path.
+ * `slack init --manual` is the unmanaged Slack CLI / paste path.
  * {@link SLACK_SETUP_PHASES} is that checklist; its ids key
  * `.agent-serve/slack/setup-status.json`.
  */
@@ -21,6 +21,7 @@ export const SLACK_SETUP_PHASES: SlackSetupPhase[] = [
     title: "Generate channel + manifests",
     steps: [
       "agent-serve slack init --manual --dir . --name My Agent",
+      "Installs the Slack app when Slack CLI is logged in. Otherwise next asks the user to install it.",
       "Manifests default to Socket Mode (no public Request URL).",
     ],
   },
@@ -29,9 +30,11 @@ export const SLACK_SETUP_PHASES: SlackSetupPhase[] = [
     actor: "human",
     title: "Create two Slack apps from manifests",
     steps: [
-      "Open https://api.slack.com/apps -> Create New App from a manifest",
-      "Paste .agent-serve/slack/manifest.dev.json -> create the *dev* app",
-      "Repeat with manifest.prod.json for the *prod* app",
+      "Preferred: Slack CLI at ~/.slack/bin/slack. slack login --no-prompt, then slack app install --environment local --team <T> --force",
+      "Prod: SLACK_ENV=deployed slack app install --environment deployed --team <T> --force",
+      "Do not slack deploy; Agent SDK serve owns Socket Mode",
+      "Fallback: https://api.slack.com/apps -> Create New App from a manifest",
+      "Paste .slack/manifest.dev.json, then manifest.prod.json",
     ],
   },
   {
@@ -39,8 +42,9 @@ export const SLACK_SETUP_PHASES: SlackSetupPhase[] = [
     actor: "human",
     title: "Install + mint App-Level Token",
     steps: [
-      "Install to Workspace; copy Bot User OAuth Token (xoxb-...)",
+      "Slack CLI install leaves tokens in that process only. Copy xoxb from OAuth & Permissions at https://api.slack.com/apps/<appId>",
       "App-Level Tokens: create token with connections:write; copy xapp-...",
+      "If Slack CLI wrote SLACK_* to .env, copy them into .env.local using env.example names",
     ],
   },
   {
@@ -106,7 +110,7 @@ export function formatSlackSetupGuide(): string {
     "  Finish Slack consent and the bot name there. The CLI writes",
     "  tokens into .env.local.",
     "",
-    "Manual Slack app: `slack init --manual`. Phases below.",
+    "Manual Slack app: `slack init --manual` (Slack CLI, or paste at api.slack.com).",
     "Goal: importable dev + prod Slack apps over Socket Mode (no public URL).",
     "App-Level Token (xapp-...) + Bot Token (xoxb-...) required.",
     "",

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

@@ -238,6 +238,8 @@ export function slackChannel(
         : { interruptContinuation: args.interruptContinuation }),
       ...(channelWatch === undefined ? {} : { channelWatch }),
       ...(botMentionGate === undefined ? {} : { botMentionGate }),
+      suggestedPrompts: options.suggestedPrompts,
+      suggestedPromptsTitle: options.suggestedPromptsTitle,
     };
   }
 
@@ -485,6 +487,7 @@ export function slackChannel(
               credentials,
               getSession: args.getSession,
               resolveApproval: args.resolveApproval,
+              resolveAuth: args.resolveAuth,
               waitUntil: args.waitUntil,
               log: getLog(),
               blockExternals,