@desplega.ai/agent-swarm 1.108.0 → 1.108.2

package/src/http/poll.ts

@@ -16,6 +16,7 @@ import {
   getInboxSummary,
   getOfferedTasksForAgent,
   getPendingTaskForAgent,
+  getTaskAttachments,
   getTaskById,
   getUnassignedTaskIds,
   getUserById,
@@ -90,6 +91,23 @@ function getRequesterNotes(notes: string | undefined): string | undefined {
   return typeof notes === "string" && notes.trim().length > 0 ? notes : undefined;
 }
 
+/**
+ * Slim attachment projection for the `task_assigned` poll trigger — just
+ * enough (id, name, mimeType, sizeBytes) for the worker to build a one-shot
+ * `/api/fs/tasks/{taskId}/files/{id}/raw` fetch recipe into the dispatch
+ * prompt, without shipping the full capabilities/provider blob over poll.
+ */
+function attachmentsForTrigger(
+  taskId: string,
+): Array<{ id: string; name: string; mimeType?: string; sizeBytes?: number }> {
+  return getTaskAttachments(taskId).map((a) => ({
+    id: a.id,
+    name: a.name,
+    mimeType: a.mimeType,
+    sizeBytes: a.sizeBytes,
+  }));
+}
+
 // ─── Cursor Commit Endpoint ─────────────────────────────────────────────────
 
 const commitCursorsRoute = route({
@@ -266,7 +284,11 @@ export async function handlePoll(
               trigger: {
                 type: "task_assigned",
                 taskId: pendingTask.id,
-                task: { ...pendingTask, status: "in_progress" },
+                task: {
+                  ...pendingTask,
+                  status: "in_progress",
+                  attachments: attachmentsForTrigger(pendingTask.id),
+                },
                 ...(requestedByUser && {
                   requestedBy: {
                     name: requestedByUser.name,
@@ -381,7 +403,7 @@ export async function handlePoll(
                   trigger: {
                     type: "task_assigned",
                     taskId: claimed.id,
-                    task: claimed,
+                    task: { ...claimed, attachments: attachmentsForTrigger(claimed.id) },
                   },
                 };
               }

package/src/telemetry.ts

@@ -188,13 +188,23 @@ export function track(options: TrackOptions): void {
       actor_anonymous_id: installationId,
       properties: {
         ...(options.properties ?? {}),
-        // Cloud-cohort signal derived from MCP_BASE_URL at init time.
+        // Cloud-cohort signal. Two independent signals OR'd together:
+        // `cachedIsCloud` (MCP_BASE_URL points at a host we own, resolved at
+        // init time) catches self-host operators who point their swarm at
+        // our managed MCP endpoint; `isCloudDeployment()` (SWARM_CLOUD env
+        // var, read fresh) catches hosted Swarm Cloud deployments, whose
+        // MCP_BASE_URL is the intra-compose `http://api:3013` address and so
+        // never matches a cloud hostname on its own — SWARM_CLOUD=true is the
+        // signal those deployments actually carry (see agent-swarm-internal's
+        // .env.personalization). Growth reporting keys off this exact field
+        // (`properties_json.is_cloud` in ClickHouse), so both cohorts must
+        // resolve true here, not just in `metadata.is_cloud` below.
         // Placed at the top level of `properties_json` so ClickHouse can
         // GROUP BY without descending into nested objects. Spread LAST so
         // caller-supplied keys can never spoof the cohort classification.
         // The hostname is intentionally NOT included — telemetry must stay
         // anonymous, and the boolean is sufficient to split cloud vs self-host.
-        is_cloud: cachedIsCloud,
+        is_cloud: cachedIsCloud || isCloudDeployment(),
         is_e2b: cachedIsE2b,
         swarmVersion: pkg.version,
       },

package/src/tests/agent-fs-provision-seeder.test.ts

@@ -38,6 +38,12 @@ type RequestRecord = {
   hasSignal: boolean;
 };
 
+type StubMember = {
+  email?: string;
+  role?: string;
+  user?: { email?: string };
+};
+
 async function removeDbFiles(path: string): Promise<void> {
   for (const suffix of ["", "-wal", "-shm"]) {
     await unlink(path + suffix).catch(() => {});
@@ -58,7 +64,10 @@ function configValue(key: string): string | undefined {
   return getSwarmConfigs({ scope: "global", key })[0]?.value;
 }
 
-function createFetchStub(records: RequestRecord[]): typeof fetch {
+function createFetchStub(
+  records: RequestRecord[],
+  options: { members?: StubMember[] } = {},
+): typeof fetch {
   return (async (input, init) => {
     const url = new URL(String(input));
     const method = init?.method ?? "GET";
@@ -111,6 +120,9 @@ function createFetchStub(records: RequestRecord[]): typeof fetch {
     if (url.pathname === "/orgs/shared-org/drives" && method === "POST") {
       return Response.json({ id: "shared-drive", name: "shared" }, { status: 201 });
     }
+    if (url.pathname === "/orgs/shared-org/members" && method === "GET") {
+      return Response.json({ members: options.members ?? [] });
+    }
     if (url.pathname === "/orgs/shared-org/members/invite" && method === "POST") {
       return Response.json({ ok: true });
     }
@@ -160,8 +172,8 @@ describe("agent-fs provisioning seeder", () => {
     process.env.AGENT_FS_EMAIL_DOMAIN = "agents.example.test";
 
     createUser({
-      name: "Viewer User",
-      email: `viewer-${suffix}@example.test`,
+      name: "Designer User",
+      email: `designer-${suffix}@example.test`,
       role: "Customer",
     });
     createUser({
@@ -169,6 +181,11 @@ describe("agent-fs provisioning seeder", () => {
       email: `operator-${suffix}@example.test`,
       role: "Operator",
     });
+    createUser({
+      name: "Explicit Viewer User",
+      email: `viewer-${suffix}@example.test`,
+      role: "read-only contractor",
+    });
     const records: RequestRecord[] = [];
     setAgentFsProvisionFetchForTests(createFetchStub(records));
 
@@ -202,6 +219,7 @@ describe("agent-fs provisioning seeder", () => {
 
     expect(invites).toEqual(
       [
+        { email: `designer-${suffix}@example.test`, role: "editor" },
         { email: `operator-${suffix}@example.test`, role: "editor" },
         { email: `viewer-${suffix}@example.test`, role: "viewer" },
       ].sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b))),
@@ -215,6 +233,189 @@ describe("agent-fs provisioning seeder", () => {
     expect(records).toEqual([]);
   });
 
+  test("classifies arbitrary non-viewer human roles as agent-fs editors", async () => {
+    const suffix = crypto.randomUUID().slice(0, 8);
+    process.env.AGENT_FS_API_URL = "https://agent-fs.example.test/";
+    process.env.AGENT_FS_REGISTER_EMAIL = "admin@example.test";
+    upsertSwarmConfig({
+      scope: "global",
+      key: "API_AGENT_FS_API_KEY",
+      value: "afs-admin-key",
+      isSecret: true,
+    });
+    upsertSwarmConfig({
+      scope: "global",
+      key: "AGENT_FS_DEFAULT_ORG_ID",
+      value: "shared-org",
+    });
+    upsertSwarmConfig({
+      scope: "global",
+      key: "AGENT_FS_DEFAULT_DRIVE_ID",
+      value: "shared-drive",
+    });
+
+    createUser({
+      name: "Taras Founder",
+      email: `taras-founder-${suffix}@example.test`,
+      role: "co-founder, CTO",
+    });
+    createUser({
+      name: "Eze Founder",
+      email: `eze-founder-${suffix}@example.test`,
+      role: "co-founder, CEO",
+    });
+    createUser({
+      name: "Designer Human",
+      email: `designer-${suffix}@example.test`,
+      role: "designer",
+    });
+    createUser({
+      name: "Unknown Human",
+      email: `whatever-${suffix}@example.test`,
+      role: "whatever",
+    });
+
+    const records: RequestRecord[] = [];
+    setAgentFsProvisionFetchForTests(createFetchStub(records));
+
+    const result = await runSeeder(agentFsProvisionSeeder, { quiet: true });
+
+    expect(result.failed).toEqual([]);
+    const invites = records
+      .filter((r) => r.path === "/orgs/shared-org/members/invite")
+      .map((r) => r.body);
+    expect(invites).toContainEqual({
+      email: `taras-founder-${suffix}@example.test`,
+      role: "editor",
+    });
+    expect(invites).toContainEqual({
+      email: `eze-founder-${suffix}@example.test`,
+      role: "editor",
+    });
+    expect(invites).toContainEqual({
+      email: `designer-${suffix}@example.test`,
+      role: "editor",
+    });
+    expect(invites).toContainEqual({
+      email: `whatever-${suffix}@example.test`,
+      role: "editor",
+    });
+  });
+
+  test("classifies explicitly viewer human roles as agent-fs viewers", async () => {
+    const suffix = crypto.randomUUID().slice(0, 8);
+    process.env.AGENT_FS_API_URL = "https://agent-fs.example.test/";
+    process.env.AGENT_FS_REGISTER_EMAIL = "admin@example.test";
+    upsertSwarmConfig({
+      scope: "global",
+      key: "API_AGENT_FS_API_KEY",
+      value: "afs-admin-key",
+      isSecret: true,
+    });
+    upsertSwarmConfig({
+      scope: "global",
+      key: "AGENT_FS_DEFAULT_ORG_ID",
+      value: "shared-org",
+    });
+    upsertSwarmConfig({
+      scope: "global",
+      key: "AGENT_FS_DEFAULT_DRIVE_ID",
+      value: "shared-drive",
+    });
+
+    createUser({
+      name: "Viewer Human",
+      email: `viewer-${suffix}@example.test`,
+      role: "Viewer",
+    });
+    createUser({
+      name: "Read Only Human",
+      email: `read-only-${suffix}@example.test`,
+      role: "read only",
+    });
+    createUser({
+      name: "Guest Human",
+      email: `guest-${suffix}@example.test`,
+      role: "guest",
+    });
+
+    const records: RequestRecord[] = [];
+    setAgentFsProvisionFetchForTests(createFetchStub(records));
+
+    const result = await runSeeder(agentFsProvisionSeeder, { quiet: true });
+
+    expect(result.failed).toEqual([]);
+    const invites = records
+      .filter((r) => r.path === "/orgs/shared-org/members/invite")
+      .map((r) => r.body);
+    expect(invites).toContainEqual({
+      email: `viewer-${suffix}@example.test`,
+      role: "viewer",
+    });
+    expect(invites).toContainEqual({
+      email: `read-only-${suffix}@example.test`,
+      role: "viewer",
+    });
+    expect(invites).toContainEqual({
+      email: `guest-${suffix}@example.test`,
+      role: "viewer",
+    });
+  });
+
+  test("does not invite existing members when provisioning would keep or lower their role", async () => {
+    const suffix = crypto.randomUUID().slice(0, 8);
+    const existingAdmin = `existing-admin-${suffix}@example.test`;
+    const existingEditor = `existing-editor-${suffix}@example.test`;
+    const existingViewer = `existing-viewer-${suffix}@example.test`;
+    const explicitViewer = `explicit-viewer-${suffix}@example.test`;
+    process.env.AGENT_FS_API_URL = "https://agent-fs.example.test/";
+    process.env.AGENT_FS_REGISTER_EMAIL = "admin@example.test";
+    upsertSwarmConfig({
+      scope: "global",
+      key: "API_AGENT_FS_API_KEY",
+      value: "afs-admin-key",
+      isSecret: true,
+    });
+    upsertSwarmConfig({
+      scope: "global",
+      key: "AGENT_FS_DEFAULT_ORG_ID",
+      value: "shared-org",
+    });
+    upsertSwarmConfig({
+      scope: "global",
+      key: "AGENT_FS_DEFAULT_DRIVE_ID",
+      value: "shared-drive",
+    });
+
+    createUser({ name: "Existing Admin", email: existingAdmin, role: "Customer" });
+    createUser({ name: "Existing Editor", email: existingEditor, role: "Designer" });
+    createUser({ name: "Existing Viewer", email: existingViewer, role: "Whatever" });
+    createUser({ name: "Explicit Viewer", email: explicitViewer, role: "Guest" });
+
+    const records: RequestRecord[] = [];
+    setAgentFsProvisionFetchForTests(
+      createFetchStub(records, {
+        members: [
+          { email: existingAdmin, role: "admin" },
+          { user: { email: existingEditor }, role: "editor" },
+          { email: existingViewer, role: "viewer" },
+        ],
+      }),
+    );
+
+    const result = await runSeeder(agentFsProvisionSeeder, { quiet: true });
+
+    expect(result.failed).toEqual([]);
+    const inviteBodies = records
+      .filter((r) => r.path === "/orgs/shared-org/members/invite")
+      .map((r) => r.body);
+
+    expect(inviteBodies).not.toContainEqual({ email: existingAdmin, role: "editor" });
+    expect(inviteBodies).not.toContainEqual({ email: existingEditor, role: "editor" });
+    expect(inviteBodies).toContainEqual({ email: existingViewer, role: "editor" });
+    expect(inviteBodies).toContainEqual({ email: explicitViewer, role: "viewer" });
+  });
+
   test("provisions agent-scoped credentials through the API-owned bootstrap key", async () => {
     const suffix = crypto.randomUUID().slice(0, 8);
     process.env.AGENT_FS_API_URL = "https://agent-fs.example.test/";

package/src/tests/claude-adapter.test.ts

@@ -86,6 +86,16 @@ describe("ClaudeSession spawn env — reasoning_effort", () => {
   let spawnSpy: ReturnType<typeof spyOn>;
   let spawnedEnvs: Array<Record<string, string> | undefined>;
 
+  // `createSession`/`ClaudeSession` fall back to `process.env` when `config.env`
+  // is omitted, and spread it wholesale into the spawned process env. Two
+  // problems follow in a credential-less sandbox: (1) `validateClaudeCredentials`
+  // throws without CLAUDE_CODE_OAUTH_TOKEN/ANTHROPIC_API_KEY, and (2) any ambient
+  // env var sharing a name with what these tests assert on (CLAUDE_CODE_EFFORT_LEVEL,
+  // MAX_THINKING_TOKENS) would leak through and pollute the `toBeUndefined()`
+  // assertions. Passing an explicit, minimal `env` sidesteps both — deterministic
+  // regardless of the ambient process env the test happens to run in.
+  const CLEAN_ENV: Record<string, string> = { CLAUDE_CODE_OAUTH_TOKEN: "test-oauth-token" };
+
   beforeEach(() => {
     spawnedEnvs = [];
     spawnSpy = spyOn(Bun, "spawn").mockImplementation(((
@@ -103,7 +113,9 @@ describe("ClaudeSession spawn env — reasoning_effort", () => {
 
   test("reasoningEffort: 'high' on claude-opus-4-8 sets CLAUDE_CODE_EFFORT_LEVEL", async () => {
     const adapter = new ClaudeAdapter();
-    await adapter.createSession(makeConfig({ model: "claude-opus-4-8", reasoningEffort: "high" }));
+    await adapter.createSession(
+      makeConfig({ model: "claude-opus-4-8", reasoningEffort: "high", env: CLEAN_ENV }),
+    );
 
     expect(spawnedEnvs).toHaveLength(1);
     expect(spawnedEnvs[0]?.CLAUDE_CODE_EFFORT_LEVEL).toBe("high");
@@ -111,7 +123,9 @@ describe("ClaudeSession spawn env — reasoning_effort", () => {
 
   test("reasoningEffort: 'off' on a legacy budget_tokens-capable model sets MAX_THINKING_TOKENS=0, no effort env", async () => {
     const adapter = new ClaudeAdapter();
-    await adapter.createSession(makeConfig({ model: "claude-opus-4-0", reasoningEffort: "off" }));
+    await adapter.createSession(
+      makeConfig({ model: "claude-opus-4-0", reasoningEffort: "off", env: CLEAN_ENV }),
+    );
 
     expect(spawnedEnvs).toHaveLength(1);
     expect(spawnedEnvs[0]?.MAX_THINKING_TOKENS).toBe("0");
@@ -120,7 +134,7 @@ describe("ClaudeSession spawn env — reasoning_effort", () => {
 
   test("undefined reasoningEffort leaves spawn env unchanged (no effort/budget keys)", async () => {
     const adapter = new ClaudeAdapter();
-    await adapter.createSession(makeConfig({ model: "claude-opus-4-8" }));
+    await adapter.createSession(makeConfig({ model: "claude-opus-4-8", env: CLEAN_ENV }));
 
     expect(spawnedEnvs).toHaveLength(1);
     expect(spawnedEnvs[0]?.CLAUDE_CODE_EFFORT_LEVEL).toBeUndefined();

package/src/tests/fs-provider.test.ts

@@ -85,6 +85,40 @@ describe("LocalFsProvider", () => {
     }
   });
 
+  test("head() returns the real upload Content-Type, not an extension guess from the storage key", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "agent-swarm-fs-"));
+    try {
+      const provider = new LocalFsProvider({ rootDir });
+      // Storage key has no extension Bun can sniff correctly from — the JPEG bytes
+      // would otherwise be mis-reported (e.g. application/octet-stream or worse).
+      const scope = { taskId: "task-1", name: "attachment-blob" };
+
+      const uploaded = await provider.upload(scope, new Blob([new Uint8Array([1, 2, 3])]), {
+        contentType: "image/jpeg",
+      });
+      expect(uploaded.contentType).toBe("image/jpeg");
+
+      const head = await provider.head(scope);
+      expect(head.contentType).toBe("image/jpeg");
+
+      // copy() must carry the stored Content-Type forward too.
+      const copied = await provider.copy(scope, { taskId: "task-1", name: "attachment-copy" });
+      expect(copied.contentType).toBe("image/jpeg");
+
+      // The sidecar metadata file must not surface as a listed file.
+      const listed = await provider.list({ taskId: "task-1" });
+      expect(listed.map((item) => item.name).sort()).toEqual([
+        "attachment-blob",
+        "attachment-copy",
+      ]);
+
+      await provider.delete(scope);
+      expect(await provider.exists(scope)).toBe(false);
+    } finally {
+      await rm(rootDir, { recursive: true, force: true });
+    }
+  });
+
   test("signedUploadUrl throws a normalized ReadOnly error", async () => {
     const provider = new LocalFsProvider({
       rootDir: await mkdtemp(join(tmpdir(), "agent-swarm-fs-")),

package/src/tests/http-api-integration.test.ts

@@ -860,6 +860,57 @@ describe("Polling", () => {
     expect(status).toBe(200);
     expect(body).toBeDefined();
   });
+
+  test("GET /api/poll — task_assigned trigger carries a slim attachments projection", async () => {
+    // Dedicated agent + task so this doesn't race other tests' fixtures for
+    // the shared worker agents.
+    const attachAgent = randomUUID();
+    const registered = await post("/api/agents", {
+      agentId: attachAgent,
+      body: { name: "AttachmentPollWorker" },
+    });
+    expect(registered.status).toBe(201);
+
+    const created = await post("/api/tasks", {
+      agentId: ids.leadAgent,
+      body: { task: "Task with an attachment", agentId: attachAgent },
+    });
+    expect(created.status).toBe(201);
+    const taskId = created.body.id as string;
+
+    // Upload via the real provider-agnostic route (same one PR #850 added) —
+    // this is the endpoint the injected fetch recipe below points at.
+    const upload = await fetch(`${BASE}/api/fs/tasks/${taskId}/files?name=IMG_1357.jpeg`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${TEST_API_KEY}`,
+        "x-agent-id": ids.leadAgent,
+        "Content-Type": "image/jpeg",
+      },
+      body: Buffer.from("fake-jpeg-bytes"),
+    });
+    expect(upload.status).toBe(201);
+    const attachment = await upload.json();
+
+    const { status, body } = await get("/api/poll", { agentId: attachAgent });
+    expect(status).toBe(200);
+    expect(body.trigger?.type).toBe("task_assigned");
+    expect(body.trigger?.taskId).toBe(taskId);
+
+    const attachments = body.trigger?.task?.attachments;
+    expect(attachments).toHaveLength(1);
+    expect(attachments[0].id).toBe(attachment.id);
+    expect(attachments[0].name).toBe("IMG_1357.jpeg");
+    // NOTE: mimeType is whatever the provider's head() reports, which has a
+    // known pre-existing bug (local-fs infers it from the storage key rather
+    // than the upload's real Content-Type) — not asserted here, out of scope
+    // for this fix. What matters for the attachment-read fix is id/name.
+    expect(attachments[0].mimeType).toBe(attachment.mimeType);
+    // Slim projection — no need to ship the full capabilities/provider blob
+    // over every poll response.
+    expect(attachments[0]).not.toHaveProperty("capabilities");
+    expect(attachments[0]).not.toHaveProperty("providerKey");
+  });
 });
 
 // ===========================================================================

package/src/tests/prompt-template-remaining.test.ts

@@ -393,6 +393,31 @@ describe("Runner triggers — backward compatibility", () => {
 
 Task: "Fix the bug"
 
+When done, use \`store-progress\` with status: "completed" and include your output.`;
+
+    expect(result.text).toBe(expected);
+  });
+
+  test("task.trigger.assigned threads attachments_section between task_desc_section and output_instructions", () => {
+    const result = resolveTemplate("task.trigger.assigned", {
+      work_on_task_cmd: "/work-on-task",
+      task_id: "abc123",
+      task_desc_section: '\n\nTask: "Read the attached file"',
+      attachments_section:
+        "\n\n📎 Attachment(s) — fetch directly, no need to discover the storage path yourself:\n- IMG_1357.jpeg: `curl ...`",
+      output_instructions:
+        '\n\nWhen done, use `store-progress` with status: "completed" and include your output.',
+    });
+
+    expect(result.skipped).toBe(false);
+
+    const expected = `/work-on-task abc123
+
+Task: "Read the attached file"
+
+📎 Attachment(s) — fetch directly, no need to discover the storage path yourself:
+- IMG_1357.jpeg: \`curl ...\`
+
 When done, use \`store-progress\` with status: "completed" and include your output.`;
 
     expect(result.text).toBe(expected);

package/src/tests/runner-attachments-section.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, test } from "bun:test";
+import { buildAttachmentsSection } from "../commands/runner";
+
+describe("buildAttachmentsSection", () => {
+  test("returns empty string when there are no attachments", () => {
+    expect(buildAttachmentsSection("task-1", undefined)).toBe("");
+    expect(buildAttachmentsSection("task-1", null)).toBe("");
+    expect(buildAttachmentsSection("task-1", [])).toBe("");
+  });
+
+  test("returns empty string when taskId is missing", () => {
+    expect(buildAttachmentsSection(undefined, [{ id: "att-1", name: "photo.jpeg" }])).toBe("");
+  });
+
+  test("builds a one-shot curl recipe against the provider-agnostic raw route", () => {
+    const section = buildAttachmentsSection("task-123", [
+      { id: "att-1", name: "IMG_1357.jpeg", mimeType: "image/jpeg", sizeBytes: 2816227 },
+    ]);
+
+    expect(section).toContain("IMG_1357.jpeg");
+    expect(section).toContain("image/jpeg, 2816227 bytes");
+    expect(section).toContain(
+      '$MCP_BASE_URL/api/fs/tasks/task-123/files/att-1/raw" -o /tmp/IMG_1357.jpeg',
+    );
+    // No org/drive discovery should be required — the whole point of the fix.
+    expect(section).not.toContain("agent-fs");
+    expect(section).toContain("X-Agent-ID: $AGENT_ID");
+    expect(section).toContain("Authorization: Bearer ");
+    expect(section).toContain("AGENT_SWARM_API_KEY:-$API_KEY");
+  });
+
+  test("handles multiple attachments, one line each", () => {
+    const section = buildAttachmentsSection("task-123", [
+      { id: "att-1", name: "a.png" },
+      { id: "att-2", name: "b.pdf" },
+    ]);
+
+    const lines = section.split("\n").filter((l) => l.startsWith("- "));
+    expect(lines).toHaveLength(2);
+    expect(lines[0]).toContain("a.png");
+    expect(lines[1]).toContain("b.pdf");
+  });
+
+  test("skips malformed attachment entries without throwing", () => {
+    const section = buildAttachmentsSection("task-123", [
+      { id: "att-1" }, // missing name — id used as fallback name
+      { name: "no-id.txt" }, // missing id — dropped
+      "not-an-object",
+      null,
+    ]);
+
+    expect(section).toContain("att-1");
+    expect(section).not.toContain("no-id.txt");
+  });
+});

package/src/tests/telemetry-init.test.ts

@@ -457,6 +457,29 @@ describe("initTelemetry", () => {
       expect(properties.mcp_host).toBeUndefined();
     });
 
+    test("hosted Swarm Cloud shape (intra-compose MCP_BASE_URL + SWARM_CLOUD=true) → properties.is_cloud=true", async () => {
+      // Mirrors agent-swarm-internal's Hetzner compose template: MCP_BASE_URL
+      // is the intra-compose service address (never a cloud hostname), and
+      // SWARM_CLOUD=true is seeded via .env.personalization. The hostname
+      // heuristic alone would misclassify this as self-host.
+      process.env.MCP_BASE_URL = "http://api:3013";
+      process.env.SWARM_CLOUD = "true";
+      await initTelemetry(
+        "api-server",
+        async () => "install_hosted_cloud_test",
+        async () => {},
+      );
+
+      track({ event: "server.started", properties: { port: 3013 } });
+      await new Promise((r) => setTimeout(r, 0));
+
+      const properties = (captured as { properties: Record<string, unknown> }).properties;
+      expect(properties.is_cloud).toBe(true);
+      expect(properties.mcp_host).toBeUndefined();
+
+      delete process.env.SWARM_CLOUD;
+    });
+
     test("caller properties cannot override is_cloud", async () => {
       // Defense-in-depth: even if a caller passes through user-supplied
       // values, the cohort signal shipped on every event must come from