@desplega.ai/agent-swarm 1.173.0 → 2.1.0

package/src/tests/skill-invocations.test.ts

@@ -78,6 +78,7 @@ afterAll(async () => {
 });
 
 describe("migration 196 skill invocations", () => {
+  // The full migration chain on a fresh DB can be slow under CI shard load.
   test("fresh DB has the counter columns and the invocations table", () => {
     const db = new Database(MIGRATION_DB_PATH, { create: true });
     try {
@@ -109,8 +110,9 @@ describe("migration 196 skill invocations", () => {
     } finally {
       db.close();
     }
-  });
+  }, 30_000);
 
+  // The full migration chain on a fresh DB can be slow under CI shard load.
   test("existing DB keeps its skills and starts them at zero", async () => {
     await removeDb(MIGRATION_DB_PATH);
     const db = new Database(MIGRATION_DB_PATH, { create: true });
@@ -143,7 +145,7 @@ describe("migration 196 skill invocations", () => {
     } finally {
       db.close();
     }
-  });
+  }, 30_000);
 });
 
 describe("skill.invoke ingestion", () => {

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

@@ -192,6 +192,42 @@ describe("buildCompletedBlocks", () => {
   });
 });
 
+describe("completed status icon override", () => {
+  test("buildCompletedBlocks and tree lines use SLACK_STATUS_ICON_COMPLETED", () => {
+    process.env.SLACK_STATUS_ICON_COMPLETED = "bee-lgtm";
+    try {
+      const card = buildCompletedBlocks({
+        agentName: "Alpha",
+        taskId: "abcdef12-3456-7890-abcd-ef1234567890",
+        body: "Task output here",
+      });
+      expect(card[0].text.text.startsWith(":bee-lgtm: *Alpha*")).toBe(true);
+
+      const tree = buildTreeBlocks([
+        {
+          taskId: makeTaskId("icon0001"),
+          agentName: "Lead",
+          status: "completed",
+          children: [
+            {
+              taskId: makeTaskId("icon0002"),
+              agentName: "Worker",
+              status: "failed",
+              children: [],
+            },
+          ],
+        },
+      ]);
+      const text = tree[0].text.text;
+      expect(text).toContain(":bee-lgtm: *Lead*");
+      expect(text).toContain("❌ *Worker*");
+      expect(text).not.toContain("✅");
+    } finally {
+      delete process.env.SLACK_STATUS_ICON_COMPLETED;
+    }
+  });
+});
+
 describe("buildFailedBlocks", () => {
   test("returns single-line header + error section", () => {
     const blocks = buildFailedBlocks({

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

@@ -71,4 +71,18 @@ describe("Slack inline completion output", () => {
     expect(text).toContain("|`abcdef12`>");
     expect(text).toContain(finalMarker);
   });
+
+  test("the inline output header uses SLACK_STATUS_ICON_COMPLETED", () => {
+    process.env.SLACK_STATUS_ICON_COMPLETED = ":bee-lgtm:";
+    try {
+      const [first] = formatInlineCompletionOutputChunks({
+        agentName: "Analyst",
+        taskId: TASK_ID,
+        output: "Done.",
+      });
+      expect(first?.startsWith(":bee-lgtm: *Analyst* completed with output")).toBe(true);
+    } finally {
+      delete process.env.SLACK_STATUS_ICON_COMPLETED;
+    }
+  });
 });

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

@@ -2,6 +2,7 @@ import { afterAll, beforeEach, describe, expect, spyOn, test } from "bun:test";
 import * as otelModule from "../otel";
 import { ackSlackMessage, finalizeSlackMessageReaction } from "../slack/ack";
 import {
+  completedStatusIcon,
   normalizeSlackReactionShortcode,
   reactionName,
   SLACK_REACTION_CONFIG_KEYS,
@@ -114,6 +115,25 @@ describe("reaction-shortcode.ts", () => {
     expect(normalizeSlackReactionShortcode("thumbsup::skin-tone-6::skin-tone-6")).toBeNull();
   });
 
+  test("completedStatusIcon defaults to ✅ and renders a configured name as :name:", () => {
+    const previous = process.env.SLACK_STATUS_ICON_COMPLETED;
+    try {
+      delete process.env.SLACK_STATUS_ICON_COMPLETED;
+      expect(completedStatusIcon()).toBe("✅");
+      for (const value of ["bee-lgtm", ":bee-lgtm:", "  :Bee-LGTM: "]) {
+        process.env.SLACK_STATUS_ICON_COMPLETED = value;
+        expect(completedStatusIcon()).toBe(":bee-lgtm:");
+      }
+      for (const bad of ["", "::", "bee lgtm", "✅", "bee:lgtm"]) {
+        process.env.SLACK_STATUS_ICON_COMPLETED = bad;
+        expect(completedStatusIcon()).toBe("✅");
+      }
+    } finally {
+      if (previous === undefined) delete process.env.SLACK_STATUS_ICON_COMPLETED;
+      else process.env.SLACK_STATUS_ICON_COMPLETED = previous;
+    }
+  });
+
   test("no Slack source file outside ack.ts names a reaction shortcode or calls reactions.add", async () => {
     const glob = new Bun.Glob("*.ts");
     const dir = new URL("../slack/", import.meta.url);

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

@@ -1116,6 +1116,43 @@ describe("Slack renderer v2", () => {
     expect(doneText.startsWith("🧵 ✅ done")).toBe(true);
   });
 
+  test("the completed glyph follows SLACK_STATUS_ICON_COMPLETED in tree, header and cards", async () => {
+    const lead = await createAgent({ name: "Icon Lead", isLead: true, status: "idle" });
+    const ask = await createTaskExtended("icon ask", { agentId: lead.id, source: "slack" });
+    const now = new Date();
+    const done = {
+      ...ask,
+      status: "completed" as const,
+      output: "Shipped.",
+      lastUpdatedAt: now.toISOString(),
+      finishedAt: now.toISOString(),
+    };
+
+    const defaultTree = await renderThreadTree([done], new Map(), now);
+    expect(defaultTree.startsWith("🧵 ✅ done")).toBe(true);
+    expect(defaultTree).toContain("↳ ✅ ");
+    expect(await childOutcomeContent(done, false)).toBe("↳ ✅ Icon Lead — result: Shipped.");
+
+    process.env.SLACK_STATUS_ICON_COMPLETED = ":bee-lgtm:";
+    try {
+      const tree = await renderThreadTree([done], new Map(), now);
+      expect(tree.startsWith("🧵 :bee-lgtm: done")).toBe(true);
+      expect(tree).toContain("↳ :bee-lgtm: ");
+      expect(tree).not.toContain("✅");
+      expect(await childOutcomeContent(done, false)).toBe(
+        "↳ :bee-lgtm: Icon Lead — result: Shipped.",
+      );
+      expect(await childOutcomeContent(done, true)).toBe("↳ :bee-lgtm: Icon Lead completed");
+
+      // Only the completed glyph moves; failure keeps its own icon.
+      expect(
+        await childOutcomeContent({ ...done, status: "failed", failureReason: "boom" }, false),
+      ).toBe("↳ ❌ Icon Lead — failed: boom");
+    } finally {
+      delete process.env.SLACK_STATUS_ICON_COMPLETED;
+    }
+  });
+
   test("a parked deferral reads waiting, and done once its wake-up settles", async () => {
     const lead = await createAgent({ name: "Parked Header Lead", isLead: true, status: "idle" });
     const ask = await createTaskExtended("parked header ask", {

package/src/tests/slack-thread-buffer.test.ts

@@ -1,16 +1,21 @@
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { afterAll, beforeAll, beforeEach, describe, expect, spyOn, test } from "bun:test";
 import { unlinkSync } from "node:fs";
 import {
   closeDb,
   createAgent,
   createTaskExtended,
   createUser,
+  getDbClient,
   getLatestActiveTaskInThread,
   getMostRecentTaskInThread,
   getSlackTasksInThread,
   initDb,
 } from "../be/db";
+import { installExtension, setExtensionState } from "../be/extensions/db";
 import { type IdentityActor, linkIdentity } from "../be/users";
+import { registerLoaded, unregister } from "../extensions/dispatcher";
+import { ensureExtensionAgent } from "../extensions/identity";
+import { cleanExtensionTmpRoot, loadExtension } from "../extensions/loader";
 import { registerMessageHandler } from "../slack/handlers";
 import {
   bufferThreadMessage,
@@ -18,6 +23,7 @@ import {
   instantFlush,
   isThreadBuffered,
 } from "../slack/thread-buffer";
+import { loadBundleFixture } from "./fixtures/extensions/load";
 
 process.env.SLACK_RENDER_V2 = "false";
 
@@ -73,6 +79,27 @@ afterAll(() => {
   }
 });
 
+async function loadBlockingExtension(reason: string) {
+  const bundle = await loadBundleFixture("minimal");
+  const name = "slack-buffer-block-test";
+  bundle.manifest = { ...bundle.manifest, name };
+  bundle.files[bundle.manifest.assets.hooks] = `
+import { block, type SwarmExtension } from "swarm-extension";
+const extension: SwarmExtension = (api) => {
+  api.on("pre.task.create", () => block(${JSON.stringify(reason)}));
+};
+export default extension;
+`;
+  const installed = await installExtension(bundle);
+  const record = await setExtensionState(installed.extension.id, {
+    agentId: await ensureExtensionAgent(name),
+  });
+  if (!record) throw new Error("Failed to load the blocking Slack test extension");
+  const loaded = await loadExtension({ record, ...bundle });
+  registerLoaded(loaded);
+  return loaded;
+}
+
 describe("Slack thread buffer", () => {
   describe("ADDITIVE_SLACK thread ingress", () => {
     const originalAdditiveSlack = process.env.ADDITIVE_SLACK;
@@ -612,4 +639,74 @@ describe("Slack thread buffer", () => {
       expect(task!.task).toContain("solo message");
     });
   });
+
+  test(
+    "logs a blocked pre-task.create once at info level with its reason scrubbed",
+    async () => {
+      const secret = `ghp_${"Z".repeat(36)}`;
+      const extensionName = "slack-buffer-block-test";
+      const loaded = await loadBlockingExtension(`Ticket required: ${secret}`);
+      const info = spyOn(console, "info").mockImplementation(() => {});
+      const error = spyOn(console, "error").mockImplementation(() => {});
+      const channelId = "C_BLOCKED_FLUSH";
+      const threadTs = "14000.0001";
+
+      try {
+        bufferThreadMessage(channelId, threadTs, "follow-up", "U1", "14000.0002");
+        await instantFlush(`${channelId}:${threadTs}`);
+
+        expect(info).toHaveBeenCalledTimes(1);
+        expect(info.mock.calls[0]?.[0]).toBe("[Slack] pre.task.create blocked:");
+        expect(info.mock.calls[0]?.[1]).toBe(extensionName);
+        expect(String(info.mock.calls[0]?.[2])).toContain("[REDACTED:");
+        expect(String(info.mock.calls[0]?.[2])).not.toContain(secret);
+        expect(error).not.toHaveBeenCalled();
+        expect(await getMostRecentTaskInThread(channelId, threadTs)).toBeNull();
+      } finally {
+        unregister(loaded.record.id);
+        await loaded.dispose();
+        info.mockRestore();
+        error.mockRestore();
+        await cleanExtensionTmpRoot();
+      }
+    },
+    { timeout: 15_000 },
+  );
+
+  test(
+    "does not treat unexpected task creation errors as blocked",
+    async () => {
+      const triggerName = "fail_slack_buffer_task_creation";
+      const failure = "simulated Slack task creation failure";
+      const channelId = "C_UNEXPECTED_FLUSH";
+      const threadTs = "14000.0003";
+      const info = spyOn(console, "info").mockImplementation(() => {});
+      const error = spyOn(console, "error").mockImplementation(() => {});
+
+      try {
+        await getDbClient().run(`DROP TRIGGER IF EXISTS ${triggerName}`);
+        await getDbClient().run(`
+          CREATE TRIGGER ${triggerName}
+          BEFORE INSERT ON agent_tasks
+          WHEN NEW.slackChannelId = '${channelId}'
+          BEGIN
+            SELECT RAISE(ABORT, '${failure}');
+          END
+        `);
+
+        bufferThreadMessage(channelId, threadTs, "follow-up", "U1", "14000.0004");
+        await instantFlush(`${channelId}:${threadTs}`);
+
+        expect(info).not.toHaveBeenCalled();
+        expect(error).toHaveBeenCalledTimes(1);
+        expect(String(error.mock.calls[0]?.[1])).toContain(failure);
+        expect(await getMostRecentTaskInThread(channelId, threadTs)).toBeNull();
+      } finally {
+        await getDbClient().run(`DROP TRIGGER IF EXISTS ${triggerName}`);
+        info.mockRestore();
+        error.mockRestore();
+      }
+    },
+    { timeout: 15_000 },
+  );
 });

package/src/tests/sonnet-5-5-registry.test.ts

@@ -23,10 +23,11 @@ describe("Sonnet 5.5 registry", () => {
             .filter((row) => row.provider === provider && row.model === model)
             .map((row) => [row.tokenClass, row.pricePerMillionUsd]),
         );
+        // Sonnet 5.5 cache hits cost 0.05x input, not the usual 0.1x.
         expect(rates).toEqual({
           input: 2,
           output: 10,
-          cached_input: 0.2,
+          cached_input: 0.1,
           cache_write: 2.5,
           cache_write_1h: 4,
         });
@@ -41,4 +42,11 @@ describe("Sonnet 5.5 registry", () => {
       ).toBe(2);
     }
   });
+
+  test("the shortname fallback seeds the same cache-read rate when the snapshot lacks the model", () => {
+    const row = buildModelsDevSeedRows({ anthropic: { models: {} } }).find(
+      (r) => r.provider === "claude" && r.model === "sonnet" && r.tokenClass === "cached_input",
+    );
+    expect(row?.pricePerMillionUsd).toBe(0.1);
+  });
 });

package/src/tests/swarm-config-export-to-env.test.ts

@@ -0,0 +1,267 @@
+import { Database } from "bun:sqlite";
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { unlink } from "node:fs/promises";
+import { createServer as createHttpServer, type Server } from "node:http";
+import { closeDb, createAgent, getSwarmConfigs, initDb, upsertSwarmConfig } from "../be/db";
+import { handleConfig } from "../http/config";
+import { getPathSegments, parseQueryParams } from "../http/utils";
+import { registerSetConfigTool } from "../tools/swarm-config/set-config";
+import { ENV_EXPORT_RESTRICTED_KEYS, envExportRestrictedError } from "../utils/config-env-export";
+import { setRequestAuth } from "../utils/request-auth-context";
+import { clearVolatileSecretsForTesting } from "../utils/secret-scrubber";
+import { listenOnFreePort } from "./test-net";
+
+const TEST_DB_PATH = "./test-swarm-config-export-to-env.sqlite";
+const LEAD_ID = "21111111-1111-1111-1111-111111111111";
+const MIGRATION = "src/be/migrations/215_swarm_config_export_to_env.sql";
+
+type ToolHandler = (args: unknown, meta: unknown) => Promise<unknown> | unknown;
+
+class MockMcpServer {
+  handlers = new Map<string, ToolHandler>();
+  registerTool(name: string, _config: unknown, handler: ToolHandler) {
+    this.handlers.set(name, handler);
+    return { name };
+  }
+}
+
+const requestInfo = {
+  sessionId: "test-session",
+  requestInfo: { headers: { "x-agent-id": LEAD_ID } },
+};
+
+describe("swarm_config exportToEnv", () => {
+  let server: Server;
+  let baseUrl = "";
+  const mcpServer = new MockMcpServer();
+
+  beforeAll(async () => {
+    initDb(TEST_DB_PATH);
+    await createAgent({
+      id: LEAD_ID,
+      name: "export-to-env-test-lead",
+      isLead: true,
+      status: "idle",
+      capabilities: [],
+    });
+    registerSetConfigTool(mcpServer as unknown as Parameters<typeof registerSetConfigTool>[0]);
+    server = createHttpServer(async (req, res) => {
+      setRequestAuth(req, { kind: "operator", fingerprint: "test" });
+      const handled = await handleConfig(
+        req,
+        res,
+        getPathSegments(req.url || ""),
+        parseQueryParams(req.url || ""),
+      );
+      if (!handled) {
+        res.writeHead(404);
+        res.end();
+      }
+    });
+    baseUrl = `http://localhost:${await listenOnFreePort(server)}`;
+  });
+
+  afterAll(async () => {
+    clearVolatileSecretsForTesting();
+    server.close();
+    closeDb();
+    for (const suffix of ["", "-wal", "-shm"]) {
+      await unlink(`${TEST_DB_PATH}${suffix}`).catch(() => {});
+    }
+  });
+
+  test("new rows export by default; an update without the flag keeps it", async () => {
+    const created = await upsertSwarmConfig({ scope: "global", key: "EXPORT_A", value: "1" });
+    expect(created.exportToEnv).toBe(true);
+
+    const off = await upsertSwarmConfig({
+      scope: "global",
+      key: "EXPORT_A",
+      value: "2",
+      isSecret: true,
+      exportToEnv: false,
+    });
+    expect(off.exportToEnv).toBe(false);
+
+    const kept = await upsertSwarmConfig({
+      scope: "global",
+      key: "EXPORT_A",
+      value: "3",
+      isSecret: true,
+    });
+    expect(kept.exportToEnv).toBe(false);
+
+    const on = await upsertSwarmConfig({
+      scope: "global",
+      key: "EXPORT_A",
+      value: "4",
+      exportToEnv: true,
+    });
+    expect(on.exportToEnv).toBe(true);
+  });
+
+  test("default-off keys start off on create but accept an explicit true", async () => {
+    const created = await upsertSwarmConfig({
+      scope: "global",
+      key: "KAPSO_WEBHOOK_HMAC_SECRET",
+      value: "k",
+      isSecret: true,
+    });
+    expect(created.exportToEnv).toBe(false);
+
+    const optedIn = await upsertSwarmConfig({
+      scope: "global",
+      key: "X_CLIENT_SECRET",
+      value: "x",
+      isSecret: true,
+      exportToEnv: true,
+    });
+    expect(optedIn.exportToEnv).toBe(true);
+  });
+
+  test("restricted keys store false and reject true through DB, HTTP, and MCP", async () => {
+    const key = "SLACK_SIGNING_SECRET";
+    const stored = await upsertSwarmConfig({ scope: "global", key, value: "s", isSecret: true });
+    expect(stored.exportToEnv).toBe(false);
+    const connection = await upsertSwarmConfig({
+      scope: "global",
+      key: "connection.example.secret",
+      value: "s",
+      isSecret: true,
+    });
+    expect(connection.exportToEnv).toBe(false);
+
+    const body = { scope: "global" as const, key, value: "s", isSecret: true, exportToEnv: true };
+    await expect(upsertSwarmConfig(body)).rejects.toThrow(envExportRestrictedError(key));
+
+    const res = await fetch(`${baseUrl}/api/config`, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+    expect(res.status).toBe(400);
+    expect(await res.json()).toMatchObject({ error: envExportRestrictedError(key) });
+
+    const result = (await mcpServer.handlers.get("set-config")!(body, requestInfo)) as {
+      structuredContent: { success: boolean; message: string };
+    };
+    expect(result.structuredContent.success).toBe(false);
+    expect(result.structuredContent.message).toBe(envExportRestrictedError(key));
+
+    const [row] = await getSwarmConfigs({ key });
+    expect(row?.exportToEnv).toBe(false);
+  });
+
+  test("the config API and /api/config/resolved carry the flag", async () => {
+    const put = await fetch(`${baseUrl}/api/config`, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        scope: "global",
+        key: "EXPORT_B",
+        value: "b",
+        isSecret: true,
+        exportToEnv: false,
+      }),
+    });
+    expect(put.status).toBe(200);
+    expect(await put.json()).toMatchObject({ key: "EXPORT_B", exportToEnv: false });
+
+    const resolved = await fetch(`${baseUrl}/api/config/resolved?key=EXPORT_B`);
+    const { configs } = (await resolved.json()) as {
+      configs: Array<{ key: string; exportToEnv: boolean }>;
+    };
+    expect(configs).toEqual([expect.objectContaining({ key: "EXPORT_B", exportToEnv: false })]);
+  });
+
+  test("set-config accepts the flag and keeps it on a later write", async () => {
+    const handler = mcpServer.handlers.get("set-config")!;
+    await handler(
+      { scope: "global", key: "EXPORT_C", value: "c", isSecret: true, exportToEnv: false },
+      requestInfo,
+    );
+    await handler({ scope: "global", key: "EXPORT_C", value: "c2", isSecret: true }, requestInfo);
+    const [row] = await getSwarmConfigs({ key: "EXPORT_C" });
+    expect(row?.exportToEnv).toBe(false);
+  });
+});
+
+describe("migration 215", () => {
+  // Keys agents read from their own env today (PR #2156 review audit, plus
+  // harness, git and agent-fs credentials). None may land on the deny list.
+  const MUST_STAY_EXPORTED = [
+    "AGENTMAIL_API_KEY",
+    "ATTIO_API_KEY",
+    "DOKPLOY_API_KEY",
+    "ELEVENLABS_API_KEY",
+    "EXA_API_KEY",
+    "GSC_SERVICE_ACCOUNT_BASE64",
+    "HETZNER_API_KEY",
+    "IMGFLIP_PASSWORD",
+    "IMGFLIP_USERNAME",
+    "KAPSO_API_KEY",
+    "PLAUSIBLE_API_KEY",
+    "SPRITES_API_KEY",
+    "SUPERAGENT_API_KEY",
+    "TURSO_API_TOKEN",
+    "TURSO_DB_TOKEN",
+    "TURSO_X_POSTS_DB_TOKEN",
+    "WORKDIR_API_KEY",
+    "X_ACCESS_TOKEN",
+    "X_ACCESS_TOKEN_SECRET",
+    "X_API_KEY",
+    "X_API_SECRET",
+    "X_BEARER_TOKEN",
+    "CLAUDE_CODE_OAUTH_TOKEN",
+    "OPENROUTER_API_KEY",
+    "GITHUB_TOKEN",
+    "AGENT_FS_API_KEY",
+    "SLACK_BOT_TOKEN",
+    "SELF_DRIVING_WEBHOOK_SECRET",
+    "DESPLEGA_PROD_DATABASE_URL",
+    "GWS_CREDS_BASE64",
+    "codex_oauth_1",
+  ];
+  const DENY_ONLY = [
+    "KAPSO_WEBHOOK_HMAC_SECRET",
+    "SENTRY_TEST_APP_WEBHOOK_SECRET",
+    "TELEMETRY_CH_AUTH",
+    "HACK_AGENT_FS_ADMIN_KEY",
+    "X_CLIENT_SECRET",
+    "connection.example.secret",
+  ];
+
+  test("backfills true and turns off only the deny list", () => {
+    const db = new Database(":memory:");
+    try {
+      db.exec(`CREATE TABLE swarm_config (
+        id TEXT PRIMARY KEY, scope TEXT NOT NULL, scopeId TEXT, key TEXT NOT NULL,
+        value TEXT NOT NULL, isSecret INTEGER NOT NULL DEFAULT 0, envPath TEXT,
+        description TEXT, createdAt TEXT NOT NULL, lastUpdatedAt TEXT NOT NULL,
+        encrypted INTEGER NOT NULL DEFAULT 0)`);
+      const insert = db.prepare(
+        "INSERT INTO swarm_config (id, scope, key, value, isSecret, createdAt, lastUpdatedAt) VALUES (?, 'global', ?, 'v', 1, 'now', 'now')",
+      );
+      const keys = [...MUST_STAY_EXPORTED, ...DENY_ONLY, ...ENV_EXPORT_RESTRICTED_KEYS];
+      for (const key of keys) insert.run(crypto.randomUUID(), key);
+
+      db.exec(readFileSync(MIGRATION, "utf8"));
+
+      const flags = Object.fromEntries(
+        db
+          .query<{ key: string; exportToEnv: number }, []>(
+            "SELECT key, exportToEnv FROM swarm_config",
+          )
+          .all()
+          .map((row) => [row.key, row.exportToEnv]),
+      );
+      for (const key of MUST_STAY_EXPORTED) expect([key, flags[key]]).toEqual([key, 1]);
+      for (const key of [...DENY_ONLY, ...ENV_EXPORT_RESTRICTED_KEYS]) {
+        expect([key, flags[key]]).toEqual([key, 0]);
+      }
+    } finally {
+      db.close();
+    }
+  });
+});

package/src/tests/swarm-config-reserved-keys.test.ts

@@ -6,6 +6,7 @@ import {
   createAgent,
   deleteSwarmConfig,
   getDbClient,
+  getInjectableGlobalConfigs,
   getSwarmConfigById,
   getSwarmConfigs,
   initDb,
@@ -94,6 +95,20 @@ function createTestServer(): Server {
   });
 }
 
+describe("Teams SDK env fallbacks", () => {
+  test("a global SERVICE_URL row is storable but never injected into env", async () => {
+    await upsertSwarmConfig({ scope: "global", key: "SERVICE_URL", value: "https://evil.example" });
+    try {
+      expect((await getSwarmConfigs({ scope: "global", key: "SERVICE_URL" })).length).toBe(1);
+      const injectable = await getInjectableGlobalConfigs();
+      expect(injectable.some((config) => config.key === "SERVICE_URL")).toBe(false);
+    } finally {
+      const rows = await getSwarmConfigs({ scope: "global", key: "SERVICE_URL" });
+      for (const row of rows) await deleteSwarmConfig(row.id);
+    }
+  });
+});
+
 describe("swarm-config reserved keys guard", () => {
   let server: Server;
   let baseUrl = "";
@@ -139,6 +154,7 @@ describe("swarm-config reserved keys guard", () => {
     "cors_allow_any_origin",
     "EXTENSION_ALLOW_LEAD_ACTIVATION",
     "extension_allow_lead_activation",
+    "CHAT_SDK_API_URL_OVERRIDES",
   ]) {
     test(`rejects deployment-only ${key} through DB, HTTP, and MCP`, async () => {
       const config = { scope: "global" as const, key, value: "true" };

package/src/tests/swarm-diff.test.ts

@@ -8,7 +8,7 @@
  * anchor ids, severity badges) without dragging in a real DOM lib.
  */
 import { describe, expect, test } from "bun:test";
-import { SWARM_UI_JS } from "../artifact-sdk/browser-sdk";
+import { SWARM_UI_JS } from "../pages/browser-sdk";
 
 const EXAMPLE_HUNK = {
   hunks: [