@desplega.ai/agent-swarm 2.7.0 → 2.7.1

package/src/tests/base-prompt.test.ts

@@ -34,6 +34,10 @@ const ENV_KEYS = [
   "SLACK_SIGNING_SECRET",
   "STEERING_ENABLED",
   "AGENT_FS_API_URL",
+  "AGENT_FS_LINK_TARGET",
+  "AGENT_FS_LIVE_URL",
+  "APP_URL",
+  "DASHBOARD_URL",
   "SCRIPTS_ONLY_MCP",
 ] as const;
 
@@ -495,6 +499,47 @@ describe("getBasePrompt: outputs section", () => {
     expect(result).not.toContain(NO_AGENT_FS_LINE);
   });
 
+  test("AGENT_FS_LINK_TARGET=dashboard with APP_URL links people to <APP_URL>/file/~/", async () => {
+    process.env.AGENT_FS_API_URL = "http://localhost:8787";
+    process.env.AGENT_FS_LINK_TARGET = "dashboard";
+    process.env.APP_URL = "http://localhost:5274/";
+    const result = await getBasePrompt({ ...minimalArgs, traits: localTraits });
+    expect(result).toContain(
+      "Give people the live app link `http://localhost:5274/file/~/<org>/<drive>/<path>`.",
+    );
+    expect(result).not.toContain("AGENT_FS_LIVE_URL}/file/~/");
+  });
+
+  test("AGENT_FS_LINK_TARGET=dashboard without APP_URL falls back to the live base", async () => {
+    process.env.AGENT_FS_API_URL = "http://localhost:8787";
+    process.env.AGENT_FS_LINK_TARGET = "dashboard";
+    process.env.AGENT_FS_LIVE_URL = "https://live.example.test/";
+    const result = await getBasePrompt({ ...minimalArgs, traits: localTraits });
+    expect(result).toContain(
+      "Give people the live app link `https://live.example.test/file/~/<org>/<drive>/<path>`.",
+    );
+  });
+
+  test("AGENT_FS_LINK_TARGET=live uses the default live host", async () => {
+    process.env.AGENT_FS_API_URL = "http://localhost:8787";
+    process.env.AGENT_FS_LINK_TARGET = "live";
+    process.env.APP_URL = "http://localhost:5274";
+    const result = await getBasePrompt({ ...minimalArgs, traits: localTraits });
+    expect(result).toContain(
+      "Give people the live app link `https://live.agent-fs.dev/file/~/<org>/<drive>/<path>`.",
+    );
+  });
+
+  test("an invalid AGENT_FS_LINK_TARGET keeps the exact old sentence", async () => {
+    process.env.AGENT_FS_API_URL = "http://localhost:8787";
+    process.env.AGENT_FS_LINK_TARGET = "Dashboard2";
+    process.env.APP_URL = "http://localhost:5274";
+    const result = await getBasePrompt({ ...minimalArgs, traits: localTraits });
+    expect(result).toContain(
+      `Give people the live app link \`\${AGENT_FS_LIVE_URL}/file/~/<org>/<drive>/<path>\`. Make an \`agent-fs share-create\` link only when the requester asks for one or the reader has no agent-fs login.`,
+    );
+  });
+
   test("uses the no_agent_fs variant when AGENT_FS_API_URL is unset", async () => {
     const result = await getBasePrompt({ ...minimalArgs, traits: localTraits });
     expect(result).toContain("## Outputs");
@@ -1193,9 +1238,7 @@ describe("getBasePrompt: harness tool discovery", () => {
 
   test.each([
     "pi",
-    "codex",
     "claude-managed",
-    "opencode",
     "acp",
   ])("%s without tool search gets direct-tool guidance", async (provider) => {
     const result = await getBasePrompt({
@@ -1220,6 +1263,30 @@ describe("getBasePrompt: harness tool discovery", () => {
     expect(result).toContain('import { store_progress } from "agent-swarm"');
   });
 
+  test("codex gets exec guidance with the normalized tool name", async () => {
+    const result = await getBasePrompt({
+      ...minimalArgs,
+      provider: "codex",
+      traits: { ...localTraits, hasToolSearch: false },
+    });
+    expect(result).not.toContain(deferred);
+    expect(result).not.toContain("already in your tool list");
+    expect(result).toContain("await tools.mcp__agent_swarm__store_progress({ ... })");
+    expect(result).toContain("`ALL_TOOLS`");
+  });
+
+  test("opencode gets execute guidance with the bracketed tool path", async () => {
+    const result = await getBasePrompt({
+      ...minimalArgs,
+      provider: "opencode",
+      traits: { ...localTraits, hasToolSearch: false },
+    });
+    expect(result).not.toContain(deferred);
+    expect(result).not.toContain("already in your tool list");
+    expect(result).toContain('await tools.swarm["store-progress"]({ ... })');
+    expect(result).toContain("`search({ query })`");
+  });
+
   test("omitted tool-search capability defaults to direct tools", async () => {
     const result = await getBasePrompt({ ...minimalArgs, traits: localTraits });
     expect(result).not.toContain(deferred);

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

@@ -34,6 +34,7 @@ import {
   resolveCodexModel,
 } from "../providers/codex-models";
 import type { ProviderEvent, ProviderResult, ProviderSessionConfig } from "../providers/types";
+import { isCodexAuthFailureReason } from "../utils/codex-auth-failure";
 import { HELD_NOTE_TEXT, holdTemplateRender } from "./fixtures/held-template-render";
 
 /**
@@ -1177,23 +1178,38 @@ describe("CodexSession event mapping", () => {
     expect(result.failureReason).toContain("[rate-limit]");
   });
 
-  test("turn.failed with auth error rewrites + sets errorCategory=authentication_failed", async () => {
+  test.each([
+    undefined,
+    0,
+    2,
+  ])("turn.failed auth error identifies pool slot %p", async (codexSlot) => {
+    const raw = "Request failed: HTTP 401 Unauthorized — Invalid API key provided.";
     const events: ThreadEvent[] = [
       { type: "thread.started", thread_id: "thread-auth" },
       { type: "turn.started" },
       {
         type: "turn.failed",
-        error: { message: "Request failed: HTTP 401 Unauthorized — Invalid API key provided." },
+        error: { message: raw },
       },
     ];
 
     const { emitted, result } = await runSessionWithFakeThread(
       events,
-      testConfig({ logFile: join(tmpLogDir, "auth.log"), cwd: "" }),
+      testConfig({
+        logFile: join(tmpLogDir, "auth.log"),
+        cwd: "",
+        codexSlot,
+        apiUrl: "",
+        apiKey: "",
+      }),
     );
 
+    const expected =
+      codexSlot === undefined
+        ? `[auth-error] Codex authentication failed — check OPENAI_API_KEY or ChatGPT login. Original error: ${raw}`
+        : `[auth-error] Codex pool slot ${codexSlot} authentication failed — re-run agent-swarm codex-login --slot ${codexSlot}. Original error: ${raw}`;
     const errorEvent = emitted.find((e) => e.type === "error");
-    expect(errorEvent?.type === "error" && errorEvent.message).toContain("[auth-error]");
+    expect(errorEvent?.type === "error" && errorEvent.message).toBe(expected);
 
     const resultEvent = emitted.findLast((e) => e.type === "result");
     expect(resultEvent?.type === "result" && resultEvent.errorCategory).toBe(
@@ -1201,7 +1217,8 @@ describe("CodexSession event mapping", () => {
     );
 
     expect(result.isError).toBe(true);
-    expect(result.failureReason).toContain("[auth-error]");
+    expect(result.failureReason).toBe(expected);
+    expect(isCodexAuthFailureReason(result.failureReason)).toBe(true);
   });
 
   test("abort() resolves the session with cancelled result", async () => {
@@ -2517,7 +2534,9 @@ describe("CodexSession — rate-limit error preservation", () => {
     expect(resetMs).toBeGreaterThan(Date.now());
   });
 
-  test("revoked-while-valid OAuth pool failure ('Failed to refresh token') classifies as [auth-error]/authentication_failed", async () => {
+  test.each([
+    0, 2,
+  ])("revoked-while-valid OAuth failure identifies pool slot %i after transport exit", async (codexSlot) => {
     // A credential revoked server-side while its access token is still
     // unexpired never enters getValidCodexOAuth (the token looks fresh, it
     // fast-returns) — the spawned Codex CLI self-refreshes straight from the
@@ -2534,13 +2553,32 @@ describe("CodexSession — rate-limit error preservation", () => {
     ];
     const sdkThrow = new Error("Codex Exec exited with code 1: Reading prompt from stdin");
 
-    const { result } = await runSessionWithThrowingThread(
+    const { emitted, result } = await runSessionWithThrowingThread(
       events,
       sdkThrow,
-      testConfig({ logFile: join(tmpLogDir, "authfail-preserve.log"), cwd: "" }),
+      testConfig({
+        logFile: join(tmpLogDir, "authfail-preserve.log"),
+        cwd: "",
+        codexSlot,
+        apiUrl: "",
+        apiKey: "",
+      }),
     );
 
     expect(result.failureReason).toMatch(/\[auth-error\]/);
+    expect(result.failureReason).toContain(`pool slot ${codexSlot}`);
+    expect(result.failureReason).toContain(`agent-swarm codex-login --slot ${codexSlot}`);
+    expect(result.failureReason).toContain(refreshFailMsg);
+    expect(isCodexAuthFailureReason(result.failureReason)).toBe(true);
+    const errorEvents = emitted.filter((e) => e.type === "error");
+    expect(errorEvents.length).toBeGreaterThan(0);
+    for (const event of errorEvents) {
+      expect(event.message).toBe(result.failureReason);
+    }
+    const resultEvent = emitted.findLast((e) => e.type === "result");
+    expect(resultEvent?.type === "result" && resultEvent.errorCategory).toBe(
+      "authentication_failed",
+    );
     expect(result.isError).toBe(true);
   });
 

package/src/tests/codex-oauth-device.test.ts

@@ -1,7 +1,14 @@
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, test } from "bun:test";
 import { createServer, type Server } from "node:http";
 import { decryptSecret, encryptSecret, getEncryptionKey } from "../be/crypto";
-import { closeDb, getDbClient, getSwarmConfigs, initDb, upsertSwarmConfig } from "../be/db";
+import {
+  closeDb,
+  getDbClient,
+  getKeyStatuses,
+  getSwarmConfigs,
+  initDb,
+  upsertSwarmConfig,
+} from "../be/db";
 import { getCodexDeviceFlow, upsertCodexDeviceFlow } from "../be/db/codex-oauth-device-flows";
 import type { OnboardingState } from "../be/onboarding";
 import { handleCodexOAuthDevice } from "../http/codex-oauth-device";
@@ -92,6 +99,7 @@ afterAll(async () => {
 beforeEach(async () => {
   await getDbClient().run("DELETE FROM codex_oauth_device_flows");
   await getDbClient().run("DELETE FROM swarm_config");
+  await getDbClient().run("DELETE FROM api_key_status");
   fetchImpl = async () => {
     throw new Error("Unexpected fetch");
   };
@@ -231,6 +239,9 @@ describe("Codex device HTTP routes", () => {
     const onboarding = await getSwarmConfigs({ scope: "global", key: "onboarding_state" });
     const state = JSON.parse(onboarding[0]!.value) as OnboardingState;
     expect(state.steps.ai).toMatchObject({ status: "done", method: "codex_device" });
+    // The sign-in itself checks the account: the account list says "Signed in".
+    const statuses = await getKeyStatuses("CODEX_OAUTH", "global", null);
+    expect(statuses.map((s) => [s.keySuffix, s.keyIndex])).toEqual([["-full", 1]]);
   });
 
   test("throttles upstream polling to the requested interval", async () => {

package/src/tests/comb-config-guard.test.ts

@@ -11,6 +11,15 @@ describe("Comb config keys", () => {
     }
   });
 
+  test("AGENT_FS_PROXY accepts boolean literals only", () => {
+    for (const value of ["true", "false", "1", "0", " TRUE "]) {
+      expect(validateConfigValue("AGENT_FS_PROXY", value)).toBeNull();
+    }
+    for (const value of ["yes", "on", ""]) {
+      expect(validateConfigValue("AGENT_FS_PROXY", value)).toContain("Invalid AGENT_FS_PROXY");
+    }
+  });
+
   test("AGENT_FS_PUBLIC_URL accepts blank or an http(s) base URL", () => {
     for (const value of ["", "http://localhost:7433", "https://agent-fs.example.com/base"]) {
       expect(validateConfigValue("AGENT_FS_PUBLIC_URL", value)).toBeNull();
@@ -28,6 +37,17 @@ describe("Comb config keys", () => {
     }
   });
 
+  test("AGENT_FS_LINK_TARGET accepts dashboard, live, or blank", () => {
+    for (const value of ["dashboard", "live", "", " live "]) {
+      expect(validateConfigValue("AGENT_FS_LINK_TARGET", value)).toBeNull();
+    }
+    for (const value of ["Dashboard2", "comb", true]) {
+      expect(validateConfigValue("AGENT_FS_LINK_TARGET", value)).toContain(
+        "Invalid AGENT_FS_LINK_TARGET",
+      );
+    }
+  });
+
   test("OPENROUTER_BASE_URL keeps its rules after sharing the URL validator", () => {
     expect(validateConfigValue("OPENROUTER_BASE_URL", "")).toBeNull();
     expect(validateConfigValue("OPENROUTER_BASE_URL", "https://api.example.com/v1")).toBeNull();

package/src/tests/comb-links.test.ts

@@ -1,7 +1,12 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { buildCitationUrl } from "../be/task-citations";
 import type { TaskAttachment } from "../types";
-import { buildAgentFsLiveUrl, buildCombFileUrl } from "../utils/constants";
+import {
+  buildAgentFsLiveUrl,
+  buildCombFileUrl,
+  readAgentFsLinkTarget,
+  resolveAgentFsLinkBase,
+} from "../utils/constants";
 import { taskAttachmentDisplayUrl } from "../utils/task-attachment-links";
 
 const ENV_KEYS = [
@@ -10,6 +15,7 @@ const ENV_KEYS = [
   "DASHBOARD_URL",
   "AGENT_FS_API_URL",
   "AGENT_FS_LIVE_URL",
+  "AGENT_FS_LINK_TARGET",
   "AGENT_FS_DEFAULT_ORG_ID",
   "AGENT_FS_DEFAULT_DRIVE_ID",
 ] as const;
@@ -160,3 +166,75 @@ describe("agent-fs citations", () => {
     ).toBe(COMB);
   });
 });
+
+describe("AGENT_FS_LINK_TARGET", () => {
+  test("unset: no target, and attachments keep the automatic choice", () => {
+    expect(readAgentFsLinkTarget()).toBeNull();
+    expect(resolveAgentFsLinkBase("attachment")).toBeNull();
+    expect(resolveAgentFsLinkBase("prompt")).toBeNull();
+    expect(taskAttachmentDisplayUrl(agentFsAttachment())).toBe(LIVE);
+    process.env.COMB_ENABLED = "true";
+    process.env.APP_URL = "http://localhost:5274";
+    expect(taskAttachmentDisplayUrl(agentFsAttachment())).toBe(COMB);
+  });
+
+  test("live on a Comb + APP_URL install: the live URL", () => {
+    process.env.COMB_ENABLED = "true";
+    process.env.APP_URL = "http://localhost:5274";
+    process.env.AGENT_FS_LINK_TARGET = " Live ";
+    expect(readAgentFsLinkTarget()).toBe("live");
+    expect(taskAttachmentDisplayUrl(agentFsAttachment())).toBe(LIVE);
+    expect(resolveAgentFsLinkBase("prompt")).toBe("https://live.example.test");
+  });
+
+  test("dashboard with Comb on and APP_URL: the dashboard URL", () => {
+    process.env.COMB_ENABLED = "true";
+    process.env.APP_URL = "http://localhost:5274/";
+    process.env.AGENT_FS_LINK_TARGET = "dashboard";
+    expect(taskAttachmentDisplayUrl(agentFsAttachment())).toBe(COMB);
+    expect(resolveAgentFsLinkBase("prompt")).toBe("http://localhost:5274");
+  });
+
+  test("dashboard with Comb off: attachments use the live URL, the prompt still uses APP_URL", () => {
+    process.env.APP_URL = "http://localhost:5274";
+    process.env.AGENT_FS_LINK_TARGET = "dashboard";
+    expect(taskAttachmentDisplayUrl(agentFsAttachment())).toBe(LIVE);
+    expect(resolveAgentFsLinkBase("attachment")).toBe("https://live.example.test");
+    expect(resolveAgentFsLinkBase("prompt")).toBe("http://localhost:5274");
+  });
+
+  test("dashboard without APP_URL: the live URL on both surfaces", () => {
+    process.env.COMB_ENABLED = "true";
+    process.env.AGENT_FS_LINK_TARGET = "dashboard";
+    expect(taskAttachmentDisplayUrl(agentFsAttachment())).toBe(LIVE);
+    expect(resolveAgentFsLinkBase("prompt")).toBe("https://live.example.test");
+  });
+
+  test("an invalid or blank value counts as unset", () => {
+    process.env.COMB_ENABLED = "true";
+    process.env.APP_URL = "http://localhost:5274";
+    for (const value of ["Dashboard2", "comb", "", "   "]) {
+      process.env.AGENT_FS_LINK_TARGET = value;
+      expect(readAgentFsLinkTarget()).toBeNull();
+      expect(resolveAgentFsLinkBase("prompt")).toBeNull();
+      expect(taskAttachmentDisplayUrl(agentFsAttachment())).toBe(COMB);
+    }
+  });
+
+  test("comb: false still links to the live URL", () => {
+    process.env.COMB_ENABLED = "true";
+    process.env.APP_URL = "http://localhost:5274";
+    process.env.AGENT_FS_LINK_TARGET = "dashboard";
+    expect(taskAttachmentDisplayUrl(agentFsAttachment(), { comb: false })).toBe(LIVE);
+  });
+
+  test("a bad path still falls back to agent-fs:<path>", () => {
+    process.env.COMB_ENABLED = "true";
+    process.env.APP_URL = "http://localhost:5274";
+    process.env.AGENT_FS_LINK_TARGET = "dashboard";
+    expect(taskAttachmentDisplayUrl(agentFsAttachment({ path: "../x" }))).toBe("agent-fs:../x");
+    expect(
+      taskAttachmentDisplayUrl(agentFsAttachment({ orgId: undefined, driveId: undefined })),
+    ).toBe("agent-fs:comb-qa/notes.md");
+  });
+});

package/src/tests/comb-status.test.ts

@@ -15,6 +15,9 @@ const ENV_KEYS = [
   "AGENT_FS_DEFAULT_DRIVE_ID",
   "API_AGENT_FS_API_KEY",
   "AGENT_FS_API_KEY",
+  "AGENT_FS_PROXY",
+  "PUBLIC_MCP_BASE_URL",
+  "MCP_BASE_URL",
 ];
 const savedEnv = new Map<string, string | undefined>();
 
@@ -92,6 +95,47 @@ describe("/status agent_fs.comb", () => {
     expect((await comb()).api_url).toBe("https://files.example.com");
   });
 
+  test("AGENT_FS_PROXY on and a blank public URL: api_url is <PUBLIC_MCP_BASE_URL>/agentfs", async () => {
+    process.env.COMB_ENABLED = "true";
+    process.env.AGENT_FS_API_URL = "http://agent-fs:7433";
+    process.env.MCP_BASE_URL = "http://swarm-api:3013";
+    process.env.PUBLIC_MCP_BASE_URL = "https://swarm.example.com/";
+    for (const value of ["true", " TRUE ", "1"]) {
+      process.env.AGENT_FS_PROXY = value;
+      expect((await comb()).api_url).toBe("https://swarm.example.com/agentfs");
+    }
+    process.env.AGENT_FS_PUBLIC_URL = "  ";
+    expect((await comb()).api_url).toBe("https://swarm.example.com/agentfs");
+    // No public URL: falls back to MCP_BASE_URL.
+    delete process.env.PUBLIC_MCP_BASE_URL;
+    expect((await comb()).api_url).toBe("http://swarm-api:3013/agentfs");
+  });
+
+  test("AGENT_FS_PROXY on: an explicit AGENT_FS_PUBLIC_URL still wins", async () => {
+    process.env.COMB_ENABLED = "true";
+    process.env.AGENT_FS_API_URL = "http://agent-fs:7433";
+    process.env.PUBLIC_MCP_BASE_URL = "https://swarm.example.com";
+    process.env.AGENT_FS_PROXY = "true";
+    process.env.AGENT_FS_PUBLIC_URL = "https://files.example.com/";
+    expect((await comb()).api_url).toBe("https://files.example.com");
+  });
+
+  test("AGENT_FS_PROXY off or without AGENT_FS_API_URL: api_url unchanged", async () => {
+    process.env.COMB_ENABLED = "true";
+    process.env.AGENT_FS_API_URL = "http://agent-fs:7433";
+    process.env.PUBLIC_MCP_BASE_URL = "https://swarm.example.com";
+    for (const value of [undefined, "false", "0", ""]) {
+      if (value === undefined) delete process.env.AGENT_FS_PROXY;
+      else process.env.AGENT_FS_PROXY = value;
+      expect((await comb()).api_url).toBe("http://agent-fs:7433");
+    }
+    process.env.AGENT_FS_PROXY = "true";
+    delete process.env.AGENT_FS_API_URL;
+    const result = await comb();
+    expect(result.enabled).toBe(false);
+    expect(result.api_url).toBeNull();
+  });
+
   test("ids come from AGENT_FS_DEFAULT_*, and live_url from AGENT_FS_LIVE_URL", async () => {
     process.env.COMB_ENABLED = "true";
     process.env.AGENT_FS_API_URL = "http://agent-fs:7433";

package/src/tests/docs-index-footprint.test.js

@@ -78,7 +78,7 @@ describe("docs API index footprint", () => {
     expect(tasks).toContain('"path":"/api/task-templates","method":"get"');
   });
 
-  test("OpenAPI and generated pages keep all 456 operations", async () => {
+  test("OpenAPI and generated pages keep all 466 operations", async () => {
     const spec = await Bun.file(resolve(repoRoot, "openapi.json")).json();
     const operationKeys = [];
     const tags = new Set();
@@ -103,8 +103,8 @@ describe("docs API index footprint", () => {
     expect(spec.paths["/api/agents/{id}/runtime"]?.get).toBeDefined();
 
     const generatedKeys = await generatedOperationKeys();
-    expect(operationKeys).toHaveLength(456);
-    expect(generatedKeys).toHaveLength(456);
+    expect(operationKeys).toHaveLength(466);
+    expect(generatedKeys).toHaveLength(466);
     expect(new Set(generatedKeys)).toEqual(new Set(operationKeys));
   });
 

package/src/tests/fixtures/onboard/baseline-states.ts

@@ -0,0 +1,68 @@
+import { getPresetById } from "../../../commands/onboard/presets.ts";
+import { INITIAL_STATE, type OnboardState } from "../../../commands/onboard/types.ts";
+
+/**
+ * Deterministic onboard states, one per unattended preset plus one variant
+ * with every integration, Bedrock (profile) and Podman. The fixtures next to
+ * this file hold the compose and .env these states rendered before the
+ * agent-fs bundle existed, so flag-off output stays byte-identical.
+ */
+export const BASELINE_PRESET_IDS = ["full", "dev", "content", "research", "solo"] as const;
+
+function agentIdsFor(state: Pick<OnboardState, "services">): Record<string, string> {
+  const ids: Record<string, string> = {};
+  let n = 0;
+  const next = () => `00000000-0000-4000-8000-${String(++n).padStart(12, "0")}`;
+  for (const svc of state.services) {
+    if (svc.count === 1) {
+      ids[svc.isLead ? "lead" : `worker-${svc.role}`] = next();
+    } else {
+      for (let i = 1; i <= svc.count; i++) ids[`worker-${svc.role}-${i}`] = next();
+    }
+  }
+  return ids;
+}
+
+export function baselineState(presetId: string, variant: "default" | "all" = "default") {
+  const preset = getPresetById(presetId);
+  if (!preset) throw new Error(`unknown preset ${presetId}`);
+  const base: OnboardState = {
+    ...INITIAL_STATE,
+    nonInteractive: true,
+    presetId: preset.id,
+    services: preset.services,
+    apiKey: "example-test-api-key",
+    claudeOAuthToken: "example-test-oauth",
+    outputDir: "/tmp/onboard-fixture",
+  };
+  base.agentIds = agentIdsFor(base);
+  if (variant === "default") return base;
+  return {
+    ...base,
+    provider: "bedrock",
+    harness: "pi",
+    awsRegion: "us-east-1",
+    awsProfile: "example-profile",
+    modelOverride: "example-model",
+    containerEngine: "podman",
+    pullPolicy: "missing",
+    apiPort: 3999,
+    maxConcurrentTasks: 3,
+    integrations: { github: true, slack: true, gitlab: true, sentry: true },
+    githubToken: "example-gh",
+    githubEmail: "dev@example.com",
+    githubName: "Example Dev",
+    slackBotToken: "example-slack-bot",
+    slackSigningSecret: "example-slack-signing",
+    slackMode: "http",
+    gitlabToken: "example-gitlab",
+    gitlabEmail: "dev@example.com",
+    sentryToken: "example-sentry",
+    sentryOrg: "example-org",
+  } satisfies OnboardState;
+}
+
+export const BASELINE_CASES: { name: string; state: OnboardState }[] = [
+  ...BASELINE_PRESET_IDS.map((id) => ({ name: id, state: baselineState(id) })),
+  { name: "full-all", state: baselineState("full", "all") },
+];