@desplega.ai/agent-swarm 2.4.0 → 2.4.1

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

@@ -1,11 +1,13 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { unlink } from "node:fs/promises";
-import { closeDb, createUser, initDb } from "../be/db";
+import { closeDb, createUser, getDbClient, initDb, updateUser, upsertSwarmConfig } from "../be/db";
 import { attachRole, detachRole } from "../be/rbac-roles";
+import { loadGlobalConfigsIntoEnv } from "../http/core";
 import {
   _getOrgIdForTests,
   _resetTelemetryStateForTests,
   initTelemetry,
+  setTelemetryFunctionResolver,
   setTelemetryOrgDomain,
   track,
 } from "../telemetry";
@@ -19,12 +21,22 @@ import {
   validOrgDomain,
   validOrgId,
 } from "../telemetry-context";
-import { _resetTelemetryIdentityForTests, computeOrgDomain } from "../telemetry-identity";
+import {
+  _resetTelemetryIdentityForTests,
+  cachedUserFunction,
+  computeOrgDomain,
+  primeUserRole,
+} from "../telemetry-identity";
 
 // initTelemetry no-ops when ANONYMIZED_TELEMETRY=false, and the CI env may set it.
 process.env.ANONYMIZED_TELEMETRY = "true";
 
 const TEST_DB_PATH = "./test-telemetry-context.sqlite";
+const PROFILE_KEYS = [
+  "SWARM_ORG_TEAM_SIZE",
+  "SWARM_ORG_USE_CASE",
+  "SWARM_ORG_ACQUISITION_SOURCE",
+] as const;
 
 async function removeTestDb(): Promise<void> {
   for (const suffix of ["", "-wal", "-shm"]) {
@@ -116,6 +128,30 @@ describe("telemetry context helpers", () => {
     expect(mapTriggerSurface(null)).toBe("other");
   });
 
+  test("buildContext omits invalid profile values and a function without an actor", () => {
+    const base = {
+      orgId: "org_0123456789abcdef",
+      installationId: "install_test",
+      isCloud: false,
+      isE2b: false,
+      swarmVersion: "1.2.3",
+    };
+    const context = buildContext({
+      ...base,
+      teamSize: "invalid",
+      useCase: "invalid",
+      acquisitionSource: "invalid",
+      userFunction: "founder",
+    });
+    expect(context).not.toHaveProperty("team_size");
+    expect(context).not.toHaveProperty("use_case");
+    expect(context).not.toHaveProperty("user_function");
+    expect(context.acquisition_source).toBeNull();
+    expect(
+      buildContext({ ...base, actor: { userId: "u-1" }, userFunction: "administrator" }),
+    ).not.toHaveProperty("user_function");
+  });
+
   test("normalizeProperties keeps an event alive when one optional value is unsendable", () => {
     const out = normalizeProperties("task.completed", {
       taskId: "t-1",
@@ -248,6 +284,19 @@ describe("telemetry envelope", () => {
     }
   });
 
+  test("track resolves the actor's job function without changing the RBAC role", async () => {
+    const config = memoryConfig({ telemetry_installation_id: "install_function" });
+    await initTelemetry("api-server", config.get, config.set, { generateIfMissing: true });
+    setTelemetryFunctionResolver(() => "founder");
+    track({
+      event: "workflow.deleted",
+      properties: { workflowId: "wf-1" },
+      actor: { userId: "u-1", role: "member" },
+    });
+    await tick();
+    expect(sent[0]?.context).toMatchObject({ user_function: "founder", user_role: "member" });
+  });
+
   test("an org with no ID yet sends nothing instead of a half-identified event", async () => {
     // A worker on an old server: installation ID known, no org ID stored.
     const config = memoryConfig({ telemetry_installation_id: "install_noorg" });
@@ -270,18 +319,95 @@ describe("telemetry envelope", () => {
 });
 
 describe("org email domain", () => {
+  const savedProfile = Object.fromEntries(PROFILE_KEYS.map((key) => [key, process.env[key]]));
+
   beforeEach(async () => {
     closeDb();
     await removeTestDb();
     initDb(TEST_DB_PATH);
     _resetTelemetryIdentityForTests();
+    for (const key of PROFILE_KEYS) delete process.env[key];
   });
 
   afterEach(async () => {
+    for (const key of PROFILE_KEYS) {
+      if (savedProfile[key] === undefined) delete process.env[key];
+      else process.env[key] = savedProfile[key];
+    }
     closeDb();
     await removeTestDb();
   });
 
+  test("stored company profile reaches context after reload and clears without restart", async () => {
+    const values = ["11-50", "features", "hacker_news"];
+    for (const [index, key] of PROFILE_KEYS.entries()) {
+      await upsertSwarmConfig({ scope: "global", key, value: values[index] as string });
+    }
+    await loadGlobalConfigsIntoEnv(true);
+    const originalFetch = globalThis.fetch;
+    const sent: Array<{ context: Record<string, unknown> }> = [];
+    globalThis.fetch = (async (_url: string, init?: { body?: string }) => {
+      if (init?.body) sent.push(JSON.parse(init.body));
+      return new Response(null, { status: 204 });
+    }) as typeof fetch;
+    _resetTelemetryStateForTests();
+    try {
+      const config = memoryConfig({
+        telemetry_installation_id: "install_profile",
+        telemetry_org_id: "org_0123456789abcdef",
+      });
+      await initTelemetry("api-server", config.get, config.set);
+      track({ event: "server.started", properties: { port: 3013 } });
+      expect(sent).toHaveLength(1);
+      expect(sent[0]?.context).toMatchObject({
+        team_size: "11-50",
+        use_case: "features",
+        acquisition_source: "hacker_news",
+      });
+      for (const key of PROFILE_KEYS) {
+        await upsertSwarmConfig({ scope: "global", key, value: "" });
+      }
+      await loadGlobalConfigsIntoEnv(true);
+      track({ event: "server.started", properties: { port: 3013 } });
+      expect(sent).toHaveLength(2);
+      expect(sent[1]?.context).not.toHaveProperty("team_size");
+      expect(sent[1]?.context).not.toHaveProperty("use_case");
+      expect(sent[1]?.context.acquisition_source).toBeNull();
+    } finally {
+      globalThis.fetch = originalFetch;
+      _resetTelemetryStateForTests();
+    }
+  });
+
+  test("job function uses the role cache and invalidates after a committed user update", async () => {
+    const user = await createUser({
+      name: "Founder",
+      role: "admin",
+      metadata: { jobFunction: "founder" },
+    });
+    await primeUserRole(user.id);
+    expect(cachedUserFunction(user.id)).toBe("founder");
+    await getDbClient().transaction(async () => {
+      await updateUser(user.id, { metadata: { jobFunction: "engineer" } });
+      expect(cachedUserFunction(user.id)).toBe("founder");
+    });
+    await primeUserRole(user.id);
+    expect(cachedUserFunction(user.id)).toBe("engineer");
+    await updateUser(user.id, { metadata: { jobFunction: "a free-text legacy role" } });
+    await primeUserRole(user.id);
+    expect(cachedUserFunction(user.id)).toBeUndefined();
+    const context = buildContext({
+      orgId: "org_0123456789abcdef",
+      installationId: "install_profile",
+      isCloud: false,
+      isE2b: false,
+      swarmVersion: "1.2.3",
+      actor: { userId: user.id },
+      userFunction: cachedUserFunction(user.id),
+    });
+    expect(context).not.toHaveProperty("user_function");
+  });
+
   test("is undefined with no users", async () => {
     expect(await computeOrgDomain()).toBeUndefined();
   });

package/src/tests/telemetry-ui-route.test.ts

@@ -5,6 +5,7 @@ import { isPublicRoute } from "../http/route-def";
 import { handleTelemetryUi } from "../http/telemetry-ui";
 import { getPathSegments, parseQueryParams } from "../http/utils";
 import { _resetTelemetryStateForTests, initTelemetry } from "../telemetry";
+import catalog from "../telemetry-contract/catalog.json";
 import { UI_EVENT_NAMES, validateUiEvent } from "../telemetry-ui-events";
 import type { HttpRequestAuth } from "../utils/request-auth-context";
 import { setRequestAuth } from "../utils/request-auth-context";
@@ -118,6 +119,128 @@ describe("POST /api/telemetry/ui-event", () => {
     expect(sent).toHaveLength(0);
   });
 
+  test.each([
+    { event: "identity.lookup", properties: { matched: true } },
+    ...["identity_modal", "setup"].map((surface) => ({
+      event: "identity.user_created",
+      properties: { surface, email_kind: "work", has_function: true, has_company: true },
+    })),
+    {
+      event: "fleet_benchmark.unlocked",
+      properties: { fields: ["website", "team_size", "use_case"] },
+    },
+    ...["compose", "docker", "kubernetes"].map((target) => ({
+      event: "setup.worker_command_copied",
+      properties: { target, harness: "codex" },
+    })),
+    ...[
+      "prompt",
+      "setup",
+      "settings",
+      "org_name_popup",
+      "feedback",
+      "fleet_benchmark",
+      "telemetry_banner",
+      "identity_modal",
+    ].map((surface) => ({
+      event: "org.profile_updated",
+      properties: {
+        fields: ["name", "website", "team_size", "use_case", "acquisition_source"],
+        surface,
+      },
+    })),
+    {
+      event: "popup.submitted",
+      properties: {
+        popup: "feedback",
+        has_message: false,
+        has_contact: false,
+        answered: 3,
+        perks: ["used_by", "slack_connect"],
+      },
+    },
+    ...["notification.viewed", "notification.dismissed", "notification.submitted"].flatMap(
+      (event) =>
+        ["task_failed", "first_workflow", "default"].map((moment) => ({
+          event,
+          properties: {
+            key: "slack_connect_invite",
+            moment,
+            ...(event === "notification.submitted" ? { user_function: "engineer" } : {}),
+          },
+        })),
+    ),
+  ])("accepts the company-profile catalog event $event with $properties", async ({
+    event,
+    properties,
+  }) => {
+    const result = await post({ event, properties });
+    await flush();
+    expect(result.statusCode).toBe(204);
+    expect(sent).toHaveLength(1);
+    expect(sent[0]).toMatchObject({ event, source: "ui", properties });
+  });
+
+  test.each([
+    {
+      event: "identity.user_created",
+      properties: {
+        surface: "invalid",
+        email_kind: "work",
+        has_function: true,
+        has_company: false,
+      },
+    },
+    { event: "setup.worker_command_copied", properties: { target: "invalid", harness: "codex" } },
+    { event: "org.profile_updated", properties: { fields: ["team_size"], surface: "invalid" } },
+    { event: "org.profile_updated", properties: { fields: ["invalid"], surface: "settings" } },
+    { event: "fleet_benchmark.unlocked", properties: { fields: ["invalid"] } },
+    {
+      event: "popup.submitted",
+      properties: { popup: "feedback", has_message: false, has_contact: false, perks: ["invalid"] },
+    },
+    {
+      event: "notification.submitted",
+      properties: { key: "slack_connect_invite", moment: "invalid" },
+    },
+    {
+      event: "notification.submitted",
+      properties: { key: "slack_connect_invite", user_function: "invalid" },
+    },
+  ])("rejects a bad enum in $event with $properties", async ({ event, properties }) => {
+    const result = await post({ event, properties });
+    expect(result.statusCode).toBe(400);
+    expect(sent).toHaveLength(0);
+  });
+
+  test("array item references enforce the referenced enum", async () => {
+    const entry = catalog.events.find((entry) => entry.event === "fleet_benchmark.unlocked")!;
+    const fields = entry.properties.fields!;
+    const original = fields.items;
+    // Exercise a referenced item definition without changing the vendored catalog.
+    Object.assign(fields, { items: { ref: "use_case" } });
+    try {
+      expect(
+        (
+          await post({
+            event: "fleet_benchmark.unlocked",
+            properties: { fields: ["features"] },
+          })
+        ).statusCode,
+      ).toBe(204);
+      sent = [];
+      const result = await post({
+        event: "fleet_benchmark.unlocked",
+        properties: { fields: ["invalid"] },
+      });
+      expect(result.statusCode).toBe(400);
+      expect(result.body).toContain("items must be one of");
+      expect(sent).toHaveLength(0);
+    } finally {
+      fields.items = original;
+    }
+  });
+
   test("an unknown event name gets 400 and sends nothing", async () => {
     const result = await post({ event: "task.created", properties: {} });
     await flush();

package/src/tests/tool-annotations.test.ts

@@ -376,9 +376,10 @@ describe("Tool Annotations & Classification", () => {
     // (this suite forces ALL_CAPABILITIES, including default-disabled ones).
     // Includes 11 skill tools, 7 MCP server tools, reusable script tools, and the
     // native Kapso/WhatsApp tools (register/unregister number + send/reply message),
-    // and the six Chat SDK tools (chat-* + register/unregister-chat-channel).
+    // the six Chat SDK tools (chat-* + register/unregister-chat-channel),
+    // and the seven app row tools plus app-action-run.
     expect(count).toBeGreaterThanOrEqual(45);
-    expect(count).toBeLessThanOrEqual(163);
+    expect(count).toBeLessThanOrEqual(169);
   });
 
   test("core tools are fewer than deferred tools", () => {

package/src/tests/used-by-route.test.ts

@@ -5,6 +5,7 @@ import { closeDb, createAgent, getSwarmConfigs, initDb, upsertSwarmConfig } from
 import { fillOrgLogoFromWebsite } from "../be/org-profile";
 import { handleUsedBy } from "../http/used-by";
 import { getPathSegments, parseQueryParams } from "../http/utils";
+import { _resetTelemetryStateForTests, initTelemetry } from "../telemetry";
 import type { HttpRequestAuth } from "../utils/request-auth-context";
 import { setRequestAuth } from "../utils/request-auth-context";
 
@@ -94,26 +95,155 @@ describe("POST /api/used-by", () => {
   });
 
   test("a non-lead agent gets 403 and nothing reaches the proxy", async () => {
-    const result = await post({ granted: true }, null, WORKER_ID);
+    const result = await post({ granted: true, contactEmail: "admin@acme.com" }, null, WORKER_ID);
     expect(result.statusCode).toBe(403);
     expect(proxied).toEqual([]);
   });
 
+  test("consent telemetry reports quote and function presence without their contents", async () => {
+    const savedFlag = process.env.ANONYMIZED_TELEMETRY;
+    try {
+      process.env.ANONYMIZED_TELEMETRY = "true";
+      _resetTelemetryStateForTests();
+      await initTelemetry("api-server", configValue, async () => {}, { generateIfMissing: true });
+      await post(
+        {
+          granted: true,
+          contactEmail: "admin@acme.com",
+          contactFunction: "founder",
+          quote: "Private quote",
+        },
+        OPERATOR,
+      );
+      await post({ granted: false }, OPERATOR);
+      await post({ granted: true, contactEmail: "admin@acme.com" }, OPERATOR);
+      const events = proxied.filter((request) => request.body.event === "used_by.consent_changed");
+      expect(events).toHaveLength(3);
+      expect(events.map((event) => event.body.properties)).toMatchObject([
+        { granted: true, has_quote: true, has_function: true },
+        { granted: false, has_quote: false, has_function: false },
+        { granted: true, has_quote: false, has_function: false },
+      ]);
+      for (const event of events) {
+        expect(JSON.stringify(event.body)).not.toContain("Private quote");
+        expect(JSON.stringify(event.body)).not.toContain("admin@acme.com");
+      }
+    } finally {
+      if (savedFlag === undefined) delete process.env.ANONYMIZED_TELEMETRY;
+      else process.env.ANONYMIZED_TELEMETRY = savedFlag;
+      _resetTelemetryStateForTests();
+    }
+  });
+
   test("grant and revoke both reach the proxy and are stored", async () => {
-    const grant = await post({ granted: true }, OPERATOR);
+    const grant = await post(
+      {
+        granted: true,
+        contactEmail: "admin@acme.com",
+        contactFunction: "founder",
+        quote: "Our swarm ships features.",
+      },
+      OPERATOR,
+    );
     expect(grant.statusCode).toBe(200);
     expect(proxied[0]?.url).toBe("https://proxy.desplega.sh/v1/used-by");
     expect(proxied[0]?.body).toMatchObject({
       org_name: "Acme",
       org_website: "acme.com",
       granted: true,
+      contact_email: "admin@acme.com",
+      contact_function: "founder",
+      quote: "Our swarm ships features.",
     });
     expect(await configValue("SWARM_USED_BY_CONSENT")).toBe("true");
+    expect(await configValue("SWARM_USED_BY_CONTACT_EMAIL")).toBe("admin@acme.com");
+    expect(await configValue("SWARM_USED_BY_CONTACT_FUNCTION")).toBe("founder");
+    expect(await configValue("SWARM_USED_BY_QUOTE")).toBe("Our swarm ships features.");
+    // Contact details never reach agent env, and readers see the email masked.
+    const rows = await getSwarmConfigs({ scope: "global" });
+    const row = (key: string) => rows.find((entry) => entry.key === key);
+    for (const key of [
+      "SWARM_USED_BY_CONTACT_EMAIL",
+      "SWARM_USED_BY_CONTACT_FUNCTION",
+      "SWARM_USED_BY_QUOTE",
+    ]) {
+      expect(row(key)?.exportToEnv).toBe(false);
+    }
+    expect(row("SWARM_USED_BY_CONTACT_EMAIL")?.isSecret).toBe(true);
 
     const revoke = await post({ granted: false }, OPERATOR);
     expect(revoke.statusCode).toBe(200);
     expect(proxied[1]?.body).toMatchObject({ granted: false });
     expect(await configValue("SWARM_USED_BY_CONSENT")).toBe("false");
+    expect(await configValue("SWARM_USED_BY_CONTACT_EMAIL")).toBe("");
+    expect(await configValue("SWARM_USED_BY_CONTACT_FUNCTION")).toBe("");
+    expect(await configValue("SWARM_USED_BY_QUOTE")).toBe("");
+    expect(proxied[1]?.body).not.toHaveProperty("contact_email");
+    expect(proxied[1]?.body).not.toHaveProperty("contact_function");
+    expect(proxied[1]?.body).not.toHaveProperty("quote");
+  });
+
+  test("a grant requires valid contact details and a quote of at most 280 characters", async () => {
+    for (const details of [
+      {},
+      { contactEmail: "" },
+      { contactEmail: "invalid" },
+      { contactEmail: "admin@acme.com", contactFunction: "CEO" },
+      { contactEmail: "admin@acme.com", quote: "x".repeat(281) },
+    ]) {
+      const result = await post({ granted: true, ...details }, OPERATOR);
+      expect(result.statusCode).toBe(400);
+      expect(result.body).toContain("Validation error");
+    }
+    expect(proxied).toEqual([]);
+    expect((await post({ granted: false, contactEmail: "invalid" }, OPERATOR)).statusCode).toBe(
+      400,
+    );
+    expect(proxied).toEqual([]);
+  });
+
+  test("contact email accepts 320 characters and rejects longer values", async () => {
+    const contactEmail = `${"a".repeat(64)}@${Array(4).fill("b".repeat(63)).join(".")}`;
+    expect(contactEmail).toHaveLength(320);
+    expect((await post({ granted: true, contactEmail }, OPERATOR)).statusCode).toBe(200);
+    proxied = [];
+    const result = await post({ granted: true, contactEmail: `a${contactEmail}` }, OPERATOR);
+    expect(result.statusCode).toBe(400);
+    expect(result.body).toContain("Contact email must be at most 320 characters");
+    expect(proxied).toEqual([]);
+  });
+
+  test("an empty stored name overrides the deployment name", async () => {
+    process.env.SWARM_ORG_NAME = "Deployment name";
+    try {
+      await upsertSwarmConfig({ scope: "global", key: "SWARM_ORG_NAME", value: "" });
+      const result = await post({ granted: true, contactEmail: "admin@acme.com" }, OPERATOR);
+      expect(result.statusCode).toBe(400);
+      expect(result.body).toContain("Set the organization name and website first");
+      expect(proxied).toEqual([]);
+    } finally {
+      delete process.env.SWARM_ORG_NAME;
+    }
+  });
+
+  test("a new grant clears omitted optional fields from the previous grant", async () => {
+    const result = await post(
+      {
+        granted: true,
+        contactEmail: "admin@acme.com",
+        contactFunction: "engineer",
+        quote: "x".repeat(280),
+      },
+      OPERATOR,
+    );
+    expect(result.statusCode).toBe(200);
+    expect(await configValue("SWARM_USED_BY_QUOTE")).toHaveLength(280);
+    expect((await post({ granted: true, contactEmail: "new@acme.com" }, OPERATOR)).statusCode).toBe(
+      200,
+    );
+    expect(await configValue("SWARM_USED_BY_CONTACT_EMAIL")).toBe("new@acme.com");
+    expect(await configValue("SWARM_USED_BY_CONTACT_FUNCTION")).toBe("");
+    expect(await configValue("SWARM_USED_BY_QUOTE")).toBe("");
   });
 
   test("with telemetry off the install ID stays home", async () => {
@@ -124,9 +254,9 @@ describe("POST /api/used-by", () => {
     });
     const saved = process.env.ANONYMIZED_TELEMETRY;
     process.env.ANONYMIZED_TELEMETRY = "true";
-    await post({ granted: true }, OPERATOR);
+    await post({ granted: true, contactEmail: "admin@acme.com" }, OPERATOR);
     process.env.ANONYMIZED_TELEMETRY = "false";
-    await post({ granted: true }, OPERATOR);
+    await post({ granted: true, contactEmail: "admin@acme.com" }, OPERATOR);
     if (saved === undefined) delete process.env.ANONYMIZED_TELEMETRY;
     else process.env.ANONYMIZED_TELEMETRY = saved;
     expect(proxied[0]?.body.install_id).toBe("install_0123456789abcdef");
@@ -139,7 +269,7 @@ describe("POST /api/used-by", () => {
       key: "feedback_endpoint",
       value: "http://stub.test/v1/feedback",
     });
-    await post({ granted: true }, OPERATOR);
+    await post({ granted: true, contactEmail: "admin@acme.com" }, OPERATOR);
     expect(proxied[0]?.url).toBe("http://stub.test/v1/used-by");
     await upsertSwarmConfig({
       scope: "global",
@@ -151,13 +281,15 @@ describe("POST /api/used-by", () => {
   test("a proxy failure is a 502 and leaves the stored consent alone", async () => {
     await upsertSwarmConfig({ scope: "global", key: "SWARM_USED_BY_CONSENT", value: "false" });
     proxyStatus = 500;
-    const result = await post({ granted: true }, OPERATOR);
+    const result = await post({ granted: true, contactEmail: "admin@acme.com" }, OPERATOR);
     expect(result.statusCode).toBe(502);
     expect(await configValue("SWARM_USED_BY_CONSENT")).toBe("false");
   });
 
   test("a revoke after the website is cleared or changed uses the granted identity", async () => {
-    expect((await post({ granted: true }, OPERATOR)).statusCode).toBe(200);
+    expect(
+      (await post({ granted: true, contactEmail: "admin@acme.com" }, OPERATOR)).statusCode,
+    ).toBe(200);
     await upsertSwarmConfig({ scope: "global", key: "SWARM_ORG_WEBSITE", value: "" });
     const revoke = await post({ granted: false }, OPERATOR);
     expect(revoke.statusCode).toBe(200);
@@ -173,7 +305,9 @@ describe("POST /api/used-by", () => {
     expect(proxied[2]?.body).toMatchObject({ org_name: "Acme", org_website: "acme.com" });
 
     // A new grant sends, and from then on revokes with, the current identity.
-    expect((await post({ granted: true }, OPERATOR)).statusCode).toBe(200);
+    expect(
+      (await post({ granted: true, contactEmail: "admin@acme.com" }, OPERATOR)).statusCode,
+    ).toBe(200);
     expect(proxied[3]?.body).toMatchObject({ org_name: "Acme Labs", org_website: "acme.io" });
     await upsertSwarmConfig({ scope: "global", key: "SWARM_ORG_WEBSITE", value: "" });
     await post({ granted: false }, OPERATOR);
@@ -182,7 +316,7 @@ describe("POST /api/used-by", () => {
 
   test("without a website it is a 400", async () => {
     await upsertSwarmConfig({ scope: "global", key: "SWARM_ORG_WEBSITE", value: "" });
-    const result = await post({ granted: true }, OPERATOR);
+    const result = await post({ granted: true, contactEmail: "admin@acme.com" }, OPERATOR);
     expect(result.statusCode).toBe(400);
     expect(JSON.parse(result.body)).toEqual({
       error: "Set the organization name and website first",
@@ -192,7 +326,7 @@ describe("POST /api/used-by", () => {
 
   test("a placeholder name still grants: the ranking's placeholder rule does not apply", async () => {
     await upsertSwarmConfig({ scope: "global", key: "SWARM_ORG_NAME", value: "Swarm" });
-    const result = await post({ granted: true }, OPERATOR);
+    const result = await post({ granted: true, contactEmail: "admin@acme.com" }, OPERATOR);
     expect(result.statusCode).toBe(200);
     expect(proxied[0]?.body).toMatchObject({ org_name: "Swarm", org_website: "acme.com" });
   });