@cursor/july 0.1.109 → 0.1.111

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

@@ -0,0 +1,953 @@
+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;