@desplega.ai/agent-swarm 2.5.3 → 2.6.0

package/src/tests/sessions-tree.test.ts

@@ -1,9 +1,16 @@
 import { afterAll, beforeAll, beforeEach, describe, expect, spyOn, test } from "bun:test";
 import { createServer, type Server } from "node:http";
 import { keyPrefixRange, sessionGroupKey } from "../assets/key";
+import {
+  isSourceThreadKey,
+  NESTED_THREAD_MIN_ROOTS,
+  sessionThreadGroupKey,
+} from "../assets/source-key";
 import {
   closeDb,
   countSessions,
+  createAgent,
+  createSessionCost,
   createSteeringMessage,
   createTaskExtended,
   createUser,
@@ -12,10 +19,12 @@ import {
   listRecentSessions,
   upsertInboxState,
 } from "../be/db";
-import { getSessionTree, type SessionFilters } from "../be/db/session-tree";
+import { rememberSessionLabel } from "../be/db/session-labels";
+import { getSessionTree, type SessionFilters, threadRootsSql } from "../be/db/session-tree";
 import { setSessionShares } from "../be/session-shares";
 import { handleSessions } from "../http/sessions";
 import { getPathSegments, parseQueryParams } from "../http/utils";
+import { chatSdkContextKey } from "../tasks/context-key";
 import { beginRequestAuthScope, setRequestAuth } from "../utils/request-auth-context";
 import { listenOnFreePort } from "./test-net";
 
@@ -63,6 +72,7 @@ beforeEach(async () => {
   await getDbClient().run("DELETE FROM inbox_item_state");
   await getDbClient().run("DELETE FROM session_shares");
   await getDbClient().run("DELETE FROM agent_tasks");
+  await getDbClient().run("DELETE FROM kv_entries WHERE namespace = 'session-labels'");
 });
 afterAll(async () => {
   server.closeAllConnections();
@@ -168,7 +178,9 @@ describe("session groups and prefix bounds", () => {
     const query = spyOn(client, "query");
     let call: (typeof query.mock.calls)[number];
     try {
-      await listRecentSessions(filters({ groupKey: "shared/a/" }));
+      await listRecentSessions(
+        filters({ groupKey: "shared/a/", showSource: ["slack"], hideSource: ["ui"] }),
+      );
       call = query.mock.calls[0]!;
     } finally {
       query.mockRestore();
@@ -189,6 +201,232 @@ describe("session groups and prefix bounds", () => {
   });
 });
 
+describe("nested source thread groups", () => {
+  const channel = "shared/slack/c1/";
+  const thread = `${channel}thread:1.2/`;
+  const detailGroupKey = async (id: string) => {
+    const res = await fetch(`${baseUrl}/api/sessions/${id}`, {
+      headers: { "x-swarm-user-id": owner.id },
+    });
+    expect(res.status).toBe(200);
+    return ((await res.json()) as { groupKey: string }).groupKey;
+  };
+
+  test("two owned roots nest, lists agree, and a move collapses the group", async () => {
+    const first = await task(thread, { source: "slack" });
+    const second = await task(thread, { source: "mcp" }, NOW);
+    await getDbClient().run("UPDATE agent_tasks SET createdAt = ?, title = ? WHERE id = ?", [
+      OLD,
+      "First conversation",
+      first.id,
+    ]);
+    await getDbClient().run("UPDATE agent_tasks SET status = 'in_progress' WHERE id = ?", [
+      second.id,
+    ]);
+    await pending(second.id);
+    const single = await task(`${channel}thread:3/`);
+    const tree = await getSessionTree(actor(), NOW);
+    expect(tree.groups).toEqual([
+      { key: channel, lastActivityAt: RECENT, total: 1, unread: 1, running: 0, needsYou: 0 },
+      { key: thread, lastActivityAt: NOW, total: 2, unread: 2, running: 1, needsYou: 1 },
+    ]);
+    expect(tree.threadLabels).toEqual({ [thread]: "First conversation" });
+    expect(tree.sourceGroups).toEqual([channel, thread]);
+    expect(await ids({ groupKey: channel })).toEqual([single.id]);
+    expect(await ids({ groupKey: thread })).toEqual([first.id, second.id].sort());
+    expect(await countSessions(filters({ groupKey: channel }))).toBe(1);
+    expect(await countSessions(filters({ groupKey: thread }))).toBe(2);
+    const rows = await listRecentSessions(filters());
+    expect(rows.find((r) => r.root.id === first.id)?.groupKey).toBe(thread);
+    expect(rows.find((r) => r.root.id === single.id)?.groupKey).toBe(channel);
+    // The session pane reveals the detail's group: the same rule as the list rows.
+    expect(await detailGroupKey(first.id)).toBe(thread);
+    expect(await detailGroupKey(single.id)).toBe(channel);
+
+    const moved = await fetch(`${baseUrl}/api/session-moves`, {
+      method: "POST",
+      headers: { "x-swarm-user-id": owner.id, "content-type": "application/json" },
+      body: JSON.stringify({ rootTaskIds: [second.id], groupKey: "shared/research/" }),
+    });
+    expect(moved.status).toBe(200);
+    expect(
+      (await getSessionTree(actor(), NOW)).groups.find((g) => g.key === thread),
+    ).toBeUndefined();
+    expect(await ids({ groupKey: channel })).toEqual([first.id, single.id].sort());
+    expect(
+      (await listRecentSessions(filters())).find((r) => r.root.id === first.id)?.groupKey,
+    ).toBe(channel);
+    expect(await detailGroupKey(first.id)).toBe(channel);
+  });
+
+  test("one owned root stays a channel row despite children and ownerless roots", async () => {
+    const root = await task(thread);
+    await task(thread, { parentTaskId: root.id });
+    await task(thread, { requestedByUserId: undefined });
+    const tree = await getSessionTree(actor(), NOW);
+    expect(tree.groups.map((g) => [g.key, g.total])).toEqual([[channel, 1]]);
+    expect(tree.threadLabels).toEqual({});
+    expect((await listRecentSessions(filters({ tree: true })))[0].groupKey).toBe(channel);
+  });
+
+  test("nesting counts private roots but labels use only roots visible to each user", async () => {
+    const visible = await task(thread, { source: "slack" });
+    const hidden = await task(thread, { requestedByUserId: other.id });
+    await getDbClient().run("UPDATE agent_tasks SET title = ? WHERE id = ?", [
+      "Visible title",
+      visible.id,
+    ]);
+    await getDbClient().run("UPDATE agent_tasks SET createdAt = ?, title = ? WHERE id = ?", [
+      OLD,
+      "Hidden oldest",
+      hidden.id,
+    ]);
+    const tree = await getSessionTree(actor(), NOW, { mine: true, showSource: ["slack"] });
+    expect(tree.groups.map((g) => [g.key, g.total])).toEqual([[thread, 1]]);
+    expect(tree.threadLabels[thread]).toBe("Visible title");
+    expect(await ids({ groupKey: channel })).toEqual([]);
+    expect(await ids({ groupKey: thread })).toEqual([visible.id]);
+    const filtered = await getSessionTree(actor(), NOW, { showSource: ["ui"] });
+    expect(filtered.groups).toEqual([]);
+    expect(filtered.sourceGroups).toEqual([channel, thread]);
+    expect(filtered.threadLabels[thread]).toBe("Visible title");
+    const otherTree = await getSessionTree({ kind: "user", userId: other.id }, NOW);
+    expect(otherTree.groups.map((g) => [g.key, g.total])).toEqual([[thread, 1]]);
+    expect(otherTree.threadLabels[thread]).toBe("Hidden oldest");
+  });
+
+  test("the route merges title fallbacks and cached labels, including hidden thread groups", async () => {
+    const root = await task(thread);
+    await task(thread);
+    const text = "Oldest task text. ".repeat(8);
+    await getDbClient().run(
+      "UPDATE agent_tasks SET task = ?, title = '', createdAt = ? WHERE id = ?",
+      [text, OLD, root.id],
+    );
+    const headers = { "x-swarm-user-id": owner.id };
+    const read = async () => {
+      const res = await fetch(`${baseUrl}/api/session-tree?show=all&showSource=ui`, { headers });
+      expect(res.status).toBe(200);
+      return (await res.json()) as { labels: Record<string, string>; sourceGroups?: string[] };
+    };
+    await rememberSessionLabel(channel, "#engineering");
+    expect((await read()).labels).toEqual({
+      [channel]: "#engineering",
+      [thread]: text.trim(),
+    });
+    await rememberSessionLabel(thread, "Cached thread label");
+    const result = await read();
+    expect(result.labels[thread]).toBe("Cached thread label");
+    expect(result.sourceGroups).toBeUndefined();
+  });
+
+  test("a title fallback skips the thread context and keeps the list preview shape", async () => {
+    const root = await task(thread);
+    await task(thread);
+    const label = async (prompt: string) => {
+      await getDbClient().run(
+        "UPDATE agent_tasks SET task = ?, title = '', createdAt = ? WHERE id = ?",
+        [prompt, OLD, root.id],
+      );
+      return (await getSessionTree(actor(), NOW)).threadLabels[thread];
+    };
+    const ask = "<@U1|Lena>: Fix the release notes";
+    expect(await label(`<thread_context>\nT: earlier message\n</thread_context>\n\n${ask}`)).toBe(
+      ask,
+    );
+    // A Chat SDK prompt puts its header line before the block.
+    const chat = await label(
+      "[chat] from: Lena\n\n<thread_context>\nLena: hi\n</thread_context>\n\nShip it",
+    );
+    expect(chat).toStartWith("[chat] from: Lena");
+    expect(chat).toEndWith("Ship it");
+    expect(chat).not.toContain("Lena: hi");
+    // A tag inside a line is text, not a block.
+    expect(await label("Explain the <thread_context> tag")).toBe(
+      "Explain the <thread_context> tag",
+    );
+    // 300 characters and "…": the list preview the UI repairs (`isListPreview`).
+    expect(await label(`<thread_context>\nT: hi\n</thread_context>\n\n${"a".repeat(400)}`)).toBe(
+      `${"a".repeat(300)}…`,
+    );
+    // A prompt that is only thread context has no label: the UI shows `Thread · <ts>`.
+    expect(await label("<thread_context>\nT: hi\n</thread_context>")).toBe("");
+  });
+
+  test("only source thread leaves nest, including Telegram and Discord", async () => {
+    for (const [key, expectedGroup] of [
+      ["shared/telegram/-100/thread:42/", "shared/telegram/-100/thread:42/"],
+      ["shared/discord/77/thread:99/", "shared/discord/77/thread:99/"],
+      ["shared/slack/c1/thread:parent/thread:🚀/", "shared/slack/c1/thread:parent/thread:🚀/"],
+      ["shared/slack/c1/thread:parent/child/", "shared/slack/c1/thread:parent/child/"],
+      ["shared/slack/c1/task:leaf/", channel],
+      [`personal/${owner.id}/thread:1/`, `personal/${owner.id}/`],
+      ["shared/notes/thread:1/", "shared/notes/"],
+    ]) {
+      await getDbClient().run("DELETE FROM agent_tasks");
+      const root = await task(key);
+      await task(key);
+      expect(sessionThreadGroupKey(key, NESTED_THREAD_MIN_ROOTS)).toBe(expectedGroup);
+      expect(sessionThreadGroupKey(key, NESTED_THREAD_MIN_ROOTS - 1)).toBe(sessionGroupKey(key));
+      const threadRoots = threadRootsSql();
+      const count = await getDbClient().get<{ roots: number }>(
+        `SELECT ${threadRoots.sql} AS roots FROM agent_tasks r WHERE r.id = ?`,
+        [...threadRoots.params, root.id],
+      );
+      expect(count?.roots).toBe(isSourceThreadKey(key) ? NESTED_THREAD_MIN_ROOTS : 0);
+      expect((await listRecentSessions(filters({ rootId: root.id })))[0].groupKey).toBe(
+        expectedGroup,
+      );
+      const tree = await getSessionTree(actor(), NOW);
+      const noGroup = expectedGroup === `personal/${owner.id}/`;
+      expect(tree.noGroup.total).toBe(noGroup ? 2 : 0);
+      expect(tree.groups).toEqual(
+        noGroup
+          ? []
+          : [
+              {
+                key: expectedGroup,
+                lastActivityAt: RECENT,
+                total: 2,
+                unread: 2,
+                running: 0,
+                needsYou: 0,
+              },
+            ],
+      );
+    }
+  });
+
+  test("channel and thread queries retain indexed key lookup without LIKE", async () => {
+    await task(thread);
+    await task(thread);
+    for (const groupKey of [channel, thread]) {
+      const client = getDbClient();
+      const query = spyOn(client, "query");
+      let call: (typeof query.mock.calls)[number];
+      try {
+        await listRecentSessions(filters({ groupKey }));
+        call = query.mock.calls[0]!;
+      } finally {
+        query.mockRestore();
+      }
+      const [sql, params] = call;
+      const plan = await client.query<{ detail: string }>(`EXPLAIN QUERY PLAN ${sql}`, params);
+      expect(plan.some((p) => p.detail.startsWith("SEARCH r USING INDEX"))).toBe(true);
+      expect(
+        plan.some((p) =>
+          p.detail.includes("SEARCH session_thread_root USING INDEX idx_agent_tasks_asset_key"),
+        ),
+      ).toBe(true);
+      expect(
+        plan.some((p) => p.detail === "SCAN r" || p.detail === "SCAN session_thread_root"),
+      ).toBe(false);
+      expect(sql).not.toContain('"key" LIKE');
+      expect(sql).not.toContain("INDEXED BY");
+    }
+  });
+});
+
 describe("chain-wide read state", () => {
   test("every CASE branch uses the fixed clock and chain activity", async () => {
     const cases = [
@@ -605,6 +843,41 @@ test("session detail carries the viewer's read state with the list rule", async
   expect(bypass.lastActivityAt).toBeUndefined();
 });
 
+test("session detail carries each chain task's cost, so the header can total the whole session", async () => {
+  const agent = await createAgent({ name: "cost-agent", isLead: false, status: "idle" });
+  const root = await task();
+  const child = await task("shared/a/", { parentTaskId: root.id });
+  const grandchild = await task("shared/a/", { parentTaskId: child.id });
+  const followUp = await task("shared/a/", { parentTaskId: root.id });
+  const noCost = await task("shared/a/", { parentTaskId: root.id });
+  const spend = async (taskId: string, totalCostUsd: number) =>
+    createSessionCost({
+      sessionId: crypto.randomUUID(),
+      taskId,
+      agentId: agent.id,
+      totalCostUsd,
+      durationMs: 1_000,
+      numTurns: 1,
+      model: "test-model",
+    });
+  await spend(root.id, 0.2);
+  await spend(root.id, 0.0051);
+  await spend(child.id, 0.5);
+  await spend(grandchild.id, 0.25);
+  await spend(followUp.id, 0.335);
+
+  const res = await fetch(`${baseUrl}/api/sessions/${root.id}`);
+  const body = (await res.json()) as { chain: { id: string; totalCostUsd?: number }[] };
+  const costs = Object.fromEntries(body.chain.map((t) => [t.id, t.totalCostUsd]));
+  expect(costs[root.id]).toBeCloseTo(0.2051, 6);
+  expect(costs[child.id]).toBeCloseTo(0.5, 6);
+  expect(costs[grandchild.id]).toBeCloseTo(0.25, 6);
+  expect(costs[followUp.id]).toBeCloseTo(0.335, 6);
+  expect(costs[noCost.id]).toBeUndefined();
+  const total = body.chain.reduce((sum, t) => sum + (t.totalCostUsd ?? 0), 0);
+  expect(total).toBeCloseTo(1.2901, 6);
+});
+
 test("limit clamps to 200 and count without chain filters does not recurse", async () => {
   await getDbClient().transaction(async () => {
     for (let i = 0; i < 205; i++)
@@ -703,6 +976,67 @@ describe("source filter and list triage", () => {
       body: JSON.stringify(body),
     });
 
+  test("effective sources agree across lists, tree facets and triage", async () => {
+    const slack = await task("shared/slack/c1/thread:1/", { source: "slack" });
+    const mcpSlack = await task("shared/slack/c1/thread:2/", { source: "mcp" });
+    const telegram = await task("shared/telegram/-100/thread:42/", {
+      source: "chat",
+      contextKey: chatSdkContextKey("telegram:-100:42"),
+    });
+    const discord = await task("shared/discord/c1/task:root/", { source: "chat" });
+    const ui = await task("shared/", { source: "ui" });
+    const mcp = await task("shared/research/", { source: "mcp" });
+    const chat = await task("shared/research/", { source: "chat" });
+    const facets = (await treeOf("show=all")).sources;
+    expect(facets).toEqual([
+      { source: "slack", total: 2 },
+      { source: "chat", total: 1 },
+      { source: "discord", total: 1 },
+      { source: "mcp", total: 1 },
+      { source: "telegram", total: 1 },
+      { source: "ui", total: 1 },
+    ]);
+    const cases = [
+      ["slack", [slack.id, mcpSlack.id]],
+      ["telegram", [telegram.id]],
+      ["discord", [discord.id]],
+      ["mcp", [mcp.id]],
+      ["ui", [ui.id]],
+      ["chat", [chat.id]],
+    ] as const;
+    for (const [source, expected] of cases) {
+      const query = `show=all&showSource=${source}`;
+      const list = await listOf(`triage=inbox&${query}`);
+      expect(list.sessions.map((row) => row.root.id).sort()).toEqual([...expected].sort());
+      expect(list.total).toBe(expected.length);
+      const tree = await treeOf(query);
+      expect(tree.inbox.total).toBe(expected.length);
+      expect(tree.sources).toEqual(facets);
+      const res = await triage({
+        action: "done",
+        triage: "inbox",
+        show: "all",
+        showSource: [source],
+      });
+      expect(res.status).toBe(200);
+      expect(await res.json()).toEqual({ updated: expected.length });
+      const done = await listOf("triage=done&show=all");
+      expect(done.sessions.map((row) => row.root.id).sort()).toEqual([...expected].sort());
+      expect((await treeOf(query)).done.total).toBe(expected.length);
+      const reset = await triage({ action: "inbox", triage: "done", show: "all" });
+      expect(await reset.json()).toEqual({ updated: expected.length });
+    }
+    const hidden = await listOf("triage=inbox&show=all&hideSource=slack");
+    expect(hidden.total).toBe(5);
+    expect(hidden.sessions.map((row) => row.root.id)).not.toContain(mcpSlack.id);
+    const hiddenTree = await treeOf("show=all&hideSource=slack");
+    expect(hiddenTree.inbox.total).toBe(5);
+    expect(hiddenTree.sources).toEqual(facets);
+    expect(await ids({ source: ["mcp"] })).toEqual([mcp.id, mcpSlack.id].sort());
+    expect(await ids({ showSource: ["slack"], hideSource: ["slack"] })).toEqual([]);
+    expect((await treeOf("show=all&showSource=slack&hideSource=slack")).inbox.total).toBe(0);
+  });
+
   test("hideSource leaves a source out of sections and lists, and sources still count it", async () => {
     const slackA = await task("shared/", { source: "slack" });
     const slackB = await task("shared/a/", { source: "slack" });

package/src/tests/slack-inbound-files.test.ts

@@ -25,6 +25,7 @@ import {
   createAgent,
   createTaskExtended,
   getDbClient,
+  getKv,
   getLogsByTaskId,
   getSlackTasksInThread,
   getSteeringMessagesForTask,
@@ -34,7 +35,9 @@ import {
   promoteAbandonedDraftTasks,
   startTask,
 } from "../be/db";
+import { installExtension } from "../be/extensions/db";
 import { MAX_TASK_ATTACHMENT_BYTES } from "../be/task-attachment-store";
+import { disableExtension, enableExtension } from "../extensions/lifecycle";
 import { getFileStorageProvider, resetFileStorageProviderForTests } from "../fs/registry";
 import * as slackAppModule from "../slack/app";
 import { createAssistant } from "../slack/assistant";
@@ -49,6 +52,7 @@ import {
   setDraftLeaseRefreshMsForTests,
 } from "../slack/inbound-files";
 import { getBufferMessageCount, instantFlush } from "../slack/thread-buffer";
+import { loadBundleFixture } from "./fixtures/extensions/load";
 
 const TEST_DB_PATH = "./test-slack-inbound-files.sqlite";
 const BOT_TOKEN = "example-slack-inbound-files-token";
@@ -651,7 +655,7 @@ describe("Slack ingress with files", () => {
       "SELECT id FROM agent_tasks WHERE slackTriggerMessageTs = ?",
       [ts],
     );
-    return { client, task: row ? await getTaskById(row.id) : null };
+    return { client, task: row ? await getTaskById(row.id) : null, ts };
   }
 
   test("an image with no text creates a task that carries the image (case 1)", async () => {
@@ -953,31 +957,107 @@ describe("Slack ingress with files", () => {
     });
   });
 
-  test("a channel message that mentions the bot with a file attaches it", async () => {
+  for (const [route, withFiles] of [
+    ["lead", false],
+    ["lead", true],
+    ["no-lead", false],
+    ["no-lead", true],
+    ["follow-up", false],
+    ["follow-up", true],
+  ] as const) {
+    test(`Assistant DM metadata reaches hooks for ${route} with files=${withFiles}`, async () => {
+      const agent =
+        route === "no-lead"
+          ? undefined
+          : await createAgent({
+              name: route === "follow-up" ? "worker" : "lead",
+              isLead: route === "lead",
+              status: route === "follow-up" ? "busy" : "idle",
+            });
+      const channelId = "D0ASSISTMETADATA";
+      const threadTs = "1800000000.000001";
+      const earlier =
+        route === "follow-up"
+          ? await createTaskExtended("earlier work", {
+              agentId: agent!.id,
+              source: "slack",
+              slackChannelId: channelId,
+              slackThreadTs: threadTs,
+            })
+          : undefined;
+      if (earlier) await startTask(earlier.id);
+      const installed = await installExtension(await loadBundleFixture("record-task-create"));
+      const recorder = await enableExtension(installed.extension.id);
+      const text = "<@U_SWARM_BOT> inspect this\n  keep the spacing";
+      try {
+        const { task, ts } = await sendAssistantDm({
+          channel: channelId,
+          thread_ts: threadTs,
+          text,
+          files: withFiles ? [slackFile()] : [],
+        });
+
+        expect(task).not.toBeNull();
+        expect(task!.agentId ?? undefined).toBe(agent?.id);
+        if (earlier) expect(task!.parentTaskId).toBe(earlier.id);
+        expect(await readStoredBytes(task!.id)).toEqual(withFiles ? [PNG_BYTES] : []);
+        const event = (await getKv(`task:agent:${recorder.agentId}`, "ext:record-task-create:last"))
+          ?.value;
+        expect(event).toMatchObject({
+          origin: "slack",
+          slack: {
+            trigger: "mention",
+            messages: [{ ts, userId: "U_HUMAN", text }],
+          },
+        });
+      } finally {
+        await disableExtension(recorder.id);
+      }
+    });
+  }
+
+  test.each([
+    false,
+    true,
+  ])("Slack event metadata accompanies a channel mention with files=%s", async (withFiles) => {
     await createAgent({ name: "lead", isLead: true, status: "idle" });
+    const installed = await installExtension(await loadBundleFixture("record-task-create"));
+    const recorder = await enableExtension(installed.extension.id);
     seq += 1;
     const ts = `1900000000.${String(seq).padStart(6, "0")}`;
+    try {
+      await channelMessage({
+        event: {
+          type: "message",
+          subtype: "file_share",
+          channel: "C0CHANNEL1",
+          ts,
+          user: "U_HUMAN",
+          text: "<@U_SWARM_BOT> what is this?",
+          files: withFiles ? [slackFile()] : [],
+        },
+        body: { event_id: `evt_inbound_files_${seq}` },
+        client: slackClient(),
+        say: mock(async () => ({ ts: "1900000000.999999" })),
+      });
 
-    await channelMessage({
-      event: {
-        type: "message",
-        subtype: "file_share",
-        channel: "C0CHANNEL1",
-        ts,
-        user: "U_HUMAN",
-        text: "<@U_SWARM_BOT> what is this?",
-        files: [slackFile()],
-      },
-      body: { event_id: `evt_inbound_files_${seq}` },
-      client: slackClient(),
-      say: mock(async () => ({ ts: "1900000000.999999" })),
-    });
-
-    const row = await getDbClient().get<{ id: string }>(
-      "SELECT id FROM agent_tasks WHERE slackTriggerMessageTs = ?",
-      [ts],
-    );
-    expect(row).not.toBeNull();
-    expect(await readStoredBytes(row!.id)).toEqual([PNG_BYTES]);
+      const row = await getDbClient().get<{ id: string }>(
+        "SELECT id FROM agent_tasks WHERE slackTriggerMessageTs = ?",
+        [ts],
+      );
+      expect(row).not.toBeNull();
+      expect(await readStoredBytes(row!.id)).toEqual(withFiles ? [PNG_BYTES] : []);
+      const event = (await getKv(`task:agent:${recorder.agentId}`, "ext:record-task-create:last"))
+        ?.value;
+      expect(event).toMatchObject({
+        origin: "slack",
+        slack: {
+          trigger: "mention",
+          messages: [{ ts, userId: "U_HUMAN", text: "<@U_SWARM_BOT> what is this?" }],
+        },
+      });
+    } finally {
+      await disableExtension(recorder.id);
+    }
   });
 });