@desplega.ai/agent-swarm 2.4.0 → 2.4.1

package/src/tests/fleet-benchmark.test.ts

@@ -209,11 +209,37 @@ describe("GET /api/fleet-benchmark", () => {
     }
   }
 
-  test("telemetry off: no proxy call and no local scan", async () => {
+  test("telemetry off: local 30-day counts without an ingest anchor or proxy call", async () => {
     process.env.ANONYMIZED_TELEMETRY = "false";
+    await db.getDbClient().run("DELETE FROM swarm_config WHERE key = 'telemetry_first_ingest'");
+    await addTasks(9, "completed", 3);
+    await addTasks(1, "failed", 3);
+    await addTasks(5, "pending", 3);
+    await addTasks(40, "completed", 45);
+    await setProfile();
     const response = await buildFleetBenchmarkResponse(NOW);
     expect(response.state).toBe("telemetry_off");
-    expect(response.local).toBeNull();
+    expect(response.local).toEqual({
+      tasksPerWeek: 3.5,
+      taskSuccessRate: 0.9,
+      finishedTasks: 10,
+      agents: 3,
+      bucket: "2-5",
+    });
+    expect(response.level).toBe("full");
+    expect(response.peerGroup).toBeNull();
+    expect(response.comparisons).toEqual([]);
+    expect(fetched).toEqual([]);
+  });
+
+  test("telemetry off on a fresh swarm returns zero counts", async () => {
+    process.env.ANONYMIZED_TELEMETRY = "false";
+    await db.getDbClient().run("DELETE FROM swarm_config WHERE key = 'telemetry_first_ingest'");
+    expect(await buildFleetBenchmarkResponse(NOW)).toMatchObject({
+      state: "telemetry_off",
+      level: "basic",
+      local: { tasksPerWeek: 0, taskSuccessRate: null, finishedTasks: 0 },
+    });
     expect(fetched).toEqual([]);
   });
 
@@ -227,6 +253,19 @@ describe("GET /api/fleet-benchmark", () => {
     expect(fetched).toEqual([]);
   });
 
+  test("an empty stored name overrides the deployment name", async () => {
+    const saved = process.env.SWARM_ORG_NAME;
+    process.env.SWARM_ORG_NAME = "Deployment name";
+    try {
+      await db.upsertSwarmConfig({ scope: "global", key: "SWARM_ORG_NAME", value: "" });
+      expect((await buildFleetBenchmarkResponse(NOW)).state).toBe("no_org_name");
+      expect(fetched).toEqual([]);
+    } finally {
+      if (saved === undefined) delete process.env.SWARM_ORG_NAME;
+      else process.env.SWARM_ORG_NAME = saved;
+    }
+  });
+
   test("fewer than 10 finished tasks: local numbers only", async () => {
     await addTasks(9, "completed", 3);
     await addTasks(5, "pending", 3);
@@ -242,6 +281,8 @@ describe("GET /api/fleet-benchmark", () => {
     await addTasks(40, "completed", 45); // Outside the window.
     const response = await buildFleetBenchmarkResponse(NOW);
     expect(response.state).toBe("ready");
+    expect(response.level).toBe("basic");
+    expect(response.peerGroup).toBeNull();
     expect(response.local).toEqual({
       tasksPerWeek: 14,
       taskSuccessRate: 0.95,
@@ -259,6 +300,85 @@ describe("GET /api/fleet-benchmark", () => {
     expect(fetched).toHaveLength(1);
   });
 
+  async function setProfile(teamSize = "2-10", useCase = "features"): Promise<void> {
+    await db.upsertSwarmConfig({ scope: "global", key: "SWARM_ORG_WEBSITE", value: "acme.com" });
+    await db.upsertSwarmConfig({ scope: "global", key: "SWARM_ORG_TEAM_SIZE", value: teamSize });
+    await db.upsertSwarmConfig({ scope: "global", key: "SWARM_ORG_USE_CASE", value: useCase });
+  }
+
+  test("full profile requests peers and returns the proxy group", async () => {
+    await addTasks(10, "completed", 1);
+    await setProfile();
+    proxyBody = {
+      ...FLEET,
+      peer_group: { team_size: "2-10", use_case: "features", orgs: 6 },
+    };
+    const response = await buildFleetBenchmarkResponse(NOW);
+    expect(response).toMatchObject({
+      state: "ready",
+      level: "full",
+      peerGroup: { teamSize: "2-10", useCase: "features", orgs: 6 },
+    });
+    expect(fetched).toEqual([
+      "http://proxy.test/v1/fleet/benchmarks?window=30d&team_size=2-10&use_case=features",
+    ]);
+    await buildFleetBenchmarkResponse(NOW);
+    expect(fetched).toHaveLength(1);
+  });
+
+  test("full profile tolerates absent or null peer_group from the proxy", async () => {
+    await addTasks(10, "completed", 1);
+    await setProfile();
+    for (const peer_group of [undefined, null]) {
+      proxyBody = { ...FLEET, peer_group };
+      const route = await freshRoute();
+      const response = await route.buildFleetBenchmarkResponse(NOW);
+      expect(response).toMatchObject({ state: "ready", level: "full", peerGroup: null });
+    }
+  });
+
+  test("cache follows profile changes and cleared fields return to basic", async () => {
+    await addTasks(10, "completed", 1);
+    await buildFleetBenchmarkResponse(NOW);
+    await setProfile();
+    await buildFleetBenchmarkResponse(NOW);
+    await setProfile("11-50", "bugs");
+    await buildFleetBenchmarkResponse(NOW);
+    await setProfile("11-50", "review");
+    await buildFleetBenchmarkResponse(NOW);
+    expect(fetched).toHaveLength(4);
+    expect(fetched[2]).toContain("team_size=11-50&use_case=bugs");
+    expect(fetched[3]).toContain("team_size=11-50&use_case=review");
+    await db.upsertSwarmConfig({ scope: "global", key: "SWARM_ORG_WEBSITE", value: "" });
+    const response = await buildFleetBenchmarkResponse(NOW);
+    expect(response.level).toBe("basic");
+    expect(fetched.at(-1)).toBe("http://proxy.test/v1/fleet/benchmarks?window=30d");
+  });
+
+  test("partial profile stays basic and sends no peer filters", async () => {
+    await addTasks(10, "completed", 1);
+    for (const key of ["SWARM_ORG_WEBSITE", "SWARM_ORG_TEAM_SIZE", "SWARM_ORG_USE_CASE"]) {
+      await setProfile();
+      await db.upsertSwarmConfig({ scope: "global", key, value: "" });
+      const route = await freshRoute();
+      expect((await route.buildFleetBenchmarkResponse(NOW)).level).toBe("basic");
+      expect(fetched.at(-1)).toBe("http://proxy.test/v1/fleet/benchmarks?window=30d");
+    }
+  });
+
+  test("enabling telemetry never reuses local-only counts for comparison", async () => {
+    await addTasks(10, "completed", 1);
+    await db.getDbClient().run("DELETE FROM swarm_config WHERE key = 'telemetry_first_ingest'");
+    process.env.ANONYMIZED_TELEMETRY = "false";
+    expect((await buildFleetBenchmarkResponse(NOW)).local?.finishedTasks).toBe(10);
+    process.env.ANONYMIZED_TELEMETRY = "true";
+    expect(await buildFleetBenchmarkResponse(NOW)).toMatchObject({
+      state: "unavailable",
+      local: null,
+    });
+    expect(fetched).toEqual([]);
+  });
+
   async function mintInstallId(daysAgo: number): Promise<void> {
     await db
       .getDbClient()

package/src/tests/http-users.test.ts

@@ -160,12 +160,39 @@ describe("GET /api/users", () => {
 });
 
 describe("POST /api/users", () => {
+  test("email is optional, and valid email addresses are accepted", async () => {
+    for (const email of [undefined, "taras+swarm@example.com"]) {
+      const response = await authedFetch("/api/users", {
+        method: "POST",
+        body: JSON.stringify({ name: "Optional email", email, role: "engineer" }),
+      });
+      expect(response.status).toBe(200);
+      const { user } = await response.json();
+      expect(user.email ?? null).toBe(email ?? null);
+      expect(user.role).toBe("engineer");
+    }
+  });
+
+  test("invalid email is rejected before a user is created", async () => {
+    for (const email of ["", "not-an-email", "tester@dev", null]) {
+      const response = await authedFetch("/api/users", {
+        method: "POST",
+        body: JSON.stringify({ name: "Invalid email", email }),
+      });
+      expect(response.status).toBe(400);
+      expect(await response.text()).toContain("email");
+    }
+    expect(await getDbClient().get<{ n: number }>("SELECT COUNT(*) AS n FROM users")).toEqual({
+      n: 0,
+    });
+  });
+
   test("creates user + links identities + budget event, all tagged op:<fp>", async () => {
     const r = await authedFetch("/api/users", {
       method: "POST",
       body: JSON.stringify({
         name: "Tester",
-        email: "tester@dev",
+        email: "tester@dev.example",
         dailyBudgetUsd: 5,
         identities: [
           { kind: "slack", externalId: "U_QA1" },
@@ -197,6 +224,40 @@ describe("POST /api/users", () => {
 });
 
 describe("PATCH /api/users/:id", () => {
+  test("validates email when present and permits profile updates without email", async () => {
+    const user = await createUser({ name: "Email validation", email: "old@example.com" });
+    for (const email of ["", "invalid", "tester@dev"]) {
+      const response = await authedFetch(`/api/users/${user.id}`, {
+        method: "PATCH",
+        body: JSON.stringify({ email }),
+      });
+      expect(response.status).toBe(400);
+      expect(await response.text()).toContain("email");
+    }
+    const unchanged = await authedFetch(`/api/users/${user.id}`);
+    expect((await unchanged.json()).user.email).toBe("old@example.com");
+    for (const patch of [{ role: "founder" }, { email: "new+swarm@example.com" }]) {
+      const response = await authedFetch(`/api/users/${user.id}`, {
+        method: "PATCH",
+        body: JSON.stringify(patch),
+      });
+      expect(response.status).toBe(200);
+      expect((await response.json()).user).toMatchObject(patch);
+    }
+  });
+
+  test("null clears the primary email", async () => {
+    const user = await createUser({ name: "Clear email", email: "clear@example.com" });
+    const response = await authedFetch(`/api/users/${user.id}`, {
+      method: "PATCH",
+      body: JSON.stringify({ email: null }),
+    });
+    expect(response.status).toBe(200);
+    expect((await response.json()).user.email ?? null).toBeNull();
+    const reloaded = await authedFetch(`/api/users/${user.id}`);
+    expect((await reloaded.json()).user.email ?? null).toBeNull();
+  });
+
   test("dailyBudgetUsd mirrors into user-scoped budgets and null removes the mirror", async () => {
     const create = await authedFetch("/api/users", {
       method: "POST",

package/src/tests/model-catalog-table.test.ts

@@ -1,5 +1,6 @@
 import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
 import { unlink } from "node:fs/promises";
+import { reasoningLevelsForModel } from "@desplega/model-catalog";
 import { closeDb, getActivePricingRow, getDbClient, initDb } from "../be/db";
 import {
   listModelCatalogOverlay,
@@ -10,6 +11,7 @@ import {
 import { getModelsCatalog, resetModelsCatalogForTests } from "../be/models-catalog";
 import type { ModelsDevCache } from "../be/modelsdev-cache";
 import { MODEL_CATALOG_FRESH_MS, refreshModelCatalog } from "../be/pricing-refresh";
+import { getContextWindowSize } from "../utils/context-window";
 
 const TEST_DB_PATH = "./test-model-catalog-table.sqlite";
 
@@ -212,6 +214,67 @@ describe("persistent model catalog", () => {
     expect(model?.name).toBe("GPT Base");
   });
 
+  test("opencode-go lands in the catalog, context windows and effort gating", async () => {
+    const cache: ModelsDevCache = {
+      "opencode-go": {
+        id: "opencode-go",
+        name: "OpenCode Go",
+        models: {
+          "deepseek-v4.1-flash": {
+            id: "deepseek-v4.1-flash",
+            name: "DeepSeek V4.1 Flash",
+            limit: { context: 1_000_000 },
+            reasoning: true,
+            reasoning_options: [{ type: "effort", values: ["low", "high", "max"] }],
+          },
+        },
+      },
+    };
+    await refreshModelCatalog({ force: true, now: 1_000, fetchImpl: ok(cache, '"og-v1"') });
+
+    const catalog = await loadModelsCatalog();
+    expect(catalog.providers["opencode-go"]?.models["deepseek-v4.1-flash"]?.limit?.context).toBe(
+      1_000_000,
+    );
+    // Before the projection covered opencode-go this fell back to 200k.
+    expect(getContextWindowSize("opencode-go/deepseek-v4.1-flash")).toBe(1_000_000);
+    // opencode keeps the model's own `max`; the catalog now carries the facts.
+    expect(
+      reasoningLevelsForModel("opencode", "opencode-go/deepseek-v4.1-flash", catalog.providers),
+    ).toEqual(["low", "high", "max"]);
+  });
+
+  test("an opencode-go overlay expires once upstream carries the projected facts", async () => {
+    const cache: ModelsDevCache = {
+      "opencode-go": {
+        id: "opencode-go",
+        name: "OpenCode Go",
+        models: {
+          "deepseek-v4.1-flash": {
+            id: "deepseek-v4.1-flash",
+            limit: { context: 1_000_000 },
+            reasoning: true,
+          },
+        },
+      },
+    };
+    await refreshModelCatalog({ force: true, now: 1_000, fetchImpl: ok(cache, '"og-v1"') });
+    await upsertModelCatalogOverlay({
+      provider: "opencode-go",
+      modelId: "deepseek-v4.1-flash",
+      contextWindow: 1_000_000,
+      reason: "hand-verified until models.dev caught up",
+    });
+
+    await refreshModelCatalog({ force: true, now: 2_000, fetchImpl: ok(cache, '"og-v2"') });
+
+    expect((await listModelCatalogOverlay()).map((o) => `${o.provider}/${o.modelId}`)).toEqual([]);
+    const model = (await loadModelsCatalog()).providers["opencode-go"]?.models[
+      "deepseek-v4.1-flash"
+    ];
+    expect(model?.limit?.context).toBe(1_000_000);
+  });
+
   test("overlay auto-expires once upstream matches", async () => {
     await refreshModelCatalog({ force: true, now: 1_000, fetchImpl: ok(payload(), '"v1"') });
     await upsertModelCatalogOverlay({

package/src/tests/model-profiles-api.test.ts

@@ -228,14 +228,26 @@ describe("profile CRUD", () => {
       (await call("PATCH", "/api/model-profiles/oc-off", { description: "kept" })).status,
     ).toBe(200);
 
+    // opencode passes the model's own declared efforts through, `max` included.
+    expect(
+      (await call("POST", "/api/model-profiles", { ...body, name: "oc-max", effort: "max" }))
+        .status,
+    ).toBe(201);
+
     // Control: a level this model does not list is still refused, on both verbs.
-    const max = await call("POST", "/api/model-profiles", {
-      ...body,
-      name: "oc-max",
-      effort: "max",
-    });
-    expect(max.status).toBe(400);
-    expect((await call("PATCH", "/api/model-profiles/oc-low", { effort: "max" })).status).toBe(400);
+    // `openai/gpt-5.1-codex` declares low|medium|high, so it accepts no `max`.
+    const noMax = { harness: "opencode", model: "openai/gpt-5.1-codex" };
+    expect(
+      (await call("POST", "/api/model-profiles", { ...noMax, name: "oc-nomax", effort: "max" }))
+        .status,
+    ).toBe(400);
+    expect(
+      (await call("POST", "/api/model-profiles", { ...noMax, name: "oc-capped", effort: "low" }))
+        .status,
+    ).toBe(201);
+    expect((await call("PATCH", "/api/model-profiles/oc-capped", { effort: "max" })).status).toBe(
+      400,
+    );
   });
 
   test("a tier seed and a profile in use cannot be deleted", async () => {

package/src/tests/models-catalog.test.ts

@@ -74,6 +74,33 @@ describe("buildModelsCatalog", () => {
     });
     expect(catalog.openai?.models["gpt-keyed"]?.id).toBe("gpt-keyed");
   });
+
+  test("projects opencode-go (OpenCode Go) like its sibling opencode", () => {
+    const catalog = buildModelsCatalog({
+      requesty: { models: { ignored: { id: "ignored" } } },
+      "opencode-go": {
+        id: "opencode-go",
+        name: "OpenCode Go",
+        models: {
+          "deepseek-v4.1-flash": {
+            id: "deepseek-v4.1-flash",
+            name: "DeepSeek V4.1 Flash",
+            limit: { context: 1_000_000 },
+            reasoning: true,
+            reasoning_options: [{ type: "effort", values: ["low", "high", "max"] }],
+          },
+        },
+      },
+    });
+    // A non-picker provider is dropped; opencode-go is kept.
+    expect(Object.keys(catalog)).toEqual(["opencode-go"]);
+    expect(catalog["opencode-go"]?.models["deepseek-v4.1-flash"]).toMatchObject({
+      id: "deepseek-v4.1-flash",
+      limit: { context: 1_000_000 },
+      reasoning: true,
+      reasoning_options: [{ type: "effort", values: ["low", "high", "max"] }],
+    });
+  });
 });
 
 describe("getModelsCatalog", () => {
@@ -85,6 +112,11 @@ describe("getModelsCatalog", () => {
     expect(Object.keys(result.providers.openrouter?.models ?? {}).length).toBeGreaterThan(0);
     expect(Object.keys(result.providers.anthropic?.models ?? {}).length).toBeGreaterThan(0);
     expect(Object.keys(result.providers.opencode?.models ?? {}).length).toBeGreaterThan(0);
+    // OpenCode Go is a catalog provider too (its sibling `opencode` is Zen).
+    expect(result.providers["opencode-go"]?.name).toBe("OpenCode Go");
+    expect(result.providers["opencode-go"]?.models["deepseek-v4-flash"]?.limit?.context).toBe(
+      1_000_000,
+    );
     expect(result.providers.nan?.models["glm5.3-flash"]).toBeDefined();
     expect(Object.keys(result.providers.helmcode?.models ?? {}).sort()).toEqual([
       "deepseek-v4-flash",
@@ -159,3 +191,21 @@ describe("nan and helmcode sections", () => {
     expect(getContextWindowSize("nan/qwen3.6")).toBe(262_144);
   });
 });
+
+describe("opencode-go section", () => {
+  test("the snapshot gives opencode-go ids their context window, not the 200k fallback", () => {
+    expect(getContextWindowSize("opencode-go/deepseek-v4-flash")).toBe(1_000_000);
+  });
+
+  test("opencode and pi keep the model's own max for an opencode-go id", () => {
+    const catalog = getModelsCatalog().providers;
+    // `deepseek-v4-flash` declares low|high|max and both harnesses pass it through.
+    for (const harness of ["opencode", "pi"] as const) {
+      expect(reasoningLevelsForModel(harness, "opencode-go/deepseek-v4-flash", catalog)).toEqual([
+        "low",
+        "high",
+        "max",
+      ]);
+    }
+  });
+});

package/src/tests/onboarding.test.ts

@@ -184,6 +184,27 @@ describe("onboarding state", () => {
     expect(body.state.version).toBe(1);
   });
 
+  test("a stored org name completes the name step, the old default does not", async () => {
+    const nameStep = async () =>
+      ((await (await request("/api/onboarding")).json()) as { state: OnboardingState }).state.steps
+        .name;
+    const previous = process.env.SWARM_ORG_NAME;
+    try {
+      delete process.env.SWARM_ORG_NAME;
+      expect((await nameStep()).status).toBe("todo");
+      process.env.SWARM_ORG_NAME = " Your Swarm ";
+      expect((await nameStep()).status).toBe("todo");
+      process.env.SWARM_ORG_NAME = "Acme";
+      expect(await nameStep()).toMatchObject({ status: "done", method: "custom_name" });
+      // Clearing the name later never undoes a done step.
+      delete process.env.SWARM_ORG_NAME;
+      expect((await nameStep()).status).toBe("done");
+    } finally {
+      if (previous === undefined) delete process.env.SWARM_ORG_NAME;
+      else process.env.SWARM_ORG_NAME = previous;
+    }
+  });
+
   test("concurrent first GETs create state and started telemetry once", async () => {
     const responses = await Promise.all(
       Array.from({ length: 8 }, () => request("/api/onboarding")),

package/src/tests/org-website.test.ts

@@ -1,6 +1,11 @@
 import { describe, expect, test } from "bun:test";
 import { validateConfigValue } from "../be/swarm-config-guard";
 import { buildContext } from "../telemetry-context";
+import {
+  COMPANY_ACQUISITION_SOURCES,
+  COMPANY_TEAM_SIZES,
+  COMPANY_USE_CASES,
+} from "../utils/company-profile";
 import {
   isFilledOrgLogoUrl,
   normalizeOrgWebsite,
@@ -75,6 +80,48 @@ describe("websiteSuggestion", () => {
     expect(websiteSuggestion("gmail.com")).toBeNull();
     expect(websiteSuggestion(null)).toBeNull();
   });
+
+  test("never suggests a regional or single-domain free-mail provider", () => {
+    for (const domain of [
+      "hotmail.es",
+      "yahoo.co.uk",
+      "outlook.fr",
+      "web.de",
+      "gmx.net",
+      "pm.me",
+      "mail.ru",
+      "live.co.uk",
+      "live.nl",
+      "yandex.com.tr",
+      "yandex.kz",
+      "icloud.com",
+      "me.com",
+      "proton.me",
+      "protonmail.ch",
+      "aol.de",
+      "qq.com",
+      "163.com",
+      "naver.com",
+      "Hotmail.CO.UK",
+      "mail.yahoo.com",
+    ]) {
+      expect(websiteSuggestion(domain)).toBeNull();
+    }
+  });
+
+  test("keeps company domains that only look like a provider", () => {
+    for (const domain of [
+      "acme.co.uk",
+      "acme.com.br",
+      "mailchimp.com",
+      "live.acme.com",
+      "yahoo-labs.dev",
+      "proton.ai",
+      "web.dev",
+    ]) {
+      expect(websiteSuggestion(domain)).toBe(domain);
+    }
+  });
 });
 
 describe("SWARM_ORG_WEBSITE config guard", () => {
@@ -95,6 +142,21 @@ describe("SWARM_ORG_WEBSITE config guard", () => {
   });
 });
 
+describe("company profile config guards", () => {
+  for (const [key, values] of [
+    ["SWARM_ORG_TEAM_SIZE", COMPANY_TEAM_SIZES],
+    ["SWARM_ORG_USE_CASE", COMPANY_USE_CASES],
+    ["SWARM_ORG_ACQUISITION_SOURCE", COMPANY_ACQUISITION_SOURCES],
+  ] as const) {
+    test(`${key} accepts its enum or empty, and rejects other values`, () => {
+      for (const value of ["", ...values]) expect(validateConfigValue(key, value)).toBeNull();
+      for (const value of ["unknown", "OTHER", "free text", null, 1, true]) {
+        expect(validateConfigValue(key, value)).toContain(key);
+      }
+    });
+  }
+});
+
 describe("org_website in the telemetry context", () => {
   const input = {
     orgId: "org_0123456789abcdef",

package/src/tests/pi-mono-adapter.test.ts

@@ -17,6 +17,7 @@ import {
   checkPiMonoCredentials,
   createPiRuntimeAuth,
   extractPiAssistantText,
+  listPiOpencodeGoModelIds,
   PiMonoAdapter,
   resolveModel,
   type SessionModelsJson,
@@ -457,6 +458,18 @@ describe("Model name mapping", () => {
   });
 });
 
+describe("listPiOpencodeGoModelIds", () => {
+  test("every reported opencode-go id resolves, so a picked id never falls back", () => {
+    const ids = listPiOpencodeGoModelIds();
+    expect(ids).toContain("deepseek-v4.1-flash");
+    for (const id of ids) {
+      expect(resolveModel(`opencode-go/${id}`, {})?.id).toBe(id);
+    }
+    expect(ids).not.toContain("deepseek-v4-flash");
+    expect(resolveModel("opencode-go/deepseek-v4-flash", {})).toBeUndefined();
+  });
+});
+
 describe("resolveModel — OpenRouter reroute for anthropic shortnames", () => {
   // Regression coverage for task 37a4a87a: workers spawned with
   // `provider: pi` + `OPENROUTER_API_KEY` (no ANTHROPIC_API_KEY) and a task
@@ -546,6 +559,16 @@ describe("createPiRuntimeAuth", () => {
     });
   });
 
+  test("passes OPENCODE_API_KEY to pi opencode-go runtime auth", async () => {
+    const modelRuntime = await createPiRuntimeAuth({
+      OPENCODE_API_KEY: "example-opencode-runtime",
+    });
+
+    await expect(modelRuntime.getAuth("opencode-go")).resolves.toMatchObject({
+      auth: { apiKey: "example-opencode-runtime" },
+    });
+  });
+
   test("passes GEMINI_API_KEY to pi google runtime auth", async () => {
     const modelRuntime = await createPiRuntimeAuth({
       GEMINI_API_KEY: "example-gemini-runtime",

package/src/tests/pr-body-leaks.test.ts

@@ -339,14 +339,18 @@ describe("parseGhPrCommands", () => {
     );
     expect(calls).toEqual([
       {
+        action: "create",
         cwd: "/tmp/wt",
         repos: ["o/r"],
+        resolvedRepos: ["o/r"],
         alsoCheckout: false,
         unknownTarget: false,
         texts: ["t"],
+        bodyTexts: [],
         bodyFiles: ["body.md"],
         unresolvedBodyFiles: [],
         opaqueBody: false,
+        externalBody: false,
       },
     ]);
   });