@cursor/july 0.1.25 → 0.1.27

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

@@ -1,795 +0,0 @@
-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);
-  });
-});