@cursor/july 0.1.20 → 0.1.21

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

@@ -0,0 +1,202 @@
+import { describe, expect, it, vi } from "vitest";
+import * as slackApi from "./api.js";
+import {
+  findLastBotMessageTs,
+  formatSlackThreadContextBlock,
+  formatSlackThreadDeltaBlock,
+  loadSlackThreadContextBlock,
+  mergeThreadMessagesByTs,
+  selectThreadDeltaMessages,
+  trimThreadMessagesForPrompt,
+} from "./thread-context.js";
+
+describe("formatSlackThreadContextBlock", () => {
+  it("formats parent then replies and excludes the triggering message", () => {
+    const block = formatSlackThreadContextBlock(
+      [
+        {
+          ts: "1.0",
+          bot_id: "B1",
+          username: "Datadog",
+          text: "parent alert",
+        },
+        { ts: "2.0", user: "U1", text: "looking" },
+        { ts: "3.0", user: "U2", text: "@jenny what happened?" },
+      ],
+      { excludeTs: "3.0" }
+    );
+    expect(block).toContain("<slack_thread>");
+    expect(block).toContain("[parent] bot:B1 (Datadog) @ 1.0:");
+    expect(block).toContain("parent alert");
+    expect(block).toContain("[reply] U1 @ 2.0:");
+    expect(block).not.toContain("what happened?");
+    expect(block).toContain("</slack_thread>");
+  });
+
+  it("labels parent by thread ts even when earlier rows are filtered", () => {
+    const block = formatSlackThreadContextBlock(
+      [
+        { ts: "1.0", user: "U1", text: "" },
+        { ts: "2.0", user: "U2", text: "actual parent" },
+        { ts: "3.0", user: "U3", text: "reply" },
+      ],
+      { threadTs: "2.0", excludeTs: "3.0" }
+    );
+    expect(block).toContain("[parent] U2 @ 2.0:");
+    expect(block).not.toContain("[reply] U3 @ 3.0:");
+    expect(block).not.toContain("[parent] U3");
+  });
+
+  it("keeps the thread root plus the newest replies when over the limit", () => {
+    const messages = [{ ts: "1.0", user: "U0", text: "root" }];
+    for (let i = 2; i <= 60; i++) {
+      messages.push({ ts: `${i}.0`, user: "U1", text: `reply ${i}` });
+    }
+    const trimmed = trimThreadMessagesForPrompt(messages, {
+      threadTs: "1.0",
+      limit: 50,
+    });
+    expect(trimmed[0]).toMatchObject({ ts: "1.0" });
+    expect(trimmed.at(-1)).toMatchObject({ ts: "60.0" });
+    expect(trimmed).toHaveLength(50);
+  });
+
+  it("returns undefined when nothing usable remains", () => {
+    expect(
+      formatSlackThreadContextBlock([{ ts: "1.0", text: "only me" }], {
+        excludeTs: "1.0",
+      })
+    ).toBeUndefined();
+  });
+
+  it("truncates oversized blocks", () => {
+    const block = formatSlackThreadContextBlock(
+      [
+        {
+          ts: "1.0",
+          user: "U1",
+          text: "x".repeat(500),
+        },
+      ],
+      { maxChars: 120 }
+    );
+    expect(block).toBeDefined();
+    expect(block!.length).toBeLessThanOrEqual(200);
+    expect(block).toContain("truncated");
+    expect(block).toContain("</slack_thread>");
+  });
+});
+
+describe("thread delta helpers", () => {
+  it("finds the latest bot message ts", () => {
+    expect(
+      findLastBotMessageTs([
+        { ts: "1.0", user: "U1", text: "human" },
+        { ts: "1.5", bot_id: "B1", text: "bot a" },
+        { ts: "2.0", user: "U2", text: "human 2" },
+        { ts: "2.5", bot_id: "B1", text: "bot b" },
+      ])
+    ).toBe("2.5");
+  });
+
+  it("restricts watermark to the agent bot when identity is provided", () => {
+    expect(
+      findLastBotMessageTs(
+        [
+          { ts: "1.0", bot_id: "BDD", text: "datadog" },
+          { ts: "1.5", bot_id: "BJENNY", text: "jenny" },
+          { ts: "2.0", user: "U1", text: "human" },
+          { ts: "2.5", bot_id: "BDD", text: "datadog again" },
+        ],
+        { botId: "BJENNY" }
+      )
+    ).toBe("1.5");
+  });
+
+  it("merges missing triggering ask by ts", () => {
+    const merged = mergeThreadMessagesByTs(
+      [{ ts: "1.0", user: "U0", text: "root" }],
+      [{ ts: "2.0", user: "U1", text: "lagging ask" }]
+    );
+    expect(merged.map((m) => m.ts)).toEqual(["1.0", "2.0"]);
+  });
+
+  it("formats slack_thread_delta after watermark", () => {
+    const delta = selectThreadDeltaMessages(
+      [
+        { ts: "1.0", bot_id: "B1", text: "bot" },
+        { ts: "2.0", user: "U1", text: "ask" },
+      ],
+      { afterTs: "1.0", excludeTs: "2.0" }
+    );
+    expect(delta).toHaveLength(0);
+    const block = formatSlackThreadDeltaBlock(
+      [
+        { ts: "1.0", bot_id: "B1", text: "bot" },
+        { ts: "2.0", user: "U1", text: "ask" },
+        { ts: "3.0", user: "U2", text: "more" },
+      ],
+      { afterTs: "1.0", excludeTs: "2.0" }
+    );
+    expect(block).toContain("<slack_thread_delta>");
+    expect(block).toContain("more");
+    expect(block).not.toContain("ask");
+  });
+});
+
+describe("loadSlackThreadContextBlock", () => {
+  it("soft-fails without a bot token", async () => {
+    await expect(
+      loadSlackThreadContextBlock({
+        botToken: undefined,
+        channelId: "C1",
+        threadTs: "1.0",
+      })
+    ).resolves.toBeUndefined();
+  });
+
+  it("calls conversations.replies and formats the result", async () => {
+    const spy = vi.spyOn(slackApi, "callSlackApiSoft").mockResolvedValue({
+      ok: true,
+      messages: [
+        { ts: "1.0", user: "Ubot", text: "alert body" },
+        { ts: "2.0", user: "U1", text: "mention" },
+      ],
+      has_more: false,
+    });
+    const block = await loadSlackThreadContextBlock({
+      botToken: "xoxb-test",
+      channelId: "C1",
+      threadTs: "1.0",
+      excludeTs: "2.0",
+    });
+    expect(spy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        operation: "conversations.replies",
+        body: expect.objectContaining({
+          channel: "C1",
+          ts: "1.0",
+          inclusive: true,
+        }),
+      })
+    );
+    expect(block).toContain("alert body");
+    expect(block).not.toContain("mention");
+    spy.mockRestore();
+  });
+
+  it("soft-fails when Slack returns not-ok", async () => {
+    const spy = vi.spyOn(slackApi, "callSlackApiSoft").mockResolvedValue({
+      ok: false,
+      error: "channel_not_found",
+    });
+    await expect(
+      loadSlackThreadContextBlock({
+        botToken: "xoxb-test",
+        channelId: "C1",
+        threadTs: "1.0",
+      })
+    ).resolves.toBeUndefined();
+    spy.mockRestore();
+  });
+});

package/src/channels/slack/types.ts

@@ -88,6 +88,21 @@ export interface SlackAuthor {
   botId?: string;
 }
 
+/**
+ * Delegation metadata carried on bot-to-bot mention posts (Slack message
+ * `metadata`, event type {@link SLACK_DELEGATION_METADATA_EVENT_TYPE}).
+ * Absent on posts from bots that don't speak the protocol — the gate then
+ * treats the mention as depth 1.
+ */
+export interface SlackDelegationInfo {
+  /** Delegation hop count. A dispatcher woken by a human posts depth 1. */
+  depth: number;
+  /** Mount slug / display name of the delegating agent. */
+  fromAgent?: string;
+  /** Session id on the delegating agent, for cross-agent tracing. */
+  originSessionId?: string;
+}
+
 export interface SlackMessage {
   /** Raw top-level `text` exactly as Slack sent it. Often empty on bot posts. */
   text: string;
@@ -105,6 +120,8 @@ export interface SlackMessage {
   channelId: string;
   teamId?: string;
   author?: SlackAuthor;
+  /** Parsed delegation metadata when the post carried it (bot mentions). */
+  delegation?: SlackDelegationInfo;
 }
 
 export interface SlackDispatchDecision {
@@ -298,6 +315,44 @@ export interface SlackChannelPostsOptions {
   includeBotPosts?: boolean;
 }
 
+/**
+ * Opt-in bot-to-bot mention wake: allow @mentions authored by explicitly
+ * trusted bots (e.g. a dispatcher agent) to dispatch like human mentions.
+ * Default off — bot-authored mentions are dropped (loop safety). There is
+ * deliberately no "any bot" wildcard; trusting a bot is a per-bot decision.
+ *
+ * Loop protection is layered: this allowlist, the always-on own-post
+ * filter, a delegation-depth budget (Slack message metadata), and a
+ * per-thread wake budget.
+ */
+export interface SlackBotMentionsOptions {
+  /**
+   * Bots whose mentions may wake this agent: `bot_id`s (`B…`) and/or bot
+   * *user* ids (`U…`). Must be non-empty (empty is a definition error).
+   */
+  allowFrom: string[];
+  /**
+   * Maximum delegation depth admitted (from the mention's delegation
+   * metadata; mentions without metadata count as depth 1). Defaults to 2 —
+   * human → dispatcher → specialist, no deeper chains.
+   */
+  maxDepth?: number;
+  /**
+   * Maximum bot-initiated wakes per thread per hour (sliding window).
+   * Defaults to 5. Rate-limits ping-pong between bots that carry no
+   * delegation metadata; termination comes from {@link maxPerThreadTotal}.
+   */
+  maxPerThreadPerHour?: number;
+  /**
+   * Lifetime cap on bot-initiated wakes per thread (resets only after the
+   * thread has been idle for 24h). Defaults to 20. This is the terminating
+   * backstop: a sliding window alone refills, so two mutually-allowlisted
+   * bots could ping-pong forever at the rate cap. Avoid mutual allowlists
+   * regardless — keep the delegation graph a DAG.
+   */
+  maxPerThreadTotal?: number;
+}
+
 /**
  * How the agent engages over Slack. Omitted entirely = mentions + DMs,
  * which is also the default for each flag — summoned, never proactive.
@@ -313,6 +368,11 @@ export interface SlackEngagementOptions {
    * (`slack init --channel-posts`, or add the events to an existing app).
    */
   channelPosts?: SlackChannelPostsOptions;
+  /**
+   * Opt-in bot-to-bot mention wake (see {@link SlackBotMentionsOptions}).
+   * Socket Mode only — rejected on `cursorAccount: true`.
+   */
+  botMentions?: SlackBotMentionsOptions;
 }
 
 /**