@cursor/july 0.1.19 → 0.1.21

package/src/channels/slack/dispatch.test.ts

@@ -0,0 +1,795 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type {
+  ChannelSession,
+  HostContext,
+  SendMessageFn,
+} from "../../types.js";
+import * as slackApi from "./api.js";
+import {
+  createEventIdDedupe,
+  createSlackLogger,
+  dispatchInboundFromEventBody,
+  dispatchInboundMessage,
+  SlackAskDedupeStore,
+  SlackNudgeStore,
+} from "./index.js";
+import type { SlackMessageHandler } from "./types.js";
+
+const testAuth = {
+  authenticator: "test",
+  principalId: "U1",
+  principalType: "user" as const,
+};
+
+function mockSession(
+  id = "ses_test",
+  extras?: { coalesced?: boolean; isNew?: boolean }
+): ChannelSession {
+  return {
+    id,
+    continuationToken: null,
+    isNew: extras?.isNew ?? true,
+    ...(extras?.coalesced === true ? { coalesced: true as const } : {}),
+    info: {
+      id,
+      channelId: "slack",
+      mode: "chat",
+      auth: testAuth,
+    },
+    getEventStream: async () => new ReadableStream(),
+    waitForCompletion: async () => ({ status: "finished" }),
+    setContinuationToken: async () => undefined,
+  };
+}
+
+function createSendRecorder(options?: { coalesced?: boolean }): {
+  send: SendMessageFn;
+  calls: Array<{ message: string; options: Parameters<SendMessageFn>[1] }>;
+} {
+  const calls: Array<{
+    message: string;
+    options: Parameters<SendMessageFn>[1];
+  }> = [];
+  const send: SendMessageFn = async (message, sendOptions) => {
+    calls.push({ message, options: sendOptions });
+    return mockSession("ses_1", {
+      coalesced: options?.coalesced,
+      isNew: false,
+    });
+  };
+  return { send, calls };
+}
+
+function acceptHandler(): SlackMessageHandler {
+  return async () => ({ auth: testAuth });
+}
+
+function testHost(options?: {
+  nudgeRoot?: string;
+  askRoot?: string;
+  evals?: HostContext["evals"];
+}) {
+  const nudgeStore =
+    options?.nudgeRoot === undefined
+      ? undefined
+      : new SlackNudgeStore(options.nudgeRoot);
+  const askStore =
+    options?.askRoot === undefined
+      ? undefined
+      : new SlackAskDedupeStore(options.askRoot);
+  return {
+    mcp: {
+      names: () => [] as string[],
+      listTools: async () => [],
+      callTool: async () => ({ content: [] }),
+    },
+    github: {
+      getOctokit: async () => {
+        throw new Error("github client not configured in test");
+      },
+    },
+    slack: {
+      getClient: async () => {
+        throw new Error("slack client not configured in test");
+      },
+    },
+    kv: {
+      get: async () => undefined,
+      put: async () => {},
+      delete: async () => {},
+    },
+    evals: options?.evals,
+    slackNudges:
+      nudgeStore === undefined || askStore === undefined
+        ? undefined
+        : {
+            append: (input: Parameters<SlackNudgeStore["append"]>[0]) =>
+              nudgeStore.append(input),
+            drainFormatted: (key: string) => nudgeStore.drainFormatted(key),
+            clear: (key: string) => nudgeStore.clear(key),
+            hasUndelivered: (key: string) => nudgeStore.hasUndelivered(key),
+            isDelivered: (key: string, ts: string) =>
+              nudgeStore.isDelivered(key, ts),
+            tryClaimAsk: (channelId: string, ts: string) =>
+              askStore.tryClaim(channelId, ts),
+            releaseAsk: (channelId: string, ts: string) =>
+              askStore.release(channelId, ts),
+          },
+  };
+}
+
+function mentionBody(
+  args: {
+    eventId?: string;
+    text?: string;
+    ts?: string;
+    threadTs?: string;
+    channel?: string;
+  } = {}
+): Record<string, unknown> {
+  return {
+    type: "event_callback",
+    team_id: "T1",
+    ...(args.eventId === undefined ? {} : { event_id: args.eventId }),
+    event: {
+      type: "app_mention",
+      user: "U1",
+      text: args.text ?? "<@Ubot> weather?",
+      ts: args.ts ?? "10.0",
+      // Different from ts so setTitle is skipped (no network).
+      thread_ts: args.threadTs ?? "9.0",
+      channel: args.channel ?? "C9",
+    },
+  };
+}
+
+const cleanups: Array<() => Promise<void>> = [];
+
+afterEach(async () => {
+  vi.unstubAllGlobals();
+  vi.restoreAllMocks();
+  while (cleanups.length > 0) {
+    await cleanups.pop()?.();
+  }
+});
+
+describe("dispatchInboundFromEventBody", () => {
+  it("dispatches app_mention to send with continuation token", async () => {
+    const { send, calls } = createSendRecorder();
+    const background: Promise<unknown>[] = [];
+    const lines: string[] = [];
+
+    const scheduled = dispatchInboundFromEventBody(mentionBody(), {
+      send,
+      waitUntil: (p) => {
+        background.push(p);
+      },
+      onAppMention: acceptHandler(),
+      onDirectMessage: async () => null,
+      credentials: undefined,
+      eventIds: createEventIdDedupe(),
+      host: testHost(),
+      log: createSlackLogger((line) => lines.push(line)),
+    });
+
+    expect(scheduled).toBe(true);
+    await Promise.all(background);
+    expect(calls).toHaveLength(1);
+    expect(calls[0]?.options?.continuationToken).toBe("C9:9.0");
+    expect(calls[0]?.message).toContain("weather?");
+    expect(calls[0]?.message).toContain("<slack_context>");
+    expect(lines.some((l) => l.includes("session start"))).toBe(true);
+  });
+
+  it("dedupes by event_id", async () => {
+    const { send, calls } = createSendRecorder();
+    const background: Promise<unknown>[] = [];
+    const eventIds = createEventIdDedupe();
+    const deps = {
+      send,
+      waitUntil: (p: Promise<unknown>) => {
+        background.push(p);
+      },
+      onAppMention: acceptHandler(),
+      onDirectMessage: async () => null,
+      credentials: undefined as undefined,
+      host: testHost(),
+      eventIds,
+      log: createSlackLogger(() => undefined),
+    };
+
+    const body = mentionBody({ eventId: "Ev1" });
+    expect(dispatchInboundFromEventBody(body, deps)).toBe(true);
+    expect(dispatchInboundFromEventBody(body, deps)).toBe(false);
+    await Promise.all(background);
+    expect(calls).toHaveLength(1);
+  });
+
+  it("skips send when handler returns null", async () => {
+    const { send, calls } = createSendRecorder();
+    const background: Promise<unknown>[] = [];
+    dispatchInboundFromEventBody(mentionBody(), {
+      send,
+      waitUntil: (p) => {
+        background.push(p);
+      },
+      onAppMention: async () => null,
+      onDirectMessage: async () => null,
+      credentials: undefined,
+      eventIds: createEventIdDedupe(),
+      host: testHost(),
+    });
+    await Promise.all(background);
+    expect(calls).toHaveLength(0);
+  });
+
+  it("does not send when handler throws", async () => {
+    const { send, calls } = createSendRecorder();
+    const background: Promise<unknown>[] = [];
+    dispatchInboundFromEventBody(mentionBody(), {
+      send,
+      waitUntil: (p) => {
+        background.push(p);
+      },
+      onAppMention: async () => {
+        throw new Error("boom");
+      },
+      onDirectMessage: async () => null,
+      credentials: undefined,
+      eventIds: createEventIdDedupe(),
+      host: testHost(),
+      log: createSlackLogger(() => undefined),
+    });
+    await Promise.all(background);
+    expect(calls).toHaveLength(0);
+  });
+
+  it("dispatches direct messages", async () => {
+    const { send, calls } = createSendRecorder();
+    const background: Promise<unknown>[] = [];
+    dispatchInboundFromEventBody(
+      {
+        type: "event_callback",
+        team_id: "T1",
+        event_id: "EvDM",
+        event: {
+          type: "message",
+          channel_type: "im",
+          user: "U1",
+          text: "hi from dm",
+          ts: "2.0",
+          thread_ts: "1.0",
+          channel: "D1",
+        },
+      },
+      {
+        send,
+        waitUntil: (p) => {
+          background.push(p);
+        },
+        onAppMention: async () => null,
+        onDirectMessage: acceptHandler(),
+        credentials: undefined,
+        eventIds: createEventIdDedupe(),
+        host: testHost(),
+      }
+    );
+    await Promise.all(background);
+    expect(calls).toHaveLength(1);
+    expect(calls[0]?.options?.continuationToken).toBe("D1:1.0");
+  });
+
+  it("returns false for unhandled shapes", () => {
+    expect(
+      dispatchInboundFromEventBody(
+        { type: "event_callback", event: { type: "reaction_added" } },
+        {
+          send: async () => mockSession(),
+          waitUntil: () => undefined,
+          onAppMention: async () => null,
+          onDirectMessage: async () => null,
+          credentials: undefined,
+          eventIds: createEventIdDedupe(),
+          host: testHost(),
+        }
+      )
+    ).toBe(false);
+  });
+
+  it("forwards message override, workspaceFiles, and cloud options from the handler", async () => {
+    const { send, calls } = createSendRecorder();
+    const background: Promise<unknown>[] = [];
+
+    dispatchInboundFromEventBody(mentionBody(), {
+      send,
+      waitUntil: (p) => {
+        background.push(p);
+      },
+      onAppMention: async () => ({
+        auth: testAuth,
+        title: "Bugbot acme/widget#1",
+        message: "Read pr.txt and review",
+        workspaceFiles: { "pr.txt": "evidence" },
+        cloud: {
+          repos: [
+            {
+              url: "https://github.com/acme/widget",
+              prUrl: "https://github.com/acme/widget/pull/1",
+            },
+          ],
+        },
+      }),
+      onDirectMessage: async () => null,
+      credentials: undefined,
+      eventIds: createEventIdDedupe(),
+      host: testHost(),
+    });
+    await Promise.all(background);
+    expect(calls).toHaveLength(1);
+    expect(calls[0]?.options?.title).toBe("Bugbot acme/widget#1");
+    expect(calls[0]?.message).toContain("Read pr.txt");
+    expect(calls[0]?.options?.workspaceFiles).toEqual({
+      "pr.txt": "evidence",
+    });
+    expect(calls[0]?.options?.cloud).toEqual({
+      repos: [
+        {
+          url: "https://github.com/acme/widget",
+          prUrl: "https://github.com/acme/widget/pull/1",
+        },
+      ],
+    });
+  });
+});
+
+describe("engagement routing", () => {
+  it("ignores mentions when mentionsEnabled is false", async () => {
+    const { send, calls } = createSendRecorder();
+    const background: Promise<unknown>[] = [];
+    const scheduled = dispatchInboundFromEventBody(mentionBody(), {
+      send,
+      waitUntil: (p) => {
+        background.push(p);
+      },
+      onAppMention: acceptHandler(),
+      onDirectMessage: async () => null,
+      credentials: undefined,
+      eventIds: createEventIdDedupe(),
+      host: testHost(),
+      log: createSlackLogger(() => undefined),
+      mentionsEnabled: false,
+    });
+    expect(scheduled).toBe(false);
+    await Promise.all(background);
+    expect(calls).toHaveLength(0);
+  });
+
+  it("routes channel posts to the watcher when configured", async () => {
+    const { send, calls } = createSendRecorder();
+    const background: Promise<unknown>[] = [];
+    const handled: string[] = [];
+    const deps = {
+      send,
+      waitUntil: (p: Promise<unknown>) => {
+        background.push(p);
+      },
+      onAppMention: acceptHandler(),
+      onDirectMessage: async () => null,
+      credentials: undefined as undefined,
+      eventIds: createEventIdDedupe(),
+      host: testHost(),
+      log: createSlackLogger(() => undefined),
+      channelWatch: {
+        handle: (event: { kind: string }, eventId?: string) => {
+          handled.push(`${event.kind}:${eventId ?? ""}`);
+          return true;
+        },
+        stop: () => undefined,
+      },
+    };
+    const scheduled = dispatchInboundFromEventBody(
+      {
+        type: "event_callback",
+        team_id: "T1",
+        event_id: "Ev9",
+        event: {
+          type: "message",
+          channel: "C9",
+          channel_type: "channel",
+          ts: "20.0",
+          text: "fresh report",
+          user: "U1",
+        },
+      },
+      deps
+    );
+    expect(scheduled).toBe(true);
+    await Promise.all(background);
+    expect(handled).toEqual(["post:Ev9"]);
+    // Watcher decides whether to dispatch; nothing sent by default here.
+    expect(calls).toHaveLength(0);
+  });
+
+  it("ignores channel posts without a watcher", () => {
+    const { send } = createSendRecorder();
+    const scheduled = dispatchInboundFromEventBody(
+      {
+        type: "event_callback",
+        event: {
+          type: "message",
+          channel: "C9",
+          channel_type: "channel",
+          ts: "20.0",
+          text: "fresh report",
+          user: "U1",
+        },
+      },
+      {
+        send,
+        waitUntil: () => undefined,
+        onAppMention: acceptHandler(),
+        onDirectMessage: async () => null,
+        credentials: undefined,
+        eventIds: createEventIdDedupe(),
+        host: testHost(),
+        log: createSlackLogger(() => undefined),
+      }
+    );
+    expect(scheduled).toBe(false);
+  });
+});
+
+describe("dispatchInboundMessage", () => {
+  it("logs delivery failure when send throws", async () => {
+    const lines: string[] = [];
+    await dispatchInboundMessage({
+      kind: "app_mention",
+      message: {
+        text: "hi",
+        body: "hi",
+        markdown: "hi",
+        ts: "2.0",
+        threadTs: "1.0",
+        channelId: "C1",
+        teamId: "T1",
+        author: { userId: "U1", isBot: false },
+      },
+      handler: acceptHandler(),
+      send: async () => {
+        throw new Error("engine down");
+      },
+      credentials: undefined,
+      host: testHost(),
+      log: createSlackLogger((line) => lines.push(line)),
+    });
+    expect(lines.some((line) => line.includes("delivery failed"))).toBe(true);
+  });
+
+  it("coalesces busy follow-ups with admission + nudge (no preempt retry)", async () => {
+    const root = await mkdtemp(join(tmpdir(), "dispatch-coalesce-"));
+    cleanups.push(() => rm(root, { recursive: true, force: true }));
+    const apiSoft = vi.spyOn(slackApi, "callSlackApiSoft").mockResolvedValue({
+      ok: true,
+      messages: [
+        { ts: "1.0", bot_id: "B1", text: "parent" },
+        { ts: "2.0", user: "U1", text: "follow-up" },
+      ],
+      has_more: false,
+    });
+    const lines: string[] = [];
+    const { send, calls } = createSendRecorder({ coalesced: true });
+    const host = testHost({
+      nudgeRoot: join(root, "nudges"),
+      askRoot: join(root, "asks"),
+    });
+    await dispatchInboundMessage({
+      kind: "app_mention",
+      message: {
+        text: "follow-up",
+        body: "follow-up",
+        markdown: "follow-up",
+        ts: "2.0",
+        threadTs: "1.0",
+        channelId: "C1",
+        teamId: "T1",
+        author: { userId: "U1", isBot: false },
+      },
+      handler: acceptHandler(),
+      send,
+      credentials: { botToken: "xoxb-test" },
+      host,
+      hasContinuationSession: async () => true,
+      log: createSlackLogger((line) => lines.push(line)),
+    });
+    expect(calls).toHaveLength(1);
+    expect(calls[0]?.options?.admission).toBe("coalesce");
+    expect(calls[0]?.options?.coalesceSourceTs).toBe("2.0");
+    expect(
+      lines.some((line) => line.includes("session busy; coalescing follow-up"))
+    ).toBe(true);
+    expect(await host.slackNudges?.hasUndelivered("C1:1.0")).toBe(false);
+    // Follow-up typing uses same-module setThreadStatus → callSlackApiSoft;
+    // vitest cannot spy that path. Coalesce admission + log is the contract.
+    expect(apiSoft).toHaveBeenCalled();
+    vi.restoreAllMocks();
+  });
+
+  it("handles whole-message stop without send", async () => {
+    const root = await mkdtemp(join(tmpdir(), "dispatch-stop-"));
+    cleanups.push(() => rm(root, { recursive: true, force: true }));
+    vi.spyOn(slackApi, "setThreadStatus").mockResolvedValue({ ok: true });
+    const { send, calls } = createSendRecorder();
+    let interrupted = false;
+    await dispatchInboundMessage({
+      kind: "app_mention",
+      message: {
+        text: "<@Ubot> stop",
+        body: "<@Ubot> stop",
+        markdown: "@Ubot stop",
+        ts: "2.0",
+        threadTs: "1.0",
+        channelId: "C1",
+        teamId: "T1",
+        author: { userId: "U1", isBot: false },
+      },
+      handler: acceptHandler(),
+      send,
+      credentials: { botToken: "xoxb-test" },
+      host: testHost({
+        nudgeRoot: join(root, "nudges"),
+        askRoot: join(root, "asks"),
+      }),
+      interruptContinuation: async () => {
+        interrupted = true;
+        return true;
+      },
+    });
+    expect(calls).toHaveLength(0);
+    expect(interrupted).toBe(true);
+    vi.restoreAllMocks();
+  });
+
+  it("handles eval list directive without send", async () => {
+    // Assert host.evals.list ran and no agent turn was started. Slack
+    // postMessage is same-module (not spyable via the export).
+    const { send, calls } = createSendRecorder();
+    let listed = false;
+    await dispatchInboundMessage({
+      kind: "app_mention",
+      message: {
+        text: "<@Ubot> eval list",
+        body: "<@Ubot> eval list",
+        markdown: "@Ubot eval list",
+        ts: "2.0",
+        threadTs: "1.0",
+        channelId: "C1",
+        teamId: "T1",
+        author: { userId: "U1", isBot: false },
+      },
+      handler: acceptHandler(),
+      send,
+      credentials: { botToken: "xoxb-test" },
+      host: testHost({
+        evals: {
+          list: async () => {
+            listed = true;
+            return {
+              evals: [{ id: "smoke", fileId: "smoke" }],
+              config: { maxPlaygroundRuns: 20, durableRuns: false },
+            };
+          },
+          get: async () => undefined,
+          listRunsWithActive: async () => ({ runs: [] }),
+          start: async () => {
+            throw new Error("should not start");
+          },
+          cancel: async () => {
+            throw new Error("should not cancel");
+          },
+        },
+      }),
+    });
+    expect(calls).toHaveLength(0);
+    expect(listed).toBe(true);
+  });
+
+  it("skips eval directive when evalCommandsEnabled is false", async () => {
+    const { send, calls } = createSendRecorder();
+    await dispatchInboundMessage({
+      kind: "app_mention",
+      message: {
+        text: "<@Ubot> eval list",
+        body: "<@Ubot> eval list",
+        markdown: "@Ubot eval list",
+        ts: "2.0",
+        threadTs: "1.0",
+        channelId: "C1",
+        teamId: "T1",
+        author: { userId: "U1", isBot: false },
+      },
+      handler: acceptHandler(),
+      send,
+      credentials: undefined,
+      host: testHost({
+        evals: {
+          list: async () => {
+            throw new Error("should not list");
+          },
+          get: async () => undefined,
+          listRunsWithActive: async () => ({ runs: [] }),
+          start: async () => {
+            throw new Error("should not start");
+          },
+          cancel: async () => {
+            throw new Error("should not cancel");
+          },
+        },
+      }),
+      evalCommandsEnabled: false,
+    });
+    expect(calls).toHaveLength(1);
+  });
+
+  it("dedupes asks by channel:ts", async () => {
+    const root = await mkdtemp(join(tmpdir(), "dispatch-dedupe-"));
+    cleanups.push(() => rm(root, { recursive: true, force: true }));
+    const host = testHost({
+      nudgeRoot: join(root, "nudges"),
+      askRoot: join(root, "asks"),
+    });
+    const { send, calls } = createSendRecorder();
+    const message = {
+      text: "hello",
+      body: "hello",
+      markdown: "hello",
+      ts: "2.0",
+      threadTs: "1.0",
+      channelId: "C1",
+      teamId: "T1",
+      author: { userId: "U1", isBot: false },
+    };
+    await dispatchInboundMessage({
+      kind: "app_mention",
+      message,
+      handler: acceptHandler(),
+      send,
+      credentials: undefined,
+      host,
+    });
+    await dispatchInboundMessage({
+      kind: "app_mention",
+      message,
+      handler: acceptHandler(),
+      send,
+      credentials: undefined,
+      host,
+    });
+    expect(calls).toHaveLength(1);
+  });
+
+  it("hydrates prior thread messages into the prompt", async () => {
+    vi.spyOn(slackApi, "callSlackApiSoft").mockResolvedValue({
+      ok: true,
+      messages: [
+        {
+          ts: "1.0",
+          bot_id: "BDD",
+          username: "Datadog",
+          text: "Monitor alert: rate limited",
+        },
+        {
+          ts: "2.0",
+          user: "U1",
+          text: "@jenny what happened here?",
+        },
+      ],
+      has_more: false,
+    });
+    const { send, calls } = createSendRecorder();
+    const lines: string[] = [];
+    await dispatchInboundMessage({
+      kind: "app_mention",
+      message: {
+        text: "<@BJENNY> what happened here?",
+        body: "<@BJENNY> what happened here?",
+        markdown: "@BJENNY what happened here?",
+        ts: "2.0",
+        threadTs: "1.0",
+        channelId: "C1",
+        teamId: "T1",
+        author: { userId: "U1", isBot: false },
+      },
+      handler: acceptHandler(),
+      send,
+      credentials: { botToken: "xoxb-test" },
+      host: testHost(),
+      log: createSlackLogger((line) => lines.push(line)),
+    });
+    expect(calls).toHaveLength(1);
+    expect(calls[0]!.message).toContain("<slack_thread>");
+    expect(calls[0]!.message).toContain("Monitor alert: rate limited");
+    expect(calls[0]!.message).toContain("@BJENNY what happened here?");
+    expect(calls[0]!.message).not.toMatch(/\[reply\].*what happened here\?/);
+    expect(lines.some((line) => line.includes("thread context loaded"))).toBe(
+      true
+    );
+    vi.restoreAllMocks();
+  });
+
+  it("loads slack_thread_delta on warm continuations", async () => {
+    const spy = vi.spyOn(slackApi, "callSlackApiSoft").mockResolvedValue({
+      ok: true,
+      messages: [
+        { ts: "1.0", bot_id: "BDD", text: "parent alert" },
+        { ts: "1.5", bot_id: "BJENNY", text: "first reply" },
+        // Non-trigger reply after our last post — appears in the delta.
+        // The triggering ask (3.0) is excluded from the block and appended
+        // as user text at the end of the prompt.
+        { ts: "2.0", user: "U2", text: "also looking" },
+        { ts: "3.0", user: "U1", text: "any leads?" },
+      ],
+      has_more: false,
+    });
+    const { send, calls } = createSendRecorder();
+    await dispatchInboundMessage({
+      kind: "app_mention",
+      message: {
+        text: "any leads?",
+        body: "any leads?",
+        markdown: "any leads?",
+        ts: "3.0",
+        threadTs: "1.0",
+        channelId: "C1",
+        teamId: "T1",
+        author: { userId: "U1", isBot: false },
+      },
+      handler: acceptHandler(),
+      send,
+      credentials: { botToken: "xoxb-test" },
+      host: testHost(),
+      hasContinuationSession: async () => true,
+      // Agent watermark (not Datadog's parent) — human reply at 2.0 is in delta.
+      getContinuationLastBotMessageTs: async () => "1.5",
+    });
+    expect(spy).toHaveBeenCalled();
+    expect(calls[0]?.message).toContain("<slack_thread_delta>");
+    expect(calls[0]?.message).toContain("also looking");
+    expect(calls[0]?.message).not.toContain("<slack_thread>");
+    expect(calls[0]?.options?.admission).toBe("coalesce");
+    spy.mockRestore();
+  });
+
+  it("releases ask claim when send fails", async () => {
+    const root = await mkdtemp(join(tmpdir(), "dispatch-claim-release-"));
+    cleanups.push(() => rm(root, { recursive: true, force: true }));
+    const host = testHost({
+      nudgeRoot: join(root, "nudges"),
+      askRoot: join(root, "asks"),
+    });
+    const send: SendMessageFn = async () => {
+      throw new Error("boom");
+    };
+    await dispatchInboundMessage({
+      kind: "app_mention",
+      message: {
+        text: "hello",
+        body: "hello",
+        markdown: "hello",
+        ts: "2.0",
+        threadTs: "1.0",
+        channelId: "C1",
+        teamId: "T1",
+        author: { userId: "U1", isBot: false },
+      },
+      handler: acceptHandler(),
+      send,
+      credentials: undefined,
+      host,
+      log: createSlackLogger(() => undefined),
+    });
+    expect(await host.slackNudges?.tryClaimAsk("C1", "2.0")).toBe(true);
+  });
+});