@desplega.ai/agent-swarm 1.149.1 → 1.151.0

package/src/tests/send-task-output-schema.test.ts

@@ -40,7 +40,7 @@ function callSendTask(
 function structuredOf(result: CallToolResult) {
   return result.structuredContent as {
     success: boolean;
-    task?: { id: string; outputSchema?: Record<string, unknown> };
+    task?: { id: string; outputSchema?: Record<string, unknown>; routingSource?: string };
     message: string;
   };
 }
@@ -168,6 +168,7 @@ describe("send-task: outputSchema propagation", () => {
     const created = await getTaskById(s.task!.id);
     expect(created?.outputSchema).toEqual(schema);
     expect(created?.routingReason).toBeUndefined();
+    expect(created?.routingSource).toBeUndefined();
   });
 
   test("a provided outputSchema is persisted when the task is offered to an agent", async () => {
@@ -184,6 +185,7 @@ describe("send-task: outputSchema propagation", () => {
         task: "offered task with a schema",
         agentId: worker.id,
         routingReason: "human_pinned",
+        routingNote: "This test explicitly selects the target worker",
         offerMode: true,
         outputSchema: schema,
         allowDuplicate: true,
@@ -214,6 +216,7 @@ describe("send-task: outputSchema propagation", () => {
         task: "directly assigned task with a schema",
         agentId: worker.id,
         routingReason: "human_pinned",
+        routingNote: "This test explicitly selects the target worker",
         outputSchema: schema,
         allowDuplicate: true,
       },
@@ -224,6 +227,8 @@ describe("send-task: outputSchema propagation", () => {
     const created = await getTaskById(s.task!.id);
     expect(created?.outputSchema).toEqual(schema);
     expect(created?.routingReason).toBe("human_pinned");
+    expect(created?.routingSource).toBe("declared");
+    expect(s.task?.routingSource).toBe("declared");
   });
 
   test("implicit parent routing stamps continuity while pool creation omits a reason", async () => {
@@ -249,6 +254,8 @@ describe("send-task: outputSchema propagation", () => {
     const continuedTask = await getTaskById(structuredOf(continued).task!.id);
     expect(continuedTask?.agentId).toBe(worker.id);
     expect(continuedTask?.routingReason).toBe("continuity");
+    expect(continuedTask?.routingSource).toBe("engine_default");
+    expect(structuredOf(continued).task?.routingSource).toBe("engine_default");
 
     const pooled = await callSendTask(
       server,
@@ -278,6 +285,7 @@ describe("send-task: outputSchema propagation", () => {
     );
     const created = await getTaskById(structuredOf(result).task!.id);
     expect(created?.routingNote).toBe("matches the required runtime specialization");
+    expect(created?.routingSource).toBe("declared");
   });
 });
 

package/src/tests/send-task-requested-by.test.ts

@@ -152,6 +152,7 @@ describe("send-task: requestedByUserId inheritance", () => {
         task: "worker direct assign — inherit user",
         agentId: WORKER_ID,
         routingReason: "human_pinned",
+        routingNote: "This test explicitly selects the target worker",
         allowDuplicate: true,
       },
       LEAD_ID,

package/src/tests/send-task-slack-routing-guard.test.ts

@@ -276,6 +276,7 @@ describe("send-task: Slack-routing coherence guard", () => {
         task: "direct assign with wrong channel",
         agentId: WORKER_ID,
         routingReason: "human_pinned",
+        routingNote: "This test explicitly selects the target worker",
         slackChannelId: "C_WRONG_DIRECT",
         slackThreadTs: "555.555",
         allowDuplicate: true,
@@ -301,6 +302,7 @@ describe("send-task: Slack-routing coherence guard", () => {
         task: "offer with wrong channel",
         agentId: WORKER_ID,
         routingReason: "human_pinned",
+        routingNote: "This test explicitly selects the target worker",
         offerMode: true,
         slackChannelId: "C_WRONG_OFFER",
         slackThreadTs: "666.666",

package/src/tests/session-costs-codex-recompute.test.ts

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

package/src/tests/session-costs-golden.test.ts

@@ -21,8 +21,8 @@ import { getPathSegments, parseQueryParams } from "../http/utils";
 import type { PricingProvider, PricingTokenClass } from "../types";
 import { listenOnFreePort } from "./test-net";
 
-const TEST_DB_PATH = "./test-session-costs-golden.sqlite";
-const API_KEY = "test-session-costs-golden";
+const TEST_DB_PATH = "./example-test-session-costs-golden.sqlite";
+const API_KEY = "example-test-session-costs-golden";
 const RATE_EFFECTIVE_AT = 1_800_000_000_000;
 const FIXTURE_CREATED_AT = RATE_EFFECTIVE_AT + 1;
 const EPSILON = 1e-9;

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-blocks.test.ts

@@ -298,8 +298,10 @@ describe("buildAssignmentSummaryBlocks", () => {
       failed: [{ agentName: "Delta", reason: "error" }],
     });
 
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0].text.text).not.toBe("");
     expect(blocks[0].text.text).toContain("⚠️");
-    expect(blocks[0].text.text).toContain("Could not assign");
+    expect(blocks[0].text.text).toContain("Could not assign to:");
   });
 });
 
@@ -463,6 +465,15 @@ function makeTaskId(prefix: string): string {
 }
 
 describe("buildTreeBlocks", () => {
+  test("empty tree omits the section with empty text", () => {
+    const blocks = buildTreeBlocks([]);
+
+    expect(blocks).toHaveLength(0);
+    expect(blocks.every((block) => block.type !== "section" || block.text.text.length > 0)).toBe(
+      true,
+    );
+  });
+
   test("single root, no children", () => {
     const root: TreeNode = {
       taskId: makeTaskId("aaaa0001"),

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;