@desplega.ai/agent-swarm 1.149.0 → 1.150.0

package/src/tests/session-costs-model-key-normalize.test.ts

@@ -19,8 +19,8 @@ import { handleSessionData } from "../http/session-data";
 import { getPathSegments, parseQueryParams } from "../http/utils";
 import { listenOnFreePort } from "./test-net";
 
-const TEST_DB_PATH = "./test-model-key-normalize.sqlite";
-const API_KEY = "test-model-key-normalize";
+const TEST_DB_PATH = "./example-test-model-key-normalize.sqlite";
+const API_KEY = "example-test-model-key-normalize";
 
 async function removeDbFiles(path: string): Promise<void> {
   for (const suffix of ["", "-wal", "-shm"]) {

package/src/tests/session-costs-recompute-all-providers.test.ts

@@ -17,7 +17,7 @@ import { getPathSegments, parseQueryParams } from "../http/utils";
 import { listenOnFreePort } from "./test-net";
 
 const TEST_DB_PATH = "./test-recompute-all-providers.sqlite";
-const API_KEY = "test-recompute-all";
+const API_KEY = "example-test-recompute-all";
 
 async function removeDbFiles(path: string): Promise<void> {
   for (const suffix of ["", "-wal", "-shm"]) {

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

@@ -23,7 +23,7 @@ import { handleSessions } from "../http/sessions";
 import { getPathSegments, parseQueryParams } from "../http/utils";
 import { listenOnFreePort } from "./test-net";
 
-const API_KEY = "test-session-token-key";
+const API_KEY = "example-test-session-token-key";
 
 function createTestServer(apiKey: string): Server {
   return createHttpServer(async (req: IncomingMessage, res: ServerResponse) => {

package/src/tests/shutdown-error-scrubbing.test.ts

@@ -18,7 +18,7 @@ import {
  * rather than executed.
  */
 
-const SECRET = "xoxb-9911-shutdown-token-value";
+const SECRET = "example-shutdown-token-value";
 
 const shutdownSourcePath = `${import.meta.dir}/../http/index.ts`;
 const shutdownSource = await Bun.file(shutdownSourcePath).text();

package/src/tests/slack-file-tools-attachments.test.ts

@@ -21,7 +21,7 @@ import type { SlackFile } from "../slack/files";
 import { createSlackTaskWithFiles, fetchSlackFiles } from "../slack/inbound-files";
 
 const TEST_DB_PATH = "./test-slack-file-tools-attachments.sqlite";
-const BOT_TOKEN = "xoxb-file-tools-test";
+const BOT_TOKEN = "example-slack-file-tools-token";
 const AGENT_ID = "aaaaaaaa-0000-4000-8000-00000000f001";
 const OTHER_ID = "aaaaaaaa-0000-4000-8000-00000000f002";
 const PNG = new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 9, 9]);

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

@@ -6,7 +6,17 @@
  * task unclaimable until its attachments exist, and both Slack ingress
  * handlers end to end against a real DB and the local file provider.
  */
-import { afterAll, beforeAll, beforeEach, describe, expect, mock, spyOn, test } from "bun:test";
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from "bun:test";
 import { mkdtemp, rm, unlink } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -16,13 +26,17 @@ import {
   createTaskExtended,
   getDbClient,
   getLogsByTaskId,
+  getSlackTasksInThread,
+  getSteeringMessagesForTask,
   getTaskAttachments,
   getTaskById,
   initDb,
   promoteAbandonedDraftTasks,
+  startTask,
 } from "../be/db";
 import { MAX_TASK_ATTACHMENT_BYTES } from "../be/task-attachment-store";
 import { getFileStorageProvider, resetFileStorageProviderForTests } from "../fs/registry";
+import * as slackAppModule from "../slack/app";
 import { createAssistant } from "../slack/assistant";
 import * as slackEnrichModule from "../slack/enrich";
 import type { SlackFile } from "../slack/files";
@@ -34,10 +48,10 @@ import {
   notifySlackFileFailures,
   setDraftLeaseRefreshMsForTests,
 } from "../slack/inbound-files";
-import { instantFlush } from "../slack/thread-buffer";
+import { getBufferMessageCount, instantFlush } from "../slack/thread-buffer";
 
 const TEST_DB_PATH = "./test-slack-inbound-files.sqlite";
-const BOT_TOKEN = "xoxb-inbound-files-test";
+const BOT_TOKEN = "example-slack-inbound-files-token";
 const PNG_BYTES = new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 1, 2, 3]);
 
 let slackFiles: ReturnType<typeof Bun.serve>;
@@ -51,6 +65,7 @@ const previousEnv = {
   SLACK_RENDER_V2: process.env.SLACK_RENDER_V2,
   STEERING_ENABLED: process.env.STEERING_ENABLED,
   SLACK_THREAD_STEERING: process.env.SLACK_THREAD_STEERING,
+  SLACK_THREAD_FOLLOWUP_REQUIRE_MENTION: process.env.SLACK_THREAD_FOLLOWUP_REQUIRE_MENTION,
 };
 
 const HTML_FILE = new TextEncoder().encode("<html><body>quarterly report</body></html>");
@@ -708,113 +723,234 @@ describe("Slack ingress with files", () => {
     expect(await getTaskAttachments(followUp!.id)).toHaveLength(1);
   });
 
-  test("a follow-up queued by ADDITIVE_SLACK says its file was not attached", async () => {
-    await createAgent({ name: "lead", isLead: true, status: "busy" });
-    const { task: first } = await sendAssistantDm({ subtype: undefined, text: "start" });
-    await getDbClient().run("UPDATE agent_tasks SET status = 'in_progress' WHERE id = ?", [
-      first!.id,
-    ]);
-    process.env.ADDITIVE_SLACK = "true";
-    // instantFlush steers into the running session when steering is on; this
-    // asserts the task-creating path, so keep steering off whatever the env says.
-    process.env.STEERING_ENABLED = "false";
-    delete process.env.SLACK_THREAD_STEERING;
-    const client = slackClient();
+  describe("buffered follow-ups with files", () => {
+    let earlier: Awaited<ReturnType<typeof createTaskExtended>>;
+    let client: ReturnType<typeof slackClient>;
+    const getApp = spyOn(slackAppModule, "getSlackApp");
+    const channelId = "C0BUFFERFILES";
+    const threadTs = "1950000000.000001";
+    const key = `${channelId}:${threadTs}`;
+
+    beforeEach(async () => {
+      const lead = await createAgent({
+        name: "lead",
+        isLead: true,
+        status: "busy",
+        harnessProvider: "pi",
+      });
+      earlier = await createTaskExtended("earlier work", {
+        agentId: lead.id,
+        source: "slack",
+        slackChannelId: channelId,
+        slackThreadTs: threadTs,
+      });
+      await startTask(earlier.id);
+      process.env.ADDITIVE_SLACK = "true";
+      process.env.STEERING_ENABLED = "true";
+      process.env.SLACK_THREAD_STEERING = "lead";
+      process.env.SLACK_THREAD_FOLLOWUP_REQUIRE_MENTION = "false";
+      client = slackClient();
+      getApp.mockReturnValue({ client } as never);
+    });
 
-    try {
+    afterEach(async () => {
+      await instantFlush(key);
+      process.env.ADDITIVE_SLACK = "false";
+      restoreSteeringEnv();
+      const requireMention = previousEnv.SLACK_THREAD_FOLLOWUP_REQUIRE_MENTION;
+      if (requireMention === undefined) delete process.env.SLACK_THREAD_FOLLOWUP_REQUIRE_MENTION;
+      else process.env.SLACK_THREAD_FOLLOWUP_REQUIRE_MENTION = requireMention;
+      getApp.mockReturnValue(null);
+    });
+
+    afterAll(() => getApp.mockRestore());
+
+    async function sendBuffered(text: string, files: SlackFile[] = []) {
       seq += 1;
-      await assistantMessage({
-        message: {
-          channel: first!.slackChannelId,
-          thread_ts: first!.slackThreadTs,
-          ts: `1800000000.${String(seq).padStart(6, "0")}`,
+      const ts = `1950000001.${String(seq).padStart(6, "0")}`;
+      await channelMessage({
+        event: {
+          type: "message",
+          subtype: files.length ? "file_share" : undefined,
+          channel: channelId,
+          thread_ts: threadTs,
+          ts,
           user: "U_HUMAN",
-          subtype: "file_share",
-          text: "",
-          files: [slackFile()],
+          text,
+          files,
         },
         body: { event_id: `evt_inbound_files_${seq}` },
         client,
         say: mock(async () => ({})),
-        setStatus: mock(async () => {}),
-        setTitle: mock(async () => {}),
-        getThreadContext: mock(async () => ({})),
       });
-    } finally {
-      process.env.ADDITIVE_SLACK = "false";
+      return ts;
     }
 
-    try {
-      await assertQueuedFollowUp();
-    } finally {
-      restoreSteeringEnv();
-    }
-
-    async function assertQueuedFollowUp() {
-      expect(fileRequests).toEqual([]);
-      expect(client.chat.postMessage).toHaveBeenCalledTimes(1);
-      const [args] = client.chat.postMessage.mock.calls[0] as unknown as [{ text: string }];
-      expect(args.text).toContain("`screenshot.png` (follow-ups queued by ADDITIVE_SLACK");
-
-      // Drain the debounce buffer now, while the DB is still open.
-      await instantFlush(`${first!.slackChannelId}:${first!.slackThreadTs}`);
-      const queued = await getDbClient().get<{ task: string }>(
-        "SELECT task FROM agent_tasks WHERE slackThreadTs = ? AND id != ? ORDER BY createdAt DESC",
-        [first!.slackThreadTs, first!.id],
+    async function followUp() {
+      const tasks = (await getSlackTasksInThread(channelId, threadTs)).filter(
+        (task) => task.id !== earlier.id,
       );
-      expect(queued?.task).toContain("(not attached: follow-ups queued by ADDITIVE_SLACK");
+      expect(tasks).toHaveLength(1);
+      return tasks[0]!;
     }
-  });
 
-  test("a !now follow-up with a file says the file was not attached", async () => {
-    const lead = await createAgent({ name: "lead", isLead: true, status: "busy" });
-    const threadTs = "1950000000.000001";
-    const earlier = await createTaskExtended("earlier work", {
-      agentId: lead.id,
-      source: "slack",
-      slackChannelId: "C0NOWTEST1",
-      slackThreadTs: threadTs,
-    });
-    await getDbClient().run("UPDATE agent_tasks SET status = 'in_progress' WHERE id = ?", [
-      earlier.id,
-    ]);
-    process.env.ADDITIVE_SLACK = "true";
-    process.env.STEERING_ENABLED = "false";
-    delete process.env.SLACK_THREAD_STEERING;
-    const client = slackClient();
-    seq += 1;
+    function failureNotices() {
+      return (client.chat.postMessage.mock.calls as unknown as [{ text: string }][])
+        .map(([args]) => args.text)
+        .filter((text) => text.includes("Couldn't attach"));
+    }
 
-    try {
-      await channelMessage({
-        event: {
-          type: "message",
-          subtype: "file_share",
-          channel: "C0NOWTEST1",
+    test("assistant follow-ups retain files until flush and resolve id-only metadata", async () => {
+      client.files.info.mockResolvedValue({ ok: true, file: slackFile() } as never);
+      seq += 1;
+      await assistantMessage({
+        message: {
+          channel: channelId,
           thread_ts: threadTs,
           ts: `1950000001.${String(seq).padStart(6, "0")}`,
           user: "U_HUMAN",
-          text: "!now here it is",
-          files: [slackFile()],
+          subtype: "file_share",
+          text: "",
+          files: [{ id: "F0SHOT0001" }],
         },
         body: { event_id: `evt_inbound_files_${seq}` },
         client,
         say: mock(async () => ({})),
+        setStatus: mock(async () => {}),
+        setTitle: mock(async () => {}),
+        getThreadContext: mock(async () => ({})),
+      });
+      expect(fileRequests).toEqual([]);
+      expect(client.files.info).not.toHaveBeenCalled();
+      expect(failureNotices()).toEqual([]);
+
+      await instantFlush(key);
+      const task = await followUp();
+      expect(await readStoredBytes(task.id)).toEqual([PNG_BYTES]);
+      expect(task.task).toContain("[File: screenshot.png");
+      expect(task.task).not.toContain("not attached");
+      expect(await wasDraft(task.id)).toBe(true);
+      expect(await getSteeringMessagesForTask(earlier.id)).toEqual([]);
+      expect(failureNotices()).toEqual([]);
+    });
+
+    for (const steering of ["off", "lead"]) {
+      test(`timed flush attaches every message's files with steering ${steering}`, async () => {
+        process.env.SLACK_THREAD_STEERING = steering;
+        const nativeSetTimeout = globalThis.setTimeout;
+        const bufferMs = Number(process.env.ADDITIVE_SLACK_BUFFER_MS) || 10_000;
+        const timer = spyOn(globalThis, "setTimeout").mockImplementation((fn, ms, ...args) =>
+          nativeSetTimeout(fn, ms === bufferMs ? 250 : ms, ...args),
+        );
+        const otherBytes = new Uint8Array([...PNG_BYTES, 4]);
+        bytesById.set("F0OTHER0001", otherBytes);
+        let lastTs: string;
+        try {
+          await sendBuffered("", [slackFile()]);
+          lastTs = await sendBuffered("compare these", [
+            slackFile({ id: "F0OTHER0001", name: "other.png", size: otherBytes.length }),
+          ]);
+          expect(getBufferMessageCount(key)).toBe(2);
+          expect(fileRequests).toEqual([]);
+          expect(failureNotices()).toEqual([]);
+        } finally {
+          timer.mockRestore();
+        }
+        // Wait for the real timer callback and draft promotion, not instantFlush.
+        for (let i = 0; i < 200; i++) {
+          const tasks = await getSlackTasksInThread(channelId, threadTs);
+          if (tasks.some((task) => task.id !== earlier.id && task.status === "pending")) break;
+          await Bun.sleep(10);
+        }
+        const task = await followUp();
+        expect(task.status).toBe("pending");
+        expect(task.dependsOn).toEqual([earlier.id]);
+        expect(task.slackTriggerMessageTs).toBe(lastTs!);
+        expect(task.task).toContain("2 message(s) buffered");
+        expect(task.task).toContain("compare these");
+        expect(task.task).not.toContain("not attached");
+        expect(await readStoredBytes(task.id)).toEqual([PNG_BYTES, otherBytes]);
+        expect(await wasDraft(task.id)).toBe(true);
+        expect(await getSteeringMessagesForTask(earlier.id)).toEqual([]);
+        expect(failureNotices()).toEqual([]);
+      });
+
+      test(`!now with files flushes existing files without dependency with steering ${steering}`, async () => {
+        process.env.SLACK_THREAD_STEERING = steering;
+        await sendBuffered("earlier screenshot", [slackFile()]);
+        expect(fileRequests).toEqual([]);
+        const otherBytes = new Uint8Array([...PNG_BYTES, 4]);
+        bytesById.set("F0OTHER0001", otherBytes);
+        await sendBuffered("!now", [
+          slackFile({ id: "F0OTHER0001", name: "other.png", size: otherBytes.length }),
+        ]);
+        const task = await followUp();
+        expect(task.task).toContain("earlier screenshot");
+        expect(task.task).not.toContain("!now");
+        expect(task.dependsOn).toEqual([]);
+        expect(await getTaskAttachments(task.id)).toHaveLength(2);
+        expect(await readStoredBytes(task.id)).toEqual([PNG_BYTES, otherBytes]);
+        expect(await getSteeringMessagesForTask(earlier.id)).toEqual([]);
+        expect(failureNotices()).toEqual([]);
       });
-    } finally {
-      process.env.ADDITIVE_SLACK = "false";
-      restoreSteeringEnv();
     }
 
-    expect(fileRequests).toEqual([]);
-    expect(client.chat.postMessage).toHaveBeenCalledTimes(1);
-    const [args] = client.chat.postMessage.mock.calls[0] as unknown as [{ text: string }];
-    expect(args.text).toContain("`screenshot.png`");
-    const flushed = await getDbClient().get<{ task: string }>(
-      "SELECT task FROM agent_tasks WHERE slackThreadTs = ? AND task != 'earlier work'",
-      [threadTs],
-    );
-    expect(flushed?.task).toContain("here it is");
-    expect(flushed?.task).toContain("(not attached: follow-ups queued by ADDITIVE_SLACK");
+    test("text-only follow-ups still steer the running task", async () => {
+      await sendBuffered("!now use the safer approach");
+      const steering = await getSteeringMessagesForTask(earlier.id);
+      expect(steering).toHaveLength(1);
+      expect(steering[0]!.body).toContain("use the safer approach");
+      expect(await getSlackTasksInThread(channelId, threadTs)).toHaveLength(1);
+      expect(fileRequests).toEqual([]);
+    });
+
+    test("download failures and oversize files are reported at flush while good files attach", async () => {
+      await sendBuffered("inspect these", [
+        slackFile(),
+        slackFile({
+          id: "F0DENIED001",
+          name: "denied.png",
+          url_private_download: `${slackFiles.url}forbidden`,
+        }),
+        slackFile({ id: "F0HUGE0001", name: "huge.png", size: HUGE_BYTES }),
+      ]);
+      expect(failureNotices()).toEqual([]);
+      await instantFlush(key);
+      const task = await followUp();
+      expect(await readStoredBytes(task.id)).toEqual([PNG_BYTES]);
+      expect(task.task).toContain("not attached: download failed (HTTP 403)");
+      expect(task.task).not.toContain("follow-ups queued by ADDITIVE_SLACK");
+      expect(failureNotices()).toHaveLength(1);
+      expect(failureNotices()[0]).toContain("`denied.png` (download failed (HTTP 403))");
+      expect(failureNotices()[0]).toContain("`huge.png`");
+      expect(failureNotices()[0]).not.toContain("`screenshot.png`");
+    });
+
+    test("storage failures are reported after flush", async () => {
+      const upload = spyOn(getFileStorageProvider(), "upload").mockRejectedValue(
+        new Error("storage unavailable"),
+      );
+      try {
+        await sendBuffered("!now inspect this", [slackFile()]);
+        const task = await followUp();
+        expect(task.status).toBe("pending");
+        expect(await getTaskAttachments(task.id)).toEqual([]);
+        expect(failureNotices()).toHaveLength(1);
+        expect(failureNotices()[0]).toContain("storage unavailable");
+      } finally {
+        upload.mockRestore();
+      }
+    });
+
+    test("an unavailable Slack app retains the buffered file failure fallback", async () => {
+      getApp.mockReturnValue(null);
+      await sendBuffered("!now inspect this", [slackFile()]);
+      const task = await followUp();
+      expect(await getTaskAttachments(task.id)).toEqual([]);
+      expect(task.task).toContain("[File: screenshot.png");
+      expect(task.task).toContain("not attached: follow-ups queued by ADDITIVE_SLACK");
+      expect(await getSteeringMessagesForTask(earlier.id)).toEqual([]);
+    });
   });
 
   test("a channel message that mentions the bot with a file attaches it", async () => {

package/src/tests/slack-reaction-config.test.ts

@@ -20,6 +20,7 @@ const ALL_EVENTS: SlackReactionEvent[] = [
 
 /** The four acceptance-stage names `main` removed as a fixed list at finalize. */
 const DEFAULT_ACCEPTANCE_NAMES = ["eyes", "heavy_plus_sign", "zap", "speech_balloon"];
+const SECRET_SHAPED_GITHUB_PAT = `github_pat_${"a".repeat(32)}`;
 
 function clearReactionEnv() {
   for (const key of Object.values(SLACK_REACTION_CONFIG_KEYS)) delete process.env[key];
@@ -320,7 +321,7 @@ describe("reaction-shortcode.ts", () => {
   test("a generic (non-invalid_name) add failure redacts a secret-shaped error message in the emitted log", async () => {
     const logSpy = spyOn(console, "log");
     logSpy.mockClear();
-    const leaked = "github_pat_11B4WKYAA0Qe95fajGmt3o_ABCDEF1234567890abcdef";
+    const leaked = SECRET_SHAPED_GITHUB_PAT;
     const add = async () => {
       throw new Error(`rate_limited: ${leaked}`);
     };
@@ -339,7 +340,7 @@ describe("reaction-shortcode.ts", () => {
   test("a generic (non-invalid_name/no_reaction) remove failure redacts a secret-shaped error message in the emitted log", async () => {
     const logSpy = spyOn(console, "log");
     logSpy.mockClear();
-    const leaked = "github_pat_11B4WKYAA0Qe95fajGmt3o_ABCDEF1234567890abcdef";
+    const leaked = SECRET_SHAPED_GITHUB_PAT;
     const remove = async () => {
       const error = new Error(`rate_limited: ${leaked}`) as Error & { data: unknown };
       error.data = { error: "rate_limited" };
@@ -361,7 +362,7 @@ describe("reaction-shortcode.ts", () => {
   test("an invalid_name add failure redacts a secret-shaped reaction name in the emitted log", async () => {
     const errorSpy = spyOn(console, "error");
     errorSpy.mockClear();
-    const leaked = "github_pat_11B4WKYAA0Qe95fajGmt3o_ABCDEF1234567890abcdef";
+    const leaked = SECRET_SHAPED_GITHUB_PAT;
     const add = async () => {
       throw { data: { error: "invalid_name" } };
     };
@@ -380,7 +381,7 @@ describe("reaction-shortcode.ts", () => {
   test("a fallback add failure after invalid_name redacts a secret-shaped error message in the emitted log", async () => {
     const logSpy = spyOn(console, "log");
     logSpy.mockClear();
-    const leaked = "github_pat_11B4WKYAA0Qe95fajGmt3o_ABCDEF1234567890abcdef";
+    const leaked = SECRET_SHAPED_GITHUB_PAT;
     const add = async ({ name }: { name: string }) => {
       if (name === "not_a_real_emoji") throw { data: { error: "invalid_name" } };
       throw new Error(`rate_limited: ${leaked}`);

package/src/tests/slack-read-boundaries.test.ts

@@ -9,7 +9,7 @@ import { mcpOverflowNamespace } from "../tools/utils";
 import { SKIP_SANDBOX_SPAWN_TESTS } from "./sandbox-spawn-test-helpers";
 
 const TEST_DB_PATH = "./test-slack-read-boundaries.sqlite";
-const API_KEY = "test-slack-read-boundaries-key-1234567890";
+const API_KEY = "example-test-slack-read-boundaries-key-1234567890";
 const AGENT_ID = "aaaaaaaa-0000-4000-8000-000000000001";
 const CHANNEL_ID = "C_BUSY_BOUNDARY";
 const FULL_MESSAGE_COUNT = 20;

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

@@ -19,6 +19,7 @@ import {
   getSlackTreeMessages,
   getTaskById,
   initDb,
+  insertTaskAttachment,
   isPendingSlackMessage,
   markTaskSlackReplySent,
   startTask,
@@ -39,7 +40,7 @@ import {
 } from "../slack/render-v2";
 import { getAgentDisplayName, getAgentEmoji } from "../slack/responses";
 import { slackContextKey } from "../tasks/context-key";
-import type { AgentTask } from "../types";
+import type { AgentTask, TaskAttachment } from "../types";
 import { clearVolatileSecretsForTesting } from "../utils/secret-scrubber";
 
 const TEST_DB_PATH = "./test-slack-render-v2.sqlite";
@@ -1183,6 +1184,95 @@ describe("Slack renderer v2", () => {
     expect(calls.some((call) => call.method === "chat.appendStream")).toBe(false);
   });
 
+  test.each<{
+    label: string;
+    attachment: Partial<TaskAttachment> & Pick<TaskAttachment, "kind" | "name">;
+    expected: string;
+  }>([
+    {
+      label: "plain ASCII positive control",
+      attachment: { kind: "agent-fs", name: "report.txt", path: "/reports/report.txt" },
+      expected:
+        "📎 [report.txt](https://files.example.test/file/~/org-1/drive-1/reports/report.txt)",
+    },
+    {
+      label: "raw path spaces and parentheses",
+      attachment: { kind: "agent-fs", name: "final report", path: "/shared reports/final (v1).md" },
+      expected:
+        "📎 [final report](https://files.example.test/file/~/org-1/drive-1/shared%20reports/final%20%28v1%29.md)",
+    },
+    {
+      label: "already encoded positive control",
+      attachment: { kind: "agent-fs", name: "report", path: "/reports/final%20%28v1%29.md" },
+      expected:
+        "📎 [report](https://files.example.test/file/~/org-1/drive-1/reports/final%20%28v1%29.md)",
+    },
+    {
+      label: "label delimiters, backslashes, and whitespace",
+      attachment: {
+        kind: "url",
+        name: " \t[report] (final)\\\r\n\t copy  ",
+        url: "https://example.test/report",
+      },
+      expected: "📎 [\\[report\\] \\(final\\)\\\\ copy](https://example.test/report)",
+    },
+    {
+      label: "URL positive control with an IPv6 host",
+      attachment: { kind: "url", name: "report", url: "http://[::1]/report.txt?q=a%20b&x=1#part" },
+      expected: "📎 [report](http://[::1]/report.txt?q=a%20b&x=1#part)",
+    },
+    {
+      label: "URL delimiters with existing escapes and query parameters",
+      attachment: {
+        kind: "url",
+        name: "report",
+        url: "https://example.test/a%20b) [c]<(d)>\\file?q=one two&x=1#part",
+      },
+      expected:
+        "📎 [report](https://example.test/a%20b%29%20[c]%3C%28d%29%3E%5Cfile?q=one%20two&x=1#part)",
+    },
+    {
+      label: "non-HTTP fallback stays omitted",
+      attachment: { kind: "url", name: "report", url: "agent-fs:/reports/report.md" },
+      expected: "",
+    },
+  ])("streams safe attachment Markdown: $label", async ({ attachment, expected }) => {
+    const originalHost = process.env.AGENT_FS_LIVE_URL;
+    process.env.AGENT_FS_LIVE_URL = "https://files.example.test";
+    try {
+      const lead = await createAgent({ name: "Attachment Lead", isLead: true, status: "idle" });
+      const { channelId, threadTs } = uniqueSlackAddress("C_OUTCOME_ATTACHMENT");
+      const ask = await createTaskExtended("render attachment link", {
+        agentId: lead.id,
+        source: "slack",
+        slackChannelId: channelId,
+        slackThreadTs: threadTs,
+        contextKey: slackContextKey({ channelId, threadTs }),
+      });
+      await insertTaskAttachment({
+        ...attachment,
+        taskId: ask.id,
+        agentId: lead.id,
+        orgId: "org-1",
+        driveId: "drive-1",
+        isPrimary: true,
+      });
+      await startTask(ask.id);
+      await ensureSlackThreadTree([ask.id]);
+      await completeTask(ask.id, "Done");
+      calls.length = 0;
+      _resetSlackRenderV2ForTests();
+
+      await processSlackRenderV2();
+
+      const started = calls.find((call) => call.method === "chat.startStream");
+      expect(started?.payload.markdown_text).toBe(`✅\n\nDone${expected ? `\n\n${expected}` : ""}`);
+    } finally {
+      if (originalHost === undefined) delete process.env.AGENT_FS_LIVE_URL;
+      else process.env.AGENT_FS_LIVE_URL = originalHost;
+    }
+  });
+
   test("truncates oversized Markdown before a code fence and links the full task", async () => {
     const lead = await createAgent({ name: "Overflow Lead", isLead: true, status: "idle" });
     const { channelId, threadTs } = uniqueSlackAddress("C_OUTCOME_OVERFLOW");
@@ -1626,6 +1716,35 @@ describe("Slack renderer v2", () => {
     expect(outcome?.finalizedAt).toBeDefined();
   });
 
+  test("keeps a deferral's human-facing line even when the agent already sent a slack-reply", async () => {
+    const lead = await createAgent({ name: "Deferring Lead", isLead: true, status: "idle" });
+    const { channelId, threadTs } = uniqueSlackAddress("C_RENDER_DEFER_AFTER_REPLY");
+    const ask = await createTaskExtended("defer after replying by hand", {
+      agentId: lead.id,
+      source: "slack",
+      slackChannelId: channelId,
+      slackThreadTs: threadTs,
+      contextKey: slackContextKey({ channelId, threadTs }),
+    });
+    await startTask(ask.id);
+    await ensureSlackThreadTree([ask.id]);
+    // Agent posts a hand-written slack-reply first (e.g. a transcription),
+    // then defer-task completes the task with the engine-authored deferral
+    // line and tags it "deferred" (mirrors defer-task.ts's completeTask call).
+    await markTaskSlackReplySent(ask.id);
+    const deferralLine =
+      "Deferred until today 17:30:19 UTC ([715bf847](https://app.agent-swarm.dev/schedules/715bf847-fe3e-40e9-9fef-3297a62d9afd)) -> checking the new defer card";
+    await completeTask(ask.id, deferralLine, { addTags: ["deferred"] });
+    calls.length = 0;
+    _resetSlackRenderV2ForTests();
+
+    await processSlackRenderV2();
+
+    const started = calls.find((call) => call.method === "chat.startStream");
+    expect(started?.payload.markdown_text).toBe(`✅\n\n${deferralLine}`);
+    expect(started?.payload.markdown_text).not.toBe(`✅ ${lead.name} completed`);
+  });
+
   test("refreshes a stream started with stale content before finalizing it", async () => {
     const lead = await createAgent({ name: "Refresh Lead", isLead: true, status: "idle" });
     const { channelId, threadTs } = uniqueSlackAddress("C_RENDER_REFRESH_STALE");