@desplega.ai/agent-swarm 2.7.2 → 2.7.3

package/src/tests/session-summaries.test.ts

@@ -0,0 +1,384 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlinkSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { defaultAssetKey } from "../assets/key";
+import {
+  closeDb,
+  createSteeringMessage,
+  createUser,
+  getDbClient,
+  initDb,
+  updateTaskProgress,
+  upsertInboxState,
+} from "../be/db";
+import { findSessionSummaryDrift } from "../be/db/session-summaries";
+import { sessionSummaryQuery } from "../be/db/session-tree";
+import { deleteTask } from "../be/db/tasks/write";
+
+const dbPath = join(tmpdir(), `session-summaries-${process.pid}-${Date.now()}.sqlite`);
+const MIGRATION = join(import.meta.dir, "../be/migrations/253_session_summaries.sql");
+const BASE = Date.parse("2026-10-01T00:00:00.000Z");
+let users: string[] = [];
+
+// mulberry32, so a failure replays with the same operations.
+let seed = 0x2520_1028;
+function rand(): number {
+  seed = (seed + 0x6d2b79f5) | 0;
+  let t = seed;
+  t = Math.imul(t ^ (t >>> 15), t | 1);
+  t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+  return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+}
+const pick = <T>(items: readonly T[]): T => items[Math.floor(rand() * items.length)]!;
+// Random, not monotonic: writes move timestamps both ways.
+const at = () => new Date(BASE + Math.floor(rand() * 20 * 86_400_000)).toISOString();
+
+const client = () => getDbClient();
+const taskIds = async () =>
+  (await client().query<{ id: string }>("SELECT id FROM agent_tasks ORDER BY id")).map((r) => r.id);
+const rootIds = async () =>
+  (
+    await client().query<{ id: string }>(
+      "SELECT id FROM agent_tasks WHERE parentTaskId IS NULL ORDER BY id",
+    )
+  ).map((r) => r.id);
+
+async function insertTask(opts: { parentTaskId?: string | null; id?: string } = {}) {
+  const id = opts.id ?? crypto.randomUUID();
+  const createdAt = at();
+  const requester = rand() < 0.7 ? pick(users) : null;
+  await client().run(
+    `INSERT INTO agent_tasks (id, "key", task, status, source, parentTaskId, requestedByUserId,
+      requestedByUserIdInherited, createdAt, lastUpdatedAt) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    [
+      id,
+      defaultAssetKey("task", id),
+      `task ${id}`,
+      pick(["pending", "in_progress", "completed", "failed"]),
+      pick(["ui", "slack", "mcp", "system", "schedule", "workflow", "api"]),
+      opts.parentTaskId ?? null,
+      requester,
+      requester && rand() < 0.5 ? 1 : 0,
+      createdAt,
+      at(),
+    ],
+  );
+  return id;
+}
+
+const OPS: Record<string, () => Promise<unknown>> = {
+  async root() {
+    await insertTask();
+  },
+  async child() {
+    const ids = await taskIds();
+    if (ids.length) await insertTask({ parentTaskId: pick(ids) });
+  },
+  async danglingChild() {
+    await insertTask({ parentTaskId: crypto.randomUUID() });
+  },
+  async progress() {
+    const ids = await taskIds();
+    if (ids.length) await updateTaskProgress(pick(ids), "working");
+  },
+  async status() {
+    const ids = await taskIds();
+    if (!ids.length) return;
+    await client().run("UPDATE agent_tasks SET status = ?, lastUpdatedAt = ? WHERE id = ?", [
+      pick(["completed", "failed", "cancelled", "in_progress"]),
+      at(),
+      pick(ids),
+    ]);
+  },
+  async statusOnly() {
+    const ids = await taskIds();
+    if (!ids.length) return;
+    await client().run("UPDATE agent_tasks SET status = ? WHERE id = ?", [
+      pick(["completed", "failed"]),
+      pick(ids),
+    ]);
+  },
+  async moveRootKey() {
+    const roots = await rootIds();
+    if (!roots.length) return;
+    await client().run(`UPDATE agent_tasks SET "key" = ? WHERE id = ?`, [
+      defaultAssetKey("task", crypto.randomUUID()),
+      pick(roots),
+    ]);
+  },
+  async requester() {
+    const ids = await taskIds();
+    if (!ids.length) return;
+    await client().run(
+      "UPDATE agent_tasks SET requestedByUserId = ?, requestedByUserIdInherited = ?, source = ? WHERE id = ?",
+      [pick([null, ...users]), rand() < 0.5 ? 1 : 0, pick(["ui", "mcp", "slack"]), pick(ids)],
+    );
+  },
+  async steer() {
+    const ids = await taskIds();
+    if (!ids.length) return;
+    const user = rand() < 0.7;
+    const message = await createSteeringMessage({
+      taskId: pick(ids),
+      body: "steer",
+      mode: pick(["steer", "queue"] as const),
+      source: "ui",
+      createdByKind: user ? "user" : "agent",
+      createdByUserId: user ? pick(users) : undefined,
+    });
+    await client().run("UPDATE task_steering_messages SET created_at = ? WHERE id = ?", [
+      at(),
+      message.id,
+    ]);
+  },
+  async steerCancel() {
+    const row = await client().get<{ id: string }>(
+      "SELECT id FROM task_steering_messages WHERE status != 'cancelled' ORDER BY random() LIMIT 1",
+    );
+    if (row)
+      await client().run("UPDATE task_steering_messages SET status = 'cancelled' WHERE id = ?", [
+        row.id,
+      ]);
+  },
+  async steerDelivered() {
+    const row = await client().get<{ id: string }>(
+      "SELECT id FROM task_steering_messages WHERE status = 'pending' ORDER BY random() LIMIT 1",
+    );
+    if (row)
+      await client().run("UPDATE task_steering_messages SET status = 'delivered' WHERE id = ?", [
+        row.id,
+      ]);
+  },
+  async steerDelete() {
+    await client().run(
+      "DELETE FROM task_steering_messages WHERE id = (SELECT id FROM task_steering_messages ORDER BY random() LIMIT 1)",
+    );
+  },
+  async approval() {
+    const ids = await taskIds();
+    if (!ids.length) return;
+    await client().run(
+      `INSERT INTO approval_requests (id, title, questions, approvers, status, sourceTaskId, createdAt)
+       VALUES (?, 'ok?', '[]', '{}', 'pending', ?, ?)`,
+      [crypto.randomUUID(), pick(ids), at()],
+    );
+  },
+  async approvalResolve() {
+    await client().run(
+      `UPDATE approval_requests SET status = ? WHERE id = (
+        SELECT id FROM approval_requests WHERE status = 'pending' ORDER BY random() LIMIT 1)`,
+      [pick(["approved", "rejected", "timeout"])],
+    );
+  },
+  async approvalDelete() {
+    await client().run(
+      "DELETE FROM approval_requests WHERE id = (SELECT id FROM approval_requests ORDER BY random() LIMIT 1)",
+    );
+  },
+  async deleteTask() {
+    const ids = await taskIds();
+    if (ids.length > 10) await deleteTask(pick(ids));
+  },
+  async doneMark() {
+    const roots = await rootIds();
+    if (!roots.length) return;
+    await upsertInboxState({
+      userId: users[0]!,
+      itemType: "to_read",
+      itemId: pick(roots),
+      status: "done",
+    });
+    await client().run(
+      `UPDATE inbox_item_state SET lastUpdatedAt = ? WHERE userId = ? AND itemType = 'to_read' AND status = 'done'
+        AND itemId = (SELECT itemId FROM inbox_item_state WHERE userId = ? ORDER BY lastUpdatedAt DESC LIMIT 1)`,
+      [at(), users[0]!, users[0]!],
+    );
+  },
+};
+
+// Weighted toward the common writes: inserts and progress.
+const SCHEDULE = [
+  ...Array(6).fill("root"),
+  ...Array(10).fill("child"),
+  ...Array(6).fill("progress"),
+  ...Array(3).fill("status"),
+  ...Object.keys(OPS),
+] as string[];
+
+/** Each Done-marked root's read state from the chain walk equals the stored rule. */
+async function expectReopensDoneMatches() {
+  const viewer = users[0]!;
+  const legacy = sessionSummaryQuery({ viewer: { userId: viewer, scope: "all" } });
+  const rows = await client().query<{ root_id: string; readState: string; stored: string }>(
+    `SELECT a.root_id, a.readState,
+      CASE WHEN s.lastHumanAt > d.lastUpdatedAt THEN 'unread' ELSE 'done' END AS stored
+    FROM (${legacy.sql}) a
+    JOIN inbox_item_state d ON d.userId = ? AND d.itemType = 'to_read' AND d.itemId = a.root_id AND d.status = 'done'
+    JOIN session_summaries s ON s.rootId = a.root_id`,
+    [...legacy.params, viewer],
+  );
+  for (const row of rows)
+    expect({ root: row.root_id, state: row.stored }).toEqual({
+      root: row.root_id,
+      state: row.readState,
+    });
+  return rows.length;
+}
+
+beforeAll(async () => {
+  initDb(dbPath);
+  users = [];
+  for (let i = 0; i < 3; i++) users.push((await createUser({ name: `summary user ${i}` })).id);
+});
+
+afterAll(() => {
+  closeDb();
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      unlinkSync(dbPath + suffix);
+    } catch {}
+  }
+});
+
+describe("session_summaries", () => {
+  test("500 random writes keep the summaries equal to the chain walk", async () => {
+    const counts: Record<string, number> = {};
+    // The most chains, human events and pending approvals any checkpoint compared.
+    const seen = { chains: 0, humans: 0, pending: 0 };
+    let doneChecks = 0;
+    for (let i = 1; i <= 500; i++) {
+      const op = pick(SCHEDULE);
+      counts[op] = (counts[op] ?? 0) + 1;
+      await OPS[op]!();
+      if (i % 50 === 0) {
+        expect({ after: i, drift: await findSessionSummaryDrift() }).toEqual({
+          after: i,
+          drift: [],
+        });
+        doneChecks += await expectReopensDoneMatches();
+        const shape = (await client().get<typeof seen>(
+          `SELECT SUM(chainCount > 2) AS chains, SUM(lastHumanAt IS NOT NULL) AS humans,
+            SUM(pendingApprovalCount > 0) AS pending FROM session_summaries`,
+        ))!;
+        for (const key of Object.keys(seen) as (keyof typeof seen)[])
+          seen[key] = Math.max(seen[key], shape[key] ?? 0);
+      }
+    }
+    // Every operation ran, and the checks compared real chains and Done marks.
+    for (const op of Object.keys(OPS)) expect(counts[op] ?? 0).toBeGreaterThan(0);
+    expect(seen.chains).toBeGreaterThan(5);
+    expect(seen.humans).toBeGreaterThan(5);
+    expect(seen.pending).toBeGreaterThan(0);
+    expect(doneChecks).toBeGreaterThan(0);
+  }, 60_000);
+
+  test("the drift check reports a corrupted summary and member (positive control)", async () => {
+    const root = await insertTask();
+    const child = await insertTask({ parentTaskId: root });
+    expect(await findSessionSummaryDrift()).toEqual([]);
+
+    await client().run(
+      "UPDATE session_summaries SET chainCount = chainCount + 5, lastHumanAt = 'x' WHERE rootId = ?",
+      [root],
+    );
+    await client().run("DELETE FROM session_members WHERE taskId = ?", [child]);
+    const drift = await findSessionSummaryDrift();
+    expect(drift.map((d) => `${d.rootId}:${d.field}`).sort()).toEqual(
+      [`${root}:chainCount`, `${root}:lastHumanAt`, `${root}:member`].sort(),
+    );
+
+    await client().run("INSERT INTO session_members (taskId, rootId) VALUES (?, ?)", [child, root]);
+    await client().run("INSERT INTO session_summary_recompute (rootId) VALUES (?)", [root]);
+    expect(await findSessionSummaryDrift()).toEqual([]);
+  });
+
+  test("deleting a mid-chain task drops its descendants from the session", async () => {
+    const root = await insertTask();
+    const mid = await insertTask({ parentTaskId: root });
+    const leaf = await insertTask({ parentTaskId: mid });
+    await insertTask({ parentTaskId: leaf });
+    const sibling = await insertTask({ parentTaskId: root });
+
+    expect(await deleteTask(mid)).toBe(true);
+    const members = await client().query<{ taskId: string }>(
+      "SELECT taskId FROM session_members WHERE rootId = ? ORDER BY taskId",
+      [root],
+    );
+    expect(members.map((m) => m.taskId)).toEqual([root, sibling].sort());
+    const summary = await client().get<{ chainCount: number }>(
+      "SELECT chainCount FROM session_summaries WHERE rootId = ?",
+      [root],
+    );
+    expect(summary!.chainCount).toBe(2);
+    expect(await findSessionSummaryDrift()).toEqual([]);
+
+    expect(await deleteTask(root)).toBe(true);
+    const left = await client().get<{ members: number; summaries: number }>(
+      `SELECT (SELECT COUNT(*) FROM session_members WHERE rootId = ?) AS members,
+        (SELECT COUNT(*) FROM session_summaries WHERE rootId = ?) AS summaries`,
+      [root, root],
+    );
+    expect(left).toEqual({ members: 0, summaries: 0 });
+  });
+
+  test("deleting a task whose steering cascades leaves no half-recomputed summary", async () => {
+    // The steering FK cascade fires its trigger while the task row is already gone.
+    const steer = (taskId: string) =>
+      createSteeringMessage({
+        taskId,
+        body: "steer",
+        mode: "steer",
+        source: "ui",
+        createdByKind: "user",
+        createdByUserId: users[0]!,
+      });
+    const single = await insertTask();
+    await steer(single);
+    expect(await deleteTask(single)).toBe(true);
+
+    const root = await insertTask();
+    const child = await insertTask({ parentTaskId: root });
+    await steer(root);
+    await steer(child);
+    await client().run("DELETE FROM agent_tasks WHERE id IN (?, ?)", [child, root]);
+    expect(await findSessionSummaryDrift()).toEqual([]);
+  });
+
+  test("changing parentTaskId aborts", async () => {
+    const root = await insertTask();
+    const other = await insertTask();
+    const child = await insertTask({ parentTaskId: root });
+    await expect(
+      client().run("UPDATE agent_tasks SET parentTaskId = ? WHERE id = ?", [other, child]),
+    ).rejects.toThrow(/parentTaskId is immutable/);
+    // Rewriting the same value is not a change.
+    await client().run("UPDATE agent_tasks SET parentTaskId = ? WHERE id = ?", [root, child]);
+  });
+
+  test("the migration backfill rebuilds the same summaries", async () => {
+    const before = await client().query<Record<string, unknown>>(
+      "SELECT * FROM session_summaries ORDER BY rootId",
+    );
+    expect(before.length).toBeGreaterThan(20);
+    const sql = await Bun.file(MIGRATION).text();
+    const backfill = sql.slice(sql.indexOf("-- Backfill:"));
+    expect(backfill).toContain("INSERT INTO session_members");
+    await client().transaction(async (tx) => {
+      await tx.run("DELETE FROM session_summaries");
+      await tx.run("DELETE FROM session_members");
+      for (const statement of backfill
+        .split(/;\s*\n/)
+        .filter((s) => s.replace(/--.*$/gm, "").trim()))
+        await tx.run(statement);
+    });
+    expect(await findSessionSummaryDrift()).toEqual([]);
+    const after = await client().query<Record<string, unknown>>(
+      "SELECT * FROM session_summaries ORDER BY rootId",
+    );
+    // latestStatus may differ only where two chain tasks tie on the newest timestamp.
+    const strip = (rows: Record<string, unknown>[]) =>
+      rows.map(({ latestStatus: _, ...row }) => row);
+    expect(strip(after)).toEqual(strip(before));
+  });
+});

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

@@ -917,6 +917,8 @@ describe("Mine view hides machine-started roots", () => {
     const slack = await task("shared/", { source: "slack" });
     const ui = await task("shared/", { source: "ui" });
     const whatsapp = await task("shared/", { source: "system", taskType: "kapso-inbound" });
+    // Comments the viewer sent from the Files page.
+    const comb = await task("shared/", { source: "comb", taskType: "comb-review" });
     // A workflow root someone else shared with the viewer stays too.
     const sharedRun = await task("shared/", { source: "workflow", requestedByUserId: other.id });
     await share(sharedRun);
@@ -935,13 +937,15 @@ describe("Mine view hides machine-started roots", () => {
       return ((await res.json()) as Awaited<ReturnType<typeof getSessionTree>>).noGroup.total;
     };
 
-    const mine = [slack.id, ui.id, whatsapp.id, sharedRun.id].sort();
+    const mine = [slack.id, ui.id, whatsapp.id, comb.id, sharedRun.id].sort();
     const all = [...mine, demo.id, scheduled.id, heartbeat.id].sort();
     expect(await list("")).toEqual(mine);
     expect(await list("show=mine")).toEqual(mine);
     expect(await list("show=all")).toEqual(all);
     expect(await tree("")).toBe(mine.length);
     expect(await tree("show=all")).toBe(all.length);
+    // The sessions v2 default source filter (`comb,ui`) keeps the Files session.
+    expect(await list("showSource=comb,ui")).toEqual([comb.id, ui.id].sort());
 
     // No picked user: the bypass actor still sees every root, ownerless included.
     const bypass = await fetch(`${baseUrl}/api/sessions?scope=tree&limit=50`);

package/src/tests/slack-app-icon.test.ts

@@ -0,0 +1,90 @@
+import { afterAll, afterEach, describe, expect, mock, setSystemTime, test } from "bun:test";
+
+// A local Slack Web API. Each test uses its own bot token, so the per-token
+// cache never leaks between tests.
+type Behaviour = { hangMs?: number; botsInfoFails?: number };
+const behaviour = new Map<string, Behaviour>();
+const hits: string[] = [];
+const server = Bun.serve({
+  port: 0,
+  async fetch(req) {
+    const method = new URL(req.url).pathname.split("/").pop() ?? "";
+    const token = req.headers.get("authorization")?.replace("Bearer ", "") ?? "";
+    hits.push(`${token} ${method}`);
+    const b = behaviour.get(token) ?? {};
+    if (method === "auth.test") {
+      if (b.hangMs) await Bun.sleep(b.hangMs);
+      return Response.json({ ok: true, bot_id: "B123" });
+    }
+    if (b.botsInfoFails) {
+      b.botsInfoFails--;
+      return Response.json({ ok: false, error: "missing_scope" });
+    }
+    return Response.json({ ok: true, bot: { icons: { image_72: `https://a/${token}.png` } } });
+  },
+});
+const slackApiUrl = `http://localhost:${server.port}/api/`;
+let token: string | null = null;
+mock.module("../slack/app", () => ({
+  getSlackApp: () => (token ? { client: { token, slackApiUrl } } : null),
+}));
+const { getSlackAppIconUrl } = await import("../slack/app-icon");
+
+const calls = (t: string, method: string) => hits.filter((h) => h === `${t} ${method}`).length;
+
+afterEach(() => setSystemTime());
+afterAll(() => server.stop(true));
+
+describe("getSlackAppIconUrl", () => {
+  test("returns the bot's image_72, cached for an hour, then asks again", async () => {
+    token = "xoxb-cache";
+    expect(await getSlackAppIconUrl()).toBe("https://a/xoxb-cache.png");
+    expect(await getSlackAppIconUrl()).toBe("https://a/xoxb-cache.png");
+    expect(calls(token, "bots.info")).toBe(1);
+    setSystemTime(new Date(Date.now() + 60 * 60 * 1000));
+    expect(await getSlackAppIconUrl()).toBe("https://a/xoxb-cache.png");
+    expect(calls(token, "bots.info")).toBe(2);
+  });
+
+  test("Slack off returns null even with an avatar cached", async () => {
+    token = "xoxb-off";
+    expect(await getSlackAppIconUrl()).toBe("https://a/xoxb-off.png");
+    token = null;
+    expect(await getSlackAppIconUrl()).toBeNull();
+  });
+
+  test("concurrent calls share one lookup", async () => {
+    token = "xoxb-concurrent";
+    const results = await Promise.all([1, 2, 3].map(() => getSlackAppIconUrl()));
+    expect(results).toEqual(Array(3).fill("https://a/xoxb-concurrent.png"));
+    expect(calls(token, "auth.test")).toBe(1);
+  });
+
+  test("a failed lookup is not cached", async () => {
+    token = "xoxb-flaky";
+    behaviour.set(token, { botsInfoFails: 1 });
+    expect(await getSlackAppIconUrl()).toBeNull();
+    expect(await getSlackAppIconUrl()).toBe("https://a/xoxb-flaky.png");
+    expect(calls(token, "bots.info")).toBe(2);
+  });
+
+  test(
+    "a hanging auth.test times out without a retry or a bots.info, then a new lookup works",
+    async () => {
+      token = "xoxb-hang";
+      behaviour.set(token, { hangMs: 4_000 });
+      const started = Date.now();
+      expect(await getSlackAppIconUrl()).toBeNull();
+      expect(Date.now() - started).toBeLessThan(3_500);
+      // Let the late auth.test reply arrive: nothing may follow it.
+      await Bun.sleep(4_000 - (Date.now() - started) + 300);
+      expect(calls(token, "auth.test")).toBe(1);
+      expect(calls(token, "bots.info")).toBe(0);
+
+      behaviour.set(token, {});
+      expect(await getSlackAppIconUrl()).toBe("https://a/xoxb-hang.png");
+      expect(calls(token, "auth.test")).toBe(2);
+    },
+    { timeout: 15_000 },
+  );
+});

package/src/tests/slack-external-channel-egress.test.ts

@@ -89,7 +89,7 @@ const writes: Array<[string, (c: InstanceType<typeof webApi.WebClient>) => Promi
         thread_ts: "1.0",
         text: "progress",
         username: "Agent",
-        icon_emoji: ":robot_face:",
+        icon: { icon_emoji: ":robot_face:" },
       }),
   ],
   [

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

@@ -23,6 +23,7 @@ import {
   getSlackInboundReceiptById,
   getSlackInboundReceiptByKey,
   purgeSlackInboundReceipts,
+  recordSlackInboundInline,
   SLACK_INBOUND_LIMITS,
 } from "../be/db-queries/slack-inbound";
 import { registerActionHandlers } from "../slack/actions";
@@ -619,6 +620,39 @@ describe("retention", () => {
   });
 });
 
+describe("inline tombstones", () => {
+  const input = {
+    dedupKey: "event:A_TEST:Ev_INLINE",
+    transport: "socket",
+    kind: "event",
+    payloadType: "event_callback",
+    eventId: "Ev_INLINE",
+  } as const;
+
+  test("a recorded key is terminal, holds no payload, is never claimable and expires", async () => {
+    await getDbClient().run("DELETE FROM slack_inbound_receipts");
+    const at = new Date("2026-09-01T00:00:00.000Z");
+    expect(await recordSlackInboundInline(input, at)).toBe("recorded");
+    expect(await recordSlackInboundInline(input, at)).toBe("duplicate");
+
+    const receipt = await getSlackInboundReceiptByKey(input.dedupKey);
+    expect(receipt).toMatchObject({
+      state: "processed",
+      outcomeCode: "ran_inline",
+      payloadCiphertext: null,
+      payloadBytes: 0,
+      duplicateCount: 1,
+    });
+    expect(await claimSlackInboundReceipt(new Date("2026-09-01T00:01:00.000Z"))).toBeNull();
+
+    // Retention drops it with the other completed keys.
+    await purgeSlackInboundReceipts(new Date("2026-09-02T00:00:00.000Z"));
+    expect(await getSlackInboundReceiptByKey(input.dedupKey)).not.toBeNull();
+    await purgeSlackInboundReceipts(new Date(at.getTime() + 49 * 60 * 60 * 1000));
+    expect(await getSlackInboundReceiptByKey(input.dedupKey)).toBeNull();
+  });
+});
+
 describe("Socket Mode ingress is unchanged", () => {
   test("SLACK_MODE defaults to socket", () => {
     expect(getSlackConfiguration({}).mode).toBe("socket");

package/src/tests/slack-inline-output.test.ts

@@ -2,10 +2,11 @@ import { describe, expect, mock, test } from "bun:test";
 import { MAX_SECTION_LENGTH } from "../slack/blocks";
 import {
   formatInlineCompletionOutputChunks,
+  getAgentSlackIcon,
   sendWithPersona,
   shouldPostInlineCompletionOutput,
 } from "../slack/responses";
-import type { AgentTask } from "../types";
+import type { Agent, AgentTask } from "../types";
 
 const TASK_ID = "abcdef12-3456-7890-abcd-ef1234567890";
 
@@ -30,13 +31,39 @@ describe("Slack inline completion output", () => {
       thread_ts: "1",
       text: "done",
       username: "Literal Lead",
-      icon_emoji: ":crown:",
+      icon: { icon_emoji: ":crown:" },
     });
     expect(postMessage).toHaveBeenCalledWith(
       expect.objectContaining({ username: "Literal Lead", icon_emoji: ":crown:" }),
     );
   });
 
+  test("posts each agent's Slack icon choice and nothing else", async () => {
+    const cases: [Partial<Agent>, Record<string, string>][] = [
+      [{ slackIcon: { type: "emoji", emoji: ":owl:" } }, { icon_emoji: ":owl:" }],
+      [{ slackIcon: { type: "url", url: "https://a/o.png" } }, { icon_url: "https://a/o.png" }],
+      [{ slackIcon: { type: "app" } }, {}],
+      [{ isLead: true, slackIcon: null }, { icon_emoji: ":crown:" }],
+      [{ slackIcon: null }, { icon_emoji: ":star:" }],
+    ];
+    for (const [overrides, icon] of cases) {
+      const postMessage = mock(async (_payload: Record<string, unknown>) => ({ ts: "1" }));
+      const agent = { id: "a1", name: "Owl Worker", isLead: false, ...overrides } as Agent;
+      await sendWithPersona({ chat: { postMessage } } as never, {
+        channel: "C123",
+        thread_ts: "1",
+        text: "done",
+        username: "Owl Worker",
+        icon: getAgentSlackIcon(agent),
+      });
+      const payload = postMessage.mock.calls[0]?.[0] ?? {};
+      const sent = Object.fromEntries(
+        Object.entries(payload).filter(([key]) => key.startsWith("icon_")),
+      );
+      expect(sent).toEqual(icon);
+    }
+  });
+
   test("posts only truncated completed Slack output that has not already been replied", () => {
     const longOutput = `Here is the answer. ${"Detailed finding ".repeat(20)}`;
     expect(shouldPostInlineCompletionOutput(task({ output: longOutput }))).toBe(true);

package/src/tests/slack-render-v2-query-plans.test.ts

@@ -96,8 +96,9 @@ describe("slack render-v2 watcher queries", () => {
   test("deferral resolution drives from the chain, not from every task", async () => {
     const sql = await capturedSql(() => getResolvableDeferralOutcomes());
     const detail = plan(sql, [50]);
-    expect(detail).toContain(
-      "SEARCH wake USING INDEX idx_agent_tasks_parentTaskId (parentTaskId=?)",
+    // Either parentTaskId-led index is a seek on the chain's children.
+    expect(detail).toMatch(
+      /SEARCH wake USING INDEX idx_agent_tasks_parentTaskId(_source)? \(parentTaskId=\?\)/,
     );
     expect(detail).not.toContain("idx_agent_tasks_taskType");
     expect(detail).not.toContain("idx_agent_tasks_status_last_updated");

package/src/tests/slack-render-v2.test.ts

@@ -40,6 +40,7 @@ import {
   noteSlackOutcomeDeliveryFailure,
   startTask,
   supersedeTask,
+  updateAgentProfile,
   upsertSwarmConfig,
 } from "../be/db";
 import { upsertTaskCitations } from "../be/task-citations";
@@ -1798,6 +1799,40 @@ describe("Slack renderer v2", () => {
     );
   });
 
+  test("a URL Slack icon reaches the stream and its postMessage fallback", async () => {
+    const lead = await createAgent({ name: "Owl Lead", isLead: true, status: "idle" });
+    const iconUrl = "https://example.com/owl.png";
+    await updateAgentProfile(lead.id, { slackIcon: { type: "url", url: iconUrl } });
+    const { channelId, threadTs } = uniqueSlackAddress("C_ICON_URL");
+    const ask = await createTaskExtended("Owl outcome", {
+      agentId: lead.id,
+      source: "slack",
+      slackChannelId: channelId,
+      slackThreadTs: threadTs,
+      contextKey: slackContextKey({ channelId, threadTs }),
+    });
+    await startTask(ask.id);
+    await completeTask(ask.id, "Hoot.");
+    await backdateLastUpdated([ask.id], 20);
+    await ensureSlackThreadTree([ask.id]);
+    calls.length = 0;
+    startStreamFailuresRemaining = 1;
+    try {
+      await processSlackRenderV2();
+    } finally {
+      startStreamFailuresRemaining = 0;
+    }
+
+    const stream = calls.find((call) => call.method === "chat.startStream");
+    const fallback = calls.find(
+      (call) => call.method === "chat.postMessage" && String(call.payload.text).startsWith("✅"),
+    );
+    for (const payload of [stream?.payload, fallback?.payload]) {
+      expect(payload?.icon_url).toBe(iconUrl);
+      expect(payload).not.toHaveProperty("icon_emoji");
+    }
+  });
+
   test("preserves complete native Markdown beyond the Block Kit text ceiling", async () => {
     const lead = await createAgent({ name: "Markdown Lead", isLead: true, status: "idle" });
     const { channelId, threadTs } = uniqueSlackAddress("C_OUTCOME_MARKDOWN");