@cursor/bdk 0.2.2 → 0.2.4

package/src/extensions/slack-communication/evals/slack-communication.eval.ts

@@ -1,830 +0,0 @@
-import { mkdtemp, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { slackSessionFooter } from "../../../channels/slack/footer.js";
-import { defineEval, type EvalDefinition, equals } from "../../../evals.js";
-import slackCommunication from "../extension.js";
-import {
-  chipStatuses,
-  countMethod,
-  JENNY_ACK,
-  methodsBeforePaint,
-  outputField,
-  playAgentic,
-  playHeldWrites,
-  playInbound,
-  publish,
-  runSlackTools,
-  signal,
-  startInbound,
-  uniqueTexts,
-} from "./harness.js";
-
-function contextFooter(call: { args: Record<string, unknown> }): string | undefined {
-  const blocks = call.args.blocks;
-  if (!Array.isArray(blocks)) {
-    return undefined;
-  }
-  const last = blocks[blocks.length - 1] as
-    | { type?: string; elements?: Array<{ text?: string }> }
-    | undefined;
-  if (last?.type !== "context") {
-    return undefined;
-  }
-  return last.elements?.[0]?.text;
-}
-
-const slackCommunicationEval: EvalDefinition = defineEval({
-  description:
-    "Agentic Slack honors slack-communication tools: new message per post-update, no silent drop, no assistant-text double post, no per-tool chatter.",
-  cases: [
-    {
-      id: "session-footer-on-final",
-      description: "Final post-update gets a context footer. Mid-turn posts do not.",
-      async test(t) {
-        const sink = await playAgentic(
-          [
-            { type: "turn.started" },
-            ...publish("Looking…"),
-            ...publish("Leak is in a.ts."),
-            { type: "turn.completed", result: "" },
-          ],
-          {
-            footer: ({ sessionId, durationMs }) =>
-              `<https://cursor.com/dashboard/deployed-agents/jenny/playground?sessionId=${sessionId}|View session> · ${durationMs}ms`,
-          },
-        );
-        const posts = sink.calls.filter(call => call.method === "chat.postMessage");
-        t.check(
-          posts.every(call => call.args.blocks === undefined),
-          equals(true),
-        );
-        const updates = sink.calls.filter(call => call.method === "chat.update");
-        t.check(updates.length, equals(1));
-        const footer = contextFooter(updates[0] ?? { args: {} });
-        t.check(footer?.includes("View session"), equals(true));
-        t.check(footer?.includes("sessionId=s1"), equals(true));
-        t.check(uniqueTexts(sink), equals(["Looking…", "Leak is in a.ts."]));
-      },
-    },
-    {
-      id: "session-footer-omitted-locally",
-      description: "No hosted public id: slackSessionFooter emits nothing.",
-      async test(t) {
-        const sink = await playAgentic(
-          [{ type: "turn.started" }, ...publish("Done."), { type: "turn.completed", result: "" }],
-          { footer: slackSessionFooter({ slug: "jenny" }) },
-        );
-        t.check(
-          sink.calls.some(call => call.args.blocks !== undefined),
-          equals(false),
-        );
-        t.check(countMethod(sink, "chat.update"), equals(0));
-      },
-    },
-    {
-      id: "session-footer-keeps-latest-after-edit",
-      description: "Edit of an earlier post-update does not rewrite the latest with that text.",
-      async test(t) {
-        const sink = await playAgentic(
-          [
-            { type: "turn.started" },
-            ...publish("Looking…", { ts: "1" }),
-            ...publish("Leak is in a.ts.", { ts: "2" }),
-            ...signal("edit-message", { ts: "1", message: "Opened a.ts." }, { id: "e1" }),
-            { type: "turn.completed", result: "" },
-          ],
-          {
-            footer: ({ sessionId }) =>
-              `<https://cursor.com/dashboard/deployed-agents/jenny/playground?sessionId=${sessionId}|View session> · 1s`,
-          },
-        );
-        const updates = sink.calls.filter(call => call.method === "chat.update");
-        const footer = updates.find(call => contextFooter(call) !== undefined);
-        t.check(footer?.args.text, equals("Leak is in a.ts."));
-        t.check(footer?.args.ts === updates[0]?.args.ts, equals(false));
-      },
-    },
-    {
-      id: "session-footer-after-card",
-      description: "A post-card after the last post-update still footers that post.",
-      async test(t) {
-        const sink = await playAgentic(
-          [
-            { type: "turn.started" },
-            ...publish("Leak is in a.ts."),
-            {
-              type: "actions.requested",
-              calls: [
-                {
-                  tool: "post-card",
-                  args: {
-                    id: "scan",
-                    title: "Scan",
-                    status: "complete",
-                    details: "Done",
-                  },
-                  id: "card1",
-                },
-              ],
-            },
-            {
-              type: "action.result",
-              tool: "post-card",
-              id: "card1",
-              output: {
-                id: "scan",
-                title: "Scan",
-                status: "complete",
-                details: "Done",
-              },
-            },
-            { type: "turn.completed", result: "" },
-          ],
-          {
-            footer: ({ sessionId }) =>
-              `<https://cursor.com/dashboard/deployed-agents/jenny/playground?sessionId=${sessionId}|View session> · 1s`,
-          },
-        );
-        const footer = sink.calls
-          .filter(call => call.method === "chat.update")
-          .map(contextFooter)
-          .find(text => text !== undefined);
-        t.check(footer?.includes("View session"), equals(true));
-        t.check(uniqueTexts(sink).includes("Leak is in a.ts."), equals(true));
-      },
-    },
-    {
-      id: "final-reply",
-      description: "A successful post-update always becomes the Slack reply.",
-      async test(t) {
-        const sink = await playAgentic([
-          { type: "turn.started" },
-          ...publish("Shipped the fix.", { tool: "slack__post-update" }),
-          { type: "turn.completed", result: "I should not appear." },
-        ]);
-        t.check(uniqueTexts(sink), equals(["Shipped the fix."]));
-        t.check(countMethod(sink, "chat.postMessage"), equals(1));
-      },
-    },
-    {
-      id: "no-silent-turn",
-      description: "Work after the last post-update does not drop the reply.",
-      async test(t) {
-        const sink = await playAgentic([
-          { type: "turn.started" },
-          ...publish("Found the leak."),
-          {
-            type: "actions.requested",
-            calls: [{ tool: "grep", args: { pattern: "TODO" } }],
-          },
-          { type: "turn.completed", result: "" },
-        ]);
-        t.check(uniqueTexts(sink), equals(["Found the leak."]));
-        t.check(countMethod(sink, "chat.postMessage"), equals(1));
-      },
-    },
-    {
-      id: "no-double-final",
-      description: "Assistant text does not post a second reply.",
-      async test(t) {
-        const sink = await playAgentic([
-          { type: "turn.started" },
-          {
-            type: "message.completed",
-            text: "Narrating the turn.",
-          },
-          ...publish("Done."),
-          { type: "turn.completed", result: "Narrating the turn." },
-        ]);
-        t.check(uniqueTexts(sink), equals(["Done."]));
-        t.check(countMethod(sink, "chat.postMessage"), equals(1));
-      },
-    },
-    {
-      id: "mid-turn-not-chatter",
-      description: "Non-signal tools do not post. Cards use the stream.",
-      async test(t) {
-        const sink = await playAgentic([
-          { type: "turn.started" },
-          {
-            type: "actions.requested",
-            calls: [
-              { tool: "grep", args: { pattern: "foo" } },
-              { tool: "read_file", args: { path: "a.ts" } },
-            ],
-          },
-          {
-            type: "actions.requested",
-            calls: [
-              {
-                tool: "post-card",
-                args: {
-                  id: "scan",
-                  title: "Scan",
-                  status: "in_progress",
-                  details: "Reading a.ts",
-                },
-                id: "card1",
-              },
-            ],
-          },
-          {
-            type: "action.result",
-            tool: "post-card",
-            id: "card1",
-            output: {
-              id: "scan",
-              title: "Scan",
-              status: "in_progress",
-              details: "Reading a.ts",
-            },
-          },
-          ...publish("Leak is in a.ts."),
-          { type: "turn.completed", result: "Here is a long wrap-up." },
-        ]);
-        t.check(countMethod(sink, "chat.postMessage"), equals(1));
-        t.check(uniqueTexts(sink), equals(["Leak is in a.ts."]));
-        t.check(
-          sink
-            .chunks()
-            .some(
-              chunk =>
-                typeof chunk === "object" &&
-                chunk !== null &&
-                "type" in chunk &&
-                chunk.type === "task_update",
-            ),
-          equals(true),
-        );
-      },
-    },
-    {
-      id: "no-nested-subagent",
-      description: "A nested subagent post-update does not become the reply.",
-      async test(t) {
-        const sink = await playAgentic([
-          { type: "turn.started" },
-          {
-            type: "actions.requested",
-            parentCallId: "task1",
-            calls: [
-              {
-                tool: "post-update",
-                args: { message: "Nested chatter." },
-                parentCallId: "task1",
-              },
-            ],
-          },
-          {
-            type: "action.result",
-            tool: "post-update",
-            parentCallId: "task1",
-            output: { message: "Nested chatter." },
-          },
-          {
-            type: "action.result",
-            tool: "post-file",
-            parentCallId: "task1",
-            output: { path: "/tmp/x.md", name: "x.md" },
-          },
-          ...publish("Parent reply."),
-          { type: "turn.completed" },
-        ]);
-        t.check(uniqueTexts(sink), equals(["Parent reply."]));
-        t.check(countMethod(sink, "chat.postMessage"), equals(1));
-        t.check(countMethod(sink, "files.getUploadURLExternal"), equals(0));
-      },
-    },
-    {
-      id: "result-only",
-      description: "A request without a successful result does not post.",
-      async test(t) {
-        const oversized = "x".repeat(2000);
-        const sink = await playAgentic([
-          { type: "turn.started" },
-          {
-            type: "actions.requested",
-            calls: [
-              {
-                tool: "post-update",
-                args: { message: oversized },
-                id: "bad",
-              },
-            ],
-          },
-          {
-            type: "action.result",
-            tool: "post-update",
-            id: "bad",
-            isError: true,
-            output: "too long",
-          },
-          {
-            type: "actions.requested",
-            calls: [
-              {
-                tool: "post-update",
-                args: { message: "Would post." },
-                id: "d1",
-              },
-            ],
-          },
-          {
-            type: "action.result",
-            tool: "post-update",
-            id: "d1",
-            stubbed: true,
-            output: "Operation acknowledged.",
-          },
-          { type: "turn.completed" },
-        ]);
-        t.check(uniqueTexts(sink), equals([]));
-        t.check(countMethod(sink, "chat.postMessage"), equals(0));
-      },
-    },
-    {
-      id: "failed-keeps-update",
-      description: "turn.failed leaves the last post-update in the thread.",
-      async test(t) {
-        const sink = await playAgentic([
-          { type: "turn.started" },
-          ...publish("Still working."),
-          { type: "turn.failed", message: "turn interrupted" },
-        ]);
-        t.check(uniqueTexts(sink), equals(["Still working."]));
-        t.check(countMethod(sink, "chat.delete"), equals(0));
-      },
-    },
-    {
-      id: "react",
-      description: "A reaction lands and the final reply still posts.",
-      async test(t) {
-        const sink = await playAgentic([
-          { type: "turn.started" },
-          ...signal("react", { emoji: "eyes" }, { id: "r1" }),
-          ...publish("Shipped the fix."),
-          { type: "turn.completed", result: "I should not appear." },
-        ]);
-        const add = sink.calls.find(call => call.method === "reactions.add");
-        t.check(add?.args.name, equals("eyes"));
-        t.check(add?.args.timestamp, equals("1.0"));
-        t.check(add?.args.channel, equals("C1"));
-        t.check(uniqueTexts(sink), equals(["Shipped the fix."]));
-        t.check(countMethod(sink, "chat.postMessage"), equals(1));
-      },
-    },
-    {
-      id: "signal-only",
-      description:
-        "React writes Slack without inventing a reply. Model set-status does not own the chip.",
-      async test(t) {
-        const sink = await playAgentic([
-          { type: "turn.started" },
-          ...signal("react", { emoji: "white_check_mark", ts: "9.9" }, { id: "r1" }),
-          ...signal("set-status", { status: "Reading a.ts" }, { id: "st1" }),
-          { type: "turn.completed", result: "I should not appear." },
-        ]);
-        const adds = sink.calls.filter(call => call.method === "reactions.add");
-        t.check(adds[0]?.args.name, equals("eyes"));
-        t.check(adds[0]?.args.timestamp, equals("1.0"));
-        t.check(
-          adds.some(call => call.args.name === "white_check_mark" && call.args.timestamp === "9.9"),
-          equals(true),
-        );
-        const session = sink.calls.find(call => call.method === "agents.sessions.setStatus");
-        t.check(session?.args.status, equals("active"));
-        const chips = chipStatuses(sink);
-        t.check(chips[0], equals("Thinking…"));
-        t.check(chips.includes("Reading a.ts"), equals(false));
-        t.check(chips.at(-1), equals(""));
-        t.check(uniqueTexts(sink), equals([]));
-        t.check(countMethod(sink, "chat.postMessage"), equals(0));
-      },
-    },
-    {
-      id: "ack-on-start",
-      description: "Turn start applies the configured reaction without a model react.",
-      async test(t) {
-        const def = await playAgentic([{ type: "turn.started" }]);
-        const eyes = def.calls.find(call => call.method === "reactions.add");
-        t.check(eyes?.args.name, equals("eyes"));
-        t.check(eyes?.args.timestamp, equals("1.0"));
-        t.check(eyes?.args.channel, equals("C1"));
-        t.check(countMethod(def, "reactions.add"), equals(1));
-        const jenny = await playAgentic([{ type: "turn.started" }], {
-          ack: JENNY_ACK,
-        });
-        t.check(
-          jenny.calls.find(call => call.method === "reactions.add")?.args.name,
-          equals("paw_prints"),
-        );
-      },
-    },
-    {
-      id: "tools-do-not-block",
-      description: "react, set-status, and post-update return without waiting on Slack.",
-      async test(t) {
-        const local = await runSlackTools();
-        t.check(local.stalled, equals(false));
-        t.check(outputField(local.outputs.react, "emoji"), equals("white_check_mark"));
-        t.check(outputField(local.outputs.status, "status"), equals("Reading a.ts"));
-        t.check(outputField(local.outputs.post, "message"), equals("Looking."));
-        const held = await playHeldWrites();
-        t.check(held.stalled, equals(false));
-        t.check(uniqueTexts(held.sink), equals(["Looking."]));
-        t.check(
-          held.sink.calls.some(
-            call => call.method === "reactions.add" && call.args.name === "white_check_mark",
-          ),
-          equals(true),
-        );
-      },
-    },
-    {
-      id: "trajectory-is-not-a-reply",
-      description: "Assistant trajectory is not a Slack reply. The agent must post-update.",
-      async test(t) {
-        const silent = await playAgentic([
-          { type: "turn.started" },
-          { type: "message.completed", text: "I should not appear." },
-          { type: "turn.completed", result: "I should not appear." },
-        ]);
-        t.check(countMethod(silent, "chat.postMessage"), equals(0));
-        t.check(uniqueTexts(silent), equals([]));
-        t.check(countMethod(silent, "reactions.add"), equals(1));
-        const posted = await playAgentic([
-          { type: "turn.started" },
-          ...publish("Here."),
-          { type: "turn.completed", result: "I should not appear." },
-        ]);
-        t.check(uniqueTexts(posted), equals(["Here."]));
-        t.check(countMethod(posted, "chat.postMessage"), equals(1));
-      },
-    },
-    {
-      id: "cold-dm-paint-first",
-      description: "Cold DM first Slack writes are ack and thinking. No thread fetch.",
-      async test(t) {
-        const play = await playInbound({ ack: JENNY_ACK, channelId: "D1" });
-        t.check(methodsBeforePaint(play.sink), equals([]));
-        t.check(play.methodsBeforeSend.includes("reactions.add"), equals(true));
-        t.check(play.methodsBeforeSend.includes("assistant.threads.setStatus"), equals(true));
-        t.check(play.methodsBeforeSend.includes("conversations.replies"), equals(false));
-        t.check(play.methodsBeforeSend.includes("users.info"), equals(false));
-        t.check(play.methodsBeforeSend.includes("chat.postMessage"), equals(false));
-        t.check(
-          play.sink.calls.find(call => call.method === "reactions.add")?.args.name,
-          equals("paw_prints"),
-        );
-        t.check(
-          play.sink.calls.find(call => call.method === "assistant.threads.setStatus")?.args.status,
-          equals("Thinking…"),
-        );
-      },
-    },
-    {
-      id: "cold-dm-skips-session-probe",
-      description: "A DM send does not wait on the session probe or last-bot watermark.",
-      async test(t) {
-        let lastBot = false;
-        const finished = playInbound({
-          ack: JENNY_ACK,
-          channelId: "D1",
-          hasContinuationSession: () => new Promise(() => {}),
-          getContinuationLastBotMessageTs: async () => {
-            lastBot = true;
-            return "0.5";
-          },
-        });
-        const raced = await Promise.race([
-          finished.then(play => ({ play, stalled: false as const })),
-          new Promise<{ play: undefined; stalled: true }>(resolve => {
-            setTimeout(() => resolve({ play: undefined, stalled: true }), 100);
-          }),
-        ]);
-        t.check(raced.stalled, equals(false));
-        t.check(lastBot, equals(false));
-        t.check(raced.play?.methodsBeforeSend.includes("reactions.add"), equals(true));
-        t.check(raced.play?.methodsBeforeSend.includes("conversations.replies"), equals(false));
-      },
-    },
-    {
-      id: "cold-dm-paint-overlaps-membership",
-      description:
-        "First paint starts while users.info is still in flight. Send waits for the gate.",
-      async test(t) {
-        const inbound = startInbound({
-          ack: JENNY_ACK,
-          channelId: "D1",
-          blockExternals: true,
-          hold: ["users.info"],
-        });
-        await new Promise(resolve => setTimeout(resolve, 30));
-        t.check(inbound.sink.methods().includes("users.info"), equals(true));
-        t.check(inbound.sink.methods().includes("reactions.add"), equals(true));
-        t.check(inbound.sink.methods().includes("assistant.threads.setStatus"), equals(true));
-        t.check(inbound.sent(), equals(false));
-        inbound.sink.release();
-        const play = await inbound.done;
-        t.check(inbound.sent(), equals(true));
-        t.check(play.methodsBeforeSend.includes("users.info"), equals(true));
-        t.check(
-          play.sink.calls.find(call => call.method === "reactions.add")?.args.name,
-          equals("paw_prints"),
-        );
-      },
-    },
-    {
-      id: "cold-dm-send-overlaps-paint",
-      description: "Send starts while inbound paint is still in flight. Paint is already started.",
-      async test(t) {
-        const inbound = startInbound({
-          ack: JENNY_ACK,
-          channelId: "D1",
-          hold: ["reactions.add", "assistant.threads.setStatus"],
-        });
-        await new Promise(resolve => setTimeout(resolve, 30));
-        t.check(inbound.sink.methods().includes("reactions.add"), equals(true));
-        t.check(inbound.sink.methods().includes("assistant.threads.setStatus"), equals(true));
-        t.check(inbound.sent(), equals(true));
-        inbound.sink.release();
-        const play = await inbound.done;
-        t.check(play.methodsBeforeSend.includes("reactions.add"), equals(true));
-        t.check(play.methodsBeforeSend.includes("chat.postMessage"), equals(false));
-      },
-    },
-    {
-      id: "thinking-status",
-      description: "The thinking hook paints the chip. No model set-status.",
-      async test(t) {
-        const sink = await playAgentic([
-          { type: "turn.started" },
-          { type: "reasoning.appended", text: "Checking the leak in a.ts" },
-          { type: "turn.completed" },
-        ]);
-        const chips = chipStatuses(sink);
-        t.check(chips[0], equals("Thinking…"));
-        t.check(chips.includes("Checking the leak in a.ts"), equals(true));
-        t.check(chips.at(-1), equals(""));
-        t.check(countMethod(sink, "chat.postMessage"), equals(0));
-        t.check(
-          sink.calls.some(call => call.method === "reactions.add"),
-          equals(true),
-        );
-      },
-    },
-    {
-      // Quiet shape this catches: open + silence + final, no tool chips.
-      id: "investigate-alive",
-      description:
-        "Multi-step investigate: Thinking… then tool chips on actions.requested; sparse posts (open, dead-end, breakthrough, final). Tools and set-status are not chat. Model set-status does not own the chip.",
-      async test(t) {
-        const open = "Looking at the east-tower lantern now.";
-        const widen = "Last night's wick log is empty. Checking the week.";
-        const found =
-          "The lantern is on Hollowmere quay. No live flame. The 3am soot ring is the only mark.";
-        const final =
-          "TL;DR: no live flame. The 3am soot ring on Hollowmere quay is the only mark.";
-        const sink = await playAgentic([
-          { type: "turn.started" },
-          {
-            type: "reasoning.appended",
-            text: "Reading the tower map.",
-          },
-          ...signal("set-status", { status: "Sifting ashes…" }, { id: "st1" }),
-          ...publish(open, { id: "u1" }),
-          {
-            type: "message.completed",
-            text: "Checking last night's wick log.",
-            finishReason: "tool_call",
-          },
-          {
-            type: "actions.requested",
-            calls: [{ tool: "wick-log", id: "w1" }],
-          },
-          {
-            type: "action.result",
-            tool: "wick-log",
-            id: "w1",
-            output: { hits: 0 },
-          },
-          ...publish(widen, { id: "u2" }),
-          {
-            type: "actions.requested",
-            calls: [{ tool: "wick-log", id: "w2" }],
-          },
-          {
-            type: "message.completed",
-            text: "The lantern is on Hollowmere quay.",
-            finishReason: "tool_call",
-          },
-          {
-            type: "actions.requested",
-            calls: [{ tool: "wick-log", id: "w3" }],
-          },
-          {
-            type: "message.completed",
-            text: "Posting what I found.",
-            finishReason: "tool_call",
-          },
-          ...publish(found, { id: "u3" }),
-          {
-            type: "actions.requested",
-            calls: [{ tool: "harbor-book", id: "h1" }],
-          },
-          ...publish(final, { id: "u4" }),
-          { type: "turn.completed", result: "I should not appear." },
-        ]);
-        const chips = chipStatuses(sink);
-        t.check(chips[0], equals("Thinking…"));
-        t.check(chips.includes("Reading the tower map."), equals(true));
-        t.check(chips.includes("Sifting ashes…"), equals(false));
-        t.check(chips.includes("Running post-update…"), equals(false));
-        t.check(chips.includes("Running set-status…"), equals(false));
-        t.check(chips.includes("Checking last night's wick log."), equals(true));
-        t.check(chips.includes("Running wick-log…"), equals(true));
-        t.check(chips.includes("The lantern is on Hollowmere quay."), equals(true));
-        t.check(chips.includes("Posting what I found."), equals(false));
-        t.check(chips.includes("Running harbor-book…"), equals(true));
-        t.check(chips.at(-1), equals(""));
-        t.check(uniqueTexts(sink), equals([open, widen, found, final]));
-        t.check(countMethod(sink, "chat.postMessage"), equals(4));
-        t.check(countMethod(sink, "chat.update"), equals(0));
-      },
-    },
-    {
-      id: "start-chip-rotates",
-      description:
-        "Inbound Thinking… includes Slack's rotating loading_messages so the chip stays alive during TTFT.",
-      async test(t) {
-        const play = await playInbound({ ack: JENNY_ACK, channelId: "D1" });
-        const status = play.sink.calls.find(call => call.method === "assistant.threads.setStatus");
-        t.check(status?.args.status, equals("Thinking…"));
-        t.check(
-          status?.args.loading_messages,
-          equals(["Thinking…", "Working on it…", "Almost there…"]),
-        );
-      },
-    },
-    {
-      id: "dm-threaded-reply",
-      description: "A DM reply threads under the ask.",
-      async test(t) {
-        const sink = await playAgentic(
-          [{ type: "turn.started" }, ...publish("Here."), { type: "turn.completed" }],
-          { channelId: "D1" },
-        );
-        const posted = sink.calls.find(call => call.method === "chat.postMessage");
-        t.check(posted?.args.channel, equals("D1"));
-        t.check(posted?.args.thread_ts, equals("1.0"));
-        t.check(posted?.args.text ?? posted?.args.markdown_text, equals("Here."));
-      },
-    },
-    {
-      id: "dm-threaded-card",
-      description: "A DM post-card streams in the ask thread.",
-      async test(t) {
-        const sink = await playAgentic(
-          [
-            { type: "turn.started" },
-            {
-              type: "action.result",
-              tool: "post-card",
-              id: "card1",
-              output: {
-                id: "scan",
-                title: "Scan",
-                status: "in_progress",
-                details: "Reading a.ts",
-              },
-            },
-          ],
-          { channelId: "D1", startPainted: true },
-        );
-        const started = sink.calls.find(call => call.method === "chat.startStream");
-        t.check(started?.args.channel, equals("D1"));
-        t.check(started?.args.thread_ts, equals("1.0"));
-      },
-    },
-    {
-      id: "inbound-paint-skips-backstop",
-      description: "Inbound already painted: turn.started does not hit Slack again.",
-      async test(t) {
-        const sink = await playAgentic([{ type: "turn.started" }], {
-          startPainted: true,
-        });
-        t.check(countMethod(sink, "reactions.add"), equals(0));
-        t.check(countMethod(sink, "assistant.threads.setStatus"), equals(0));
-      },
-    },
-    {
-      id: "status-on-start",
-      description: "The status chip is set on turn start without a tool call.",
-      async test(t) {
-        const sink = await playAgentic([{ type: "turn.started" }]);
-        const chip = sink.calls.find(call => call.method === "assistant.threads.setStatus");
-        t.check(chip?.args.status, equals("Thinking…"));
-        t.check(countMethod(sink, "chat.postMessage"), equals(0));
-        t.check(countMethod(sink, "chat.update"), equals(0));
-      },
-    },
-    {
-      id: "mid-turn-new-messages",
-      description: "Mid-turn post-update posts a new message. The final is a new message.",
-      async test(t) {
-        const sink = await playAgentic([
-          { type: "turn.started" },
-          ...publish("Looking at a.ts.", { id: "u1" }),
-          ...publish("Leak is in a.ts.", { id: "u2" }),
-          { type: "turn.completed", result: "I should not appear." },
-        ]);
-        t.check(uniqueTexts(sink), equals(["Looking at a.ts.", "Leak is in a.ts."]));
-        t.check(countMethod(sink, "chat.postMessage"), equals(2));
-        t.check(countMethod(sink, "chat.update"), equals(0));
-      },
-    },
-    {
-      id: "edit-this-turn",
-      description: "Edit uses the ts post-update returned. Slack sees the bound message ts.",
-      async test(t) {
-        const sink = await playAgentic([
-          { type: "turn.started" },
-          ...publish("Shipped 4.", { ts: "1" }),
-          ...signal("edit-message", { ts: "1", message: "Shipped 3." }, { id: "e1" }),
-          { type: "turn.completed" },
-        ]);
-        const update = sink.calls.find(call => call.method === "chat.update");
-        t.check(update?.args.ts, equals("3.0"));
-        t.check(update?.args.markdown_text, equals("Shipped 3."));
-        t.check(countMethod(sink, "chat.postMessage"), equals(1));
-        t.check(countMethod(sink, "chat.update"), equals(1));
-        t.check(countMethod(sink, "chat.delete"), equals(0));
-      },
-    },
-    {
-      id: "delete-this-turn",
-      description: "Delete uses the ts post-update returned. Slack sees the bound message ts.",
-      async test(t) {
-        const sink = await playAgentic([
-          { type: "turn.started" },
-          ...publish("Posted in the wrong thread.", { ts: "1" }),
-          ...signal("delete-message", { ts: "1", reason: "wrong thread" }, { id: "d1" }),
-          { type: "turn.completed" },
-        ]);
-        const removed = sink.calls.find(call => call.method === "chat.delete");
-        t.check(removed?.args.ts, equals("3.0"));
-        t.check(countMethod(sink, "chat.postMessage"), equals(1));
-        t.check(countMethod(sink, "chat.update"), equals(0));
-        t.check(countMethod(sink, "chat.delete"), equals(1));
-      },
-    },
-    {
-      id: "foreign-ts-rejected",
-      description: "Edit and delete of a foreign ts do not write Slack.",
-      async test(t) {
-        const sink = await playAgentic([
-          { type: "turn.started" },
-          ...publish("Shipped the fix."),
-          ...signal("edit-message", { ts: "9.9", message: "Not this one." }, { id: "e1" }),
-          ...signal("delete-message", { ts: "9.9", reason: "wrong thread" }, { id: "d1" }),
-          { type: "turn.completed" },
-        ]);
-        t.check(uniqueTexts(sink), equals(["Shipped the fix."]));
-        t.check(countMethod(sink, "chat.postMessage"), equals(1));
-        t.check(countMethod(sink, "chat.update"), equals(0));
-        t.check(countMethod(sink, "chat.delete"), equals(0));
-      },
-    },
-    {
-      id: "file-attaches",
-      description: "A staged file uploads after the reply.",
-      async test(t) {
-        const dir = await mkdtemp(join(tmpdir(), "slack-comm-"));
-        const path = join(dir, "note.md");
-        await writeFile(path, "evidence\n");
-        const sink = await playAgentic([
-          { type: "turn.started" },
-          ...publish("See the note."),
-          ...signal("post-file", { path, name: "note.md", workspace: dir }, { id: "f1" }),
-          { type: "turn.completed" },
-        ]);
-        t.check(uniqueTexts(sink), equals(["See the note."]));
-        t.check(countMethod(sink, "chat.postMessage"), equals(1));
-        t.check(countMethod(sink, "files.getUploadURLExternal"), equals(1));
-        t.check(countMethod(sink, "files.completeUploadExternal"), equals(1));
-      },
-    },
-    {
-      id: "voice",
-      description: "slack-voice leads with result; tone appends.",
-      async test(t) {
-        slackCommunication({ tone: "Name the risk next." });
-        const { DEFAULT_VOICE, default: slackVoice } = await import("../skills/slack-voice.js");
-        t.check(slackVoice.markdown, equals(`${DEFAULT_VOICE}\n\nName the risk next.`));
-      },
-    },
-  ],
-});
-
-export default slackCommunicationEval;