@cursor/july 0.1.94 → 0.1.96

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;

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/pr-ref.ts

@@ -1,7 +1,9 @@
 /**
- * Best-effort GitHub PR references from free-form chat (Slack, etc.).
+ * Best-effort PR references from free-form chat (Slack, etc.).
  */
 
+import { type PrProvider, parsePrUrl } from "../../internal/scm/pr-url.js";
+
 export interface GithubPrRef {
   /** Normalized URL `https://github.com/owner/repo/pull/N`. */
   url: string;
@@ -12,39 +14,68 @@ export interface GithubPrRef {
   number: number;
 }
 
+export type OriginPrRef = GithubPrRef;
+
+const URL_IN_TEXT = /https?:\/\/[^\s>|]+/gi;
+
+function githubRef(owner: string, repo: string, number: number): GithubPrRef {
+  return {
+    owner,
+    repo,
+    number,
+    url: `https://github.com/${owner}/${repo}/pull/${number}`,
+    label: `${owner}/${repo}#${number}`,
+  };
+}
+
+function firstUrlRef(
+  text: string,
+  provider: PrProvider
+): GithubPrRef | undefined {
+  const matches = text.match(URL_IN_TEXT);
+  if (matches === null) {
+    return undefined;
+  }
+  for (const raw of matches) {
+    const parsed = parsePrUrl(raw);
+    if (parsed?.provider === provider) {
+      return {
+        owner: parsed.owner,
+        repo: parsed.repo,
+        number: parsed.number,
+        url: parsed.url,
+        label: `${parsed.owner}/${parsed.repo}#${parsed.number}`,
+      };
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Find the first Origin PR URL in `text`.
+ * Does not treat bare `owner/repo#N` as Origin.
+ */
+export function extractOriginPrRef(text: string): OriginPrRef | undefined {
+  return firstUrlRef(text, "origin");
+}
+
 /**
  * Find the first GitHub PR URL or `owner/repo#N` in `text`.
  * Returns `undefined` when none is present.
  */
 export function extractGithubPrRef(text: string): GithubPrRef | undefined {
-  const urlMatch = text.match(
-    /https?:\/\/(?:www\.)?github\.com\/([\w.-]+)\/([\w.-]+)\/pull\/(\d+)/i
-  );
-  if (urlMatch !== null) {
-    const owner = urlMatch[1] as string;
-    const repo = urlMatch[2] as string;
-    const number = Number(urlMatch[3]);
-    return {
-      owner,
-      repo,
-      number,
-      url: `https://github.com/${owner}/${repo}/pull/${number}`,
-      label: `${owner}/${repo}#${number}`,
-    };
+  const fromUrl = firstUrlRef(text, "github");
+  if (fromUrl !== undefined) {
+    return fromUrl;
   }
 
   const hashMatch = text.match(/\b([\w.-]+)\/([\w.-]+)#(\d+)\b/);
   if (hashMatch === null) {
     return undefined;
   }
-  const owner = hashMatch[1] as string;
-  const repo = hashMatch[2] as string;
-  const number = Number(hashMatch[3]);
-  return {
-    owner,
-    repo,
-    number,
-    url: `https://github.com/${owner}/${repo}/pull/${number}`,
-    label: `${owner}/${repo}#${number}`,
-  };
+  return githubRef(
+    hashMatch[1] as string,
+    hashMatch[2] as string,
+    Number(hashMatch[3])
+  );
 }

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,
     };
   }