@desplega.ai/agent-swarm 1.150.0 → 1.152.0

package/src/tests/rbac-e2e-helpers.ts

@@ -314,3 +314,21 @@ export async function waitForAuditCount(
   }
   return n;
 }
+
+/** Poll until audit rows satisfy `predicate` (writer flushes every 2s). */
+export async function waitForAuditRows(
+  dbPath: string,
+  predicate: (rows: AuditRow[]) => boolean,
+  deadlineMs = 8_000,
+): Promise<AuditRow[]> {
+  const start = Date.now();
+  let rows = readAuditRows(dbPath);
+  while (!predicate(rows)) {
+    if (Date.now() - start >= deadlineMs) {
+      throw new Error(`audit rows did not satisfy predicate within ${deadlineMs}ms`);
+    }
+    await Bun.sleep(250);
+    rows = readAuditRows(dbPath);
+  }
+  return rows;
+}

package/src/tests/rbac-engine.test.ts

@@ -81,6 +81,9 @@ const LEAD_ONLY_VERBS: PermissionVerb[] = [
   "script.api.delete",
 ];
 
+const OPERATOR_ONLY_VERBS: PermissionVerb[] = [];
+const LEAD_OR_OPERATOR_VERBS: PermissionVerb[] = ["extension.write", "extension.activate"];
+
 const LEAD_OR_RESOURCE_OWNER_VERBS: PermissionVerb[] = [
   "memory.edit.any",
   "skill.update.any",
@@ -171,6 +174,8 @@ describe("verb-group partition", () => {
       ...ANY_AUTHENTICATED_VERBS,
       ...REQUESTER_OWNS_TASK_VERBS,
       ...COMPOSITE_VERBS,
+      ...OPERATOR_ONLY_VERBS,
+      ...LEAD_OR_OPERATOR_VERBS,
     ];
     expect(new Set(grouped).size).toBe(grouped.length);
     expect(grouped.sort()).toEqual([...PERMISSION_VERBS].sort());
@@ -216,6 +221,40 @@ describe("lead-only verbs", () => {
   });
 });
 
+describe("operator-or-user verbs", () => {
+  const expected: Expected = {
+    lead: false,
+    worker: false,
+    ownerWorker: false,
+    creatorWorker: false,
+    userRequester: true,
+    foreignUser: true,
+    operator: true,
+  };
+  for (const verb of OPERATOR_ONLY_VERBS) {
+    test(`${verb}: operator or user allowed`, () => {
+      expectDecisions(verb, { kind: "none" }, expected);
+    });
+  }
+});
+
+describe("lead-or-operator-or-user verbs", () => {
+  const expected: Expected = {
+    lead: true,
+    worker: false,
+    ownerWorker: false,
+    creatorWorker: false,
+    userRequester: true,
+    foreignUser: true,
+    operator: true,
+  };
+  for (const verb of LEAD_OR_OPERATOR_VERBS) {
+    test(`${verb}: lead, operator, or user allowed`, () => {
+      expectDecisions(verb, { kind: "none" }, expected);
+    });
+  }
+});
+
 describe("lead-or-resource-owner verbs", () => {
   const expected: Expected = {
     lead: true,

package/src/tests/rbac-mcp-admission-e2e.test.ts

@@ -12,12 +12,11 @@ import {
   countAuditRows,
   LEAD,
   makeScratchDir,
-  readAuditRows,
   registerAgent,
   removeScratchDir,
   type SwarmServer,
   spawnSwarmServer,
-  waitForAuditCount,
+  waitForAuditRows,
 } from "./rbac-e2e-helpers";
 
 setDefaultTimeout(120_000);
@@ -312,8 +311,27 @@ describe("RBAC admission over /mcp-user", () => {
       }),
     );
 
-    expect(await waitForAuditCount(enabledDbPath, 10)).toBeGreaterThanOrEqual(10);
-    const mcpRows = readAuditRows(enabledDbPath).filter((row) => row.source === "mcp");
+    const mcpRows = (
+      await waitForAuditRows(enabledDbPath, (rows) => {
+        const auditRows = rows.filter((row) => row.source === "mcp");
+        return (
+          auditRows.some(
+            (row) =>
+              row.principalId === requester.userId &&
+              row.resourceType === "mcp-tool" &&
+              row.resourceId === "send-task" &&
+              row.verb === "task.create.own" &&
+              row.decision === "allow",
+          ) &&
+          ["task.create.own", "task.cancel.own", "task.action.own"].every((verb) =>
+            auditRows.some(
+              (row) =>
+                row.principalId === empty.userId && row.decision === "deny" && row.verb === verb,
+            ),
+          )
+        );
+      })
+    ).filter((row) => row.source === "mcp");
     expect(
       mcpRows.some(
         (row) =>

package/src/tests/realtime-room-auth.test.ts

@@ -44,7 +44,7 @@ describe("realtime room namespace guards", () => {
 
   test("allows page writes for user and operator contexts when RBAC is disabled", async () => {
     const previous = process.env.RBAC_ENABLED;
-    delete process.env.RBAC_ENABLED;
+    process.env.RBAC_ENABLED = "false";
     try {
       await expect(
         authorizeRoomNamespace(

package/src/tests/reload-config.test.ts

@@ -3,6 +3,7 @@ import { unlink } from "node:fs/promises";
 import { createServer as createHttpServer, type Server } from "node:http";
 import { initAgentMail, resetAgentMail } from "../agentmail";
 import { closeDb, deleteSwarmConfig, getDbClient, initDb, upsertSwarmConfig } from "../be/db";
+import { getEmbeddingProvider, resetEmbeddingProvider } from "../be/memory";
 import { initGitHub, resetGitHub } from "../github";
 import {
   __resetInjectedEnvTracking,
@@ -10,6 +11,7 @@ import {
   _resetAutoReloadForTests,
   flushPendingIntegrationsReload,
   loadGlobalConfigsIntoEnv,
+  reloadGlobalConfigsAndIntegrations,
   scheduleIntegrationsReload,
 } from "../http/core";
 import { isOriginAllowedForCredentials } from "../http/utils";
@@ -225,6 +227,23 @@ describe("reload-config", () => {
     }
   });
 
+  test("stored lead activation gate cannot override the deployment at boot or reload", async () => {
+    const key = "EXTENSION_ALLOW_LEAD_ACTIVATION";
+    const original = process.env[key];
+    const rowId = await insertLegacyReservedRow(key, "true");
+    try {
+      process.env[key] = "false";
+      for (const override of [false, true]) {
+        expect(await loadGlobalConfigsIntoEnv(override)).not.toContain(key);
+        expect(process.env[key]).toBe("false");
+      }
+    } finally {
+      await deleteSwarmConfig(rowId);
+      if (original === undefined) delete process.env[key];
+      else process.env[key] = original;
+    }
+  });
+
   test("loadGlobalConfigsIntoEnv skips unreadable reserved secret rows before decrypting them", async () => {
     const id = await insertUnreadableReservedSecretRow("SECRETS_ENCRYPTION_KEY");
 
@@ -262,6 +281,48 @@ describe("reload-config", () => {
     expect(res.status).toBe(404);
   });
 
+  // Regression: EMBEDDING_API_KEY / OPENAI_API_KEY used to be read once at
+  // OpenAIEmbeddingProvider construction and never revisited, so a key set
+  // (or rotated) via the dashboard/API stayed inert until the API process
+  // restarted (customer-reported, Jan Carbonell 2026-09-16: valid key,
+  // reload reported it loaded, embeddings still stayed off). Assert the
+  // full path: no key -> provider unconfigured -> config write + reload ->
+  // provider live, without a restart.
+  test("reload turns embeddings on without a restart once a key lands via config", async () => {
+    const originalEmbeddingKey = process.env.EMBEDDING_API_KEY;
+    const originalOpenAiKey = process.env.OPENAI_API_KEY;
+    delete process.env.EMBEDDING_API_KEY;
+    delete process.env.OPENAI_API_KEY;
+    resetEmbeddingProvider();
+    expect(getEmbeddingProvider().isConfigured()).toBe(false);
+
+    const config = await upsertSwarmConfig({
+      scope: "global",
+      key: "EMBEDDING_API_KEY",
+      value: "sk-test-not-a-real-key",
+      isSecret: true,
+    });
+
+    try {
+      const result = await reloadGlobalConfigsAndIntegrations();
+      expect(result.keysUpdated).toContain("EMBEDDING_API_KEY");
+      expect(result.integrationsReinitialized).toContain("embeddings");
+      expect(getEmbeddingProvider().isConfigured()).toBe(true);
+    } finally {
+      await deleteSwarmConfig(config.id);
+      delete process.env.EMBEDDING_API_KEY;
+      if (originalOpenAiKey === undefined) {
+        delete process.env.OPENAI_API_KEY;
+      } else {
+        process.env.OPENAI_API_KEY = originalOpenAiKey;
+      }
+      resetEmbeddingProvider();
+      if (originalEmbeddingKey !== undefined) {
+        process.env.EMBEDDING_API_KEY = originalEmbeddingKey;
+      }
+    }
+  });
+
   // Regression: injection used to be one-way. Deleting a global row left the
   // previously-injected value live in process.env until the process restarted,
   // so "reset to default" in the dashboard silently did nothing.

package/src/tests/routing-affinity-inventory.test.ts

@@ -101,7 +101,7 @@ const EXPECTED_INVENTORY: InventoryEntry[] = [
     file: "src/tools/send-task.ts",
     owner: "sendTaskHandler",
     syntax: "PropertyAssignment",
-    count: 3,
+    count: 1,
     kind: "producer",
     dispatchProof: {
       file: "src/tests/task-tools-ctx.test.ts",

package/src/tests/script-connections.test.ts

@@ -570,6 +570,8 @@ describe("script connections", () => {
       markMigrationApplied(database, "151_repair_scheduled_task_required_params.sql");
       // 152 indexes task routing context absent from this migration-112-only fixture.
       markMigrationApplied(database, "152_routing_decisions.sql");
+      // 156 alters inbox_item_state, which this migration-112-only fixture does not create.
+      markMigrationApplied(database, "156_inbox_item_state_read_at.sql");
 
       const id = crypto.randomUUID();
       const now = new Date().toISOString();

package/src/tests/scripts-boot-reembed.test.ts

@@ -41,6 +41,10 @@ class FakeEmbeddingProvider implements EmbeddingProvider {
     return Promise.all(texts.map((text) => this.embed(text)));
   }
 
+  isConfigured(): boolean {
+    return true;
+  }
+
   reset(): void {
     this.calls.length = 0;
   }

package/src/tests/scripts-embeddings.test.ts

@@ -58,6 +58,10 @@ class FakeEmbeddingProvider implements EmbeddingProvider {
     return Promise.all(texts.map((text) => this.embed(text)));
   }
 
+  isConfigured(): boolean {
+    return true;
+  }
+
   reset(): void {
     this.calls.length = 0;
   }

package/src/tests/scripts-import-allowlist.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { validateScriptImports } from "../scripts-runtime/import-allowlist";
+import { checkImportAllowlist, validateScriptImports } from "../scripts-runtime/import-allowlist";
 
 describe("script import allowlist", () => {
   test("allows relative imports and runtime barrels", () => {
@@ -61,6 +61,49 @@ describe("script import allowlist", () => {
     if (!result.ok) expect(result.diagnostic).toContain("fs");
   });
 
+  test("allows literal dynamic imports from the existing script allowlist", () => {
+    expect(validateScriptImports("export default async () => import('zod')")).toEqual({
+      ok: true,
+    });
+  });
+
+  test("allows computed dynamic imports by default", () => {
+    expect(validateScriptImports("const x = 'zod'; export default async () => import(x)")).toEqual({
+      ok: true,
+    });
+  });
+
+  test("strictDynamic rejects computed dynamic imports and requires", () => {
+    for (const source of [
+      "const name = 'zod'; export default async () => import(name)",
+      "const name = 'zod'; export default () => require(name)",
+    ]) {
+      const result = checkImportAllowlist(source, {
+        allowedBare: ["swarm-extension", "stdlib", "zod"],
+        allowRelative: false,
+        strictDynamic: true,
+      });
+      expect(result.ok).toBe(false);
+      if (!result.ok) expect(result.diagnostic).toContain("Computed");
+    }
+  });
+
+  test("strictDynamic checks require and import-equals specifiers", () => {
+    for (const source of [
+      "export default () => require('node:fs')",
+      "import fs = require('node:fs'); export default () => fs",
+    ]) {
+      expect(validateScriptImports(source)).toEqual({ ok: true });
+      const result = checkImportAllowlist(source, {
+        allowedBare: ["swarm-extension", "stdlib", "zod"],
+        allowRelative: false,
+        strictDynamic: true,
+      });
+      expect(result.ok).toBe(false);
+      if (!result.ok) expect(result.diagnostic).toContain("node:fs");
+    }
+  });
+
   test("rejects Function constructor dynamic import bypasses", () => {
     const result = validateScriptImports(
       `export default async () => new Function("return import('node:fs')")()`,

package/src/tests/scripts-mcp-e2e.test.ts

@@ -10,6 +10,7 @@ import { handleCore } from "../http/core";
 import { handleScriptRuns } from "../http/script-runs";
 import { handleScripts } from "../http/scripts";
 import { getPathSegments, parseQueryParams } from "../http/utils";
+import { proxyScriptsApi } from "../tools/script-common";
 import { registerScriptDeleteTool } from "../tools/script-delete";
 import { registerScriptRunTool } from "../tools/script-run";
 import { registerScriptRunsTools } from "../tools/script-runs";
@@ -221,6 +222,85 @@ beforeEach(async () => {
 });
 
 describe("script_ MCP HTTP proxy tools", () => {
+  test.each([200, 502])("rejects HTML responses with HTTP %i", async (status) => {
+    const tools = buildToolServer();
+    const html = "<!doctype html><html><body>Static site fallback</body></html>";
+    const previousFetch = globalThis.fetch;
+    globalThis.fetch = (async () =>
+      new Response(html, {
+        status,
+        headers: { "Content-Type": "text/html; charset=utf-8" },
+      })) as typeof globalThis.fetch;
+    try {
+      const result = (await tools.listScriptRuns.handler(
+        { limit: 10, offset: 0 },
+        meta(workerId),
+      )) as StructuredResult<unknown>;
+
+      expect(result.isError).toBe(true);
+      expect(result.structuredContent.success).toBe(false);
+      expect(result.structuredContent.status).toBe(status);
+      expect(result.structuredContent.message).toContain("non-JSON");
+      expect(result.structuredContent.message).toContain(`HTTP ${status}`);
+      expect(result.structuredContent.message).toContain("text/html");
+      expect(result.content[0]?.text).toContain(html);
+      expect(result.content[0]?.text).not.toContain("Found 0 script run(s)");
+    } finally {
+      globalThis.fetch = previousFetch;
+    }
+  });
+
+  test("caps invalid JSON diagnostics without retaining the full body", async () => {
+    const body = `<html>${"x".repeat(20_000)}BODY_TAIL</html>`;
+    const previousFetch = globalThis.fetch;
+    globalThis.fetch = (async () =>
+      new Response(body, {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      })) as typeof globalThis.fetch;
+    try {
+      const result = await proxyScriptsApi({
+        method: "GET",
+        path: "/api/script-runs",
+        requestInfo: {
+          sessionId: "s",
+          agentId: workerId,
+          runtimeInstanceId: undefined,
+          sourceTaskId: undefined,
+          contextKey: undefined,
+          callOrigin: "mcp",
+        },
+        successMessage: () => {
+          throw new Error("Invalid JSON must not reach the success callback");
+        },
+        uncappedDetails: true,
+      });
+
+      expect(result.ok).toBe(false);
+      expect(result.message).toContain("application/json");
+      expect(result.details).toContain("<html>");
+      expect(result.details).toContain("[truncated");
+      expect(result.details?.length).toBeLessThan(16_100);
+      expect(JSON.stringify(result)).not.toContain("BODY_TAIL");
+    } finally {
+      globalThis.fetch = previousFetch;
+    }
+  });
+
+  test("reports a legitimate JSON empty run list as success", async () => {
+    const tools = buildToolServer();
+    const result = (await tools.listScriptRuns.handler(
+      { limit: 10, offset: 0 },
+      meta(workerId),
+    )) as StructuredResult<{ total: number; runs: unknown[] }>;
+
+    expect(result.isError).toBeFalsy();
+    expect(result.structuredContent.success).toBe(true);
+    expect(result.structuredContent.status).toBe(200);
+    expect(result.structuredContent.data?.runs).toEqual([]);
+    expect(result.structuredContent.message).toBe("Found 0 script run(s).");
+  });
+
   test("upserts the canonical script authoring contract example verbatim", async () => {
     const tools = buildToolServer();
     // The authoring contract lives in the seeded `swarm-scripts` skill since

package/src/tests/scripts-only-gating.test.ts

@@ -17,6 +17,12 @@ import { listenOnFreePort } from "./test-net";
 
 const TEST_DB_PATH = "./test-scripts-only-gating.sqlite";
 const SCRIPT_TOOL_NAMES = [
+  "extension-delete",
+  "extension-enable",
+  "extension-disable",
+  "extension-activate-version",
+  "extension-install",
+  "extension-list",
   "get-script-run",
   "launch-script-run",
   "list-script-runs",

package/src/tests/scripts-runtime-identity.test.ts

@@ -374,7 +374,7 @@ describe("script SDK dispatch hits the real runtime gates", () => {
   });
 
   test("with the flag off, the SDK dispatches without runtime identity as before", async () => {
-    delete process.env.MULTI_RUNTIME_ENABLED;
+    process.env.MULTI_RUNTIME_ENABLED = "false";
     const agentId = await makeAgent(1);
     const task = await createTaskExtended("legacy-claim-work");
 

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-render-v2.test.ts

@@ -6,6 +6,7 @@ import {
   completeTask,
   createAgent,
   createLogEntry,
+  createScheduledTask,
   createTaskExtended,
   ensureSlackDelegationActivation,
   ensureSlackRenderV2Activation,
@@ -26,6 +27,7 @@ import {
   supersedeTask,
   upsertSwarmConfig,
 } from "../be/db";
+import { createStandaloneScheduleTask } from "../scheduler/schedule-task";
 import { getTaskLink, MAX_SECTION_LENGTH } from "../slack/blocks";
 import {
   _resetSlackRenderV2ForTests,
@@ -300,12 +302,83 @@ describe("Slack renderer v2", () => {
     });
   });
 
-  test("defaults off and accepts an explicit opt-in", () => {
+  for (const delegationEnabled of [false, true]) {
+    test(`relays a deferred schedule continuation with delegation=${delegationEnabled}`, async () => {
+      process.env.SLACK_RENDER_V2_DELEGATION = String(delegationEnabled);
+      if (delegationEnabled) await ensureSlackDelegationActivation();
+      const lead = await createAgent({ name: "Continuation Lead", isLead: true, status: "idle" });
+      const { channelId, threadTs } = uniqueSlackAddress("C_CONTINUATION");
+      const ask = await createTaskExtended("answer when ready", {
+        agentId: lead.id,
+        source: "slack",
+        slackChannelId: channelId,
+        slackThreadTs: threadTs,
+        contextKey: slackContextKey({ channelId, threadTs }),
+      });
+      await startTask(ask.id);
+      await completeTask(ask.id, "Waiting for the result.", { addTags: ["deferred"] });
+      await backdateLastUpdated([ask.id], 20);
+      await processSlackRenderV2();
+      expect((await getSlackOutcomeMessage(ask.id))?.finalizedAt).toBeTruthy();
+
+      const schedule = await createScheduledTask({
+        name: "deferred-answer",
+        scheduleType: "one_time",
+        taskTemplate: "Deliver the result",
+        taskType: "deferred",
+        tags: ["deferred"],
+        parentTaskId: ask.id,
+        targetAgentId: lead.id,
+        createdByAgentId: lead.id,
+        nextRunAt: new Date().toISOString(),
+      });
+      const continuation = await createStandaloneScheduleTask(schedule);
+      expect(continuation.source).toBe("schedule");
+      expect(continuation.scheduleId).toBe(schedule.id);
+      expect(continuation.slackChannelId).toBe(channelId);
+      expect(continuation.slackThreadTs).toBe(threadTs);
+      await startTask(continuation.id);
+      await processSlackRenderV2();
+      expect(await getSlackOutcomeMessage(continuation.id)).toBeNull();
+      await completeTask(continuation.id, "Here is the complete answer.");
+      calls.length = 0;
+
+      await processSlackRenderV2();
+      await processSlackRenderV2();
+
+      expect((await getSlackOutcomeMessage(continuation.id))?.finalizedAt).toBeTruthy();
+      const streams = calls.filter((call) => call.method === "chat.startStream");
+      expect(streams).toHaveLength(1);
+      expect(streams[0]?.payload).toMatchObject({
+        channel: channelId,
+        thread_ts: threadTs,
+        markdown_text: "✅\n\nHere is the complete answer.",
+      });
+    });
+  }
+
+  test("does not relay an ordinary scheduled task without Slack context", async () => {
+    const schedule = await createScheduledTask({
+      name: "ordinary-maintenance",
+      scheduleType: "one_time",
+      taskTemplate: "Run maintenance",
+      taskType: "maintenance",
+      nextRunAt: new Date().toISOString(),
+    });
+    const task = await createStandaloneScheduleTask(schedule);
+    await startTask(task.id);
+    await completeTask(task.id, "Maintenance completed.");
+    await processSlackRenderV2();
+    expect(await getSlackOutcomeMessage(task.id)).toBeNull();
+    expect(calls).toHaveLength(0);
+  });
+
+  test("defaults on and accepts an explicit opt-out", () => {
     const previous = process.env.SLACK_RENDER_V2;
     delete process.env.SLACK_RENDER_V2;
-    expect(isSlackRenderV2Enabled()).toBe(false);
-    process.env.SLACK_RENDER_V2 = "true";
     expect(isSlackRenderV2Enabled()).toBe(true);
+    process.env.SLACK_RENDER_V2 = "false";
+    expect(isSlackRenderV2Enabled()).toBe(false);
     if (previous === undefined) delete process.env.SLACK_RENDER_V2;
     else process.env.SLACK_RENDER_V2 = previous;
   });
@@ -1716,7 +1789,7 @@ 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 () => {
+  test("omits the deferral ETA 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", {
@@ -1741,10 +1814,32 @@ describe("Slack renderer v2", () => {
     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).toBe("✅\n\nPending: checking the new defer card");
+    expect(JSON.stringify(calls)).not.toContain("17:30:19");
+    expect(JSON.stringify(calls)).not.toContain("Deferred until");
+    expect((await getTaskById(ask.id))?.output).toBe(deferralLine);
     expect(started?.payload.markdown_text).not.toBe(`✅ ${lead.name} completed`);
   });
 
+  test("does not post an ETA-only deferral notice", async () => {
+    const { channelId, threadTs } = uniqueSlackAddress("C_ETA_ONLY");
+    const ask = await createTaskExtended("wait", {
+      source: "slack",
+      slackChannelId: channelId,
+      slackThreadTs: threadTs,
+    });
+    await startTask(ask.id);
+    await completeTask(
+      ask.id,
+      "Deferred until today 17:30 UTC ([12345678](https://example.com/schedules/12345678)) -> ",
+      { addTags: ["deferred"] },
+    );
+    calls.length = 0;
+    await processSlackRenderV2();
+    expect(calls.filter((call) => call.method === "chat.startStream")).toHaveLength(0);
+    expect(JSON.stringify(calls)).not.toContain("17:30");
+  });
+
   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");

package/src/tests/slack-router.test.ts

@@ -1,7 +1,7 @@
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { unlinkSync } from "node:fs";
-import { closeDb, createAgent, createTaskExtended, initDb } from "../be/db";
-import { routeMessage } from "../slack/router";
+import { closeDb, createAgent, createTaskExtended, getAllAgents, initDb } from "../be/db";
+import { broadcastMatches, routeMessage } from "../slack/router";
 import type { Agent } from "../types";
 
 const TEST_DB_PATH = "./test-slack-router.sqlite";
@@ -169,6 +169,21 @@ describe("Slack router — thread follow-up routing", () => {
       // Lead should not be in the matches
       expect(matches.every((m) => !m.agent.isLead)).toBe(true);
     });
+
+    test("swarm#all includes offline non-lead agents", async () => {
+      const offlineWorker = await createAgent({
+        name: "offline-broadcast-worker",
+        isLead: false,
+        status: "offline",
+        capabilities: [],
+      });
+
+      const matches = broadcastMatches(await getAllAgents());
+
+      expect(matches.map((match) => match.agent.id)).toContain(offlineWorker.id);
+      expect(matches.every((match) => !match.agent.isLead)).toBe(true);
+      expect(matches.every((match) => match.matchedText === "swarm#all")).toBe(true);
+    });
   });
 
   describe("no thread context behaves normally", () => {

package/src/tests/slack-steering.test.ts

@@ -105,6 +105,25 @@ describe("Slack thread steering", () => {
     expect(await getChildTasks(leadTask.id)).toHaveLength(1);
   });
 
+  test("unset configuration steers the lead with queued delivery", async () => {
+    delete process.env.SLACK_THREAD_STEERING;
+    delete process.env.SLACK_THREAD_STEERING_MODE;
+    const channelId = "C_DEFAULT_STEER";
+    const threadTs = "1500.0001";
+    const task = await createRunningSlackTask(leadId, channelId, threadTs);
+    const result = await requestSlackThreadSteering({
+      channelId,
+      threadTs,
+      message: "new context",
+    });
+    expect(result).toMatchObject({
+      task: { id: task.id },
+      result: { outcome: "queued", effectiveMode: "queue" },
+    });
+    expect(await getSteeringMessagesForTask(task.id)).toHaveLength(1);
+    expect(await getChildTasks(task.id)).toEqual([]);
+  });
+
   test("lead mode sends one steering message to an in-progress lead and creates no task", async () => {
     process.env.SLACK_THREAD_STEERING = "lead";
     process.env.SLACK_THREAD_STEERING_MODE = "steer";