@desplega.ai/agent-swarm 2.5.4 → 2.6.0

package/src/slack/assistant.ts

@@ -213,6 +213,10 @@ export function createAssistant(): Assistant {
           buildEffectiveText(messageText, inbound.files, inbound.failed, inbound.notes),
           cachedBotUserId ?? undefined,
         );
+        const slack = {
+          trigger: "mention" as const,
+          messages: [{ ts: message.ts, userId, text: messageText }],
+        };
 
         if (workingAgent && workingAgent.status !== "offline") {
           // Otherwise, create a follow-up task for the working agent
@@ -236,6 +240,7 @@ export function createAssistant(): Assistant {
               contextKey: slackContextKey({ channelId, threadTs }),
             },
             inbound,
+            slack,
           );
           await ackSlackMessage(
             client,
@@ -285,6 +290,7 @@ export function createAssistant(): Assistant {
               contextKey: slackContextKey({ channelId, threadTs }),
             },
             inbound,
+            slack,
           );
           await ackSlackMessage(
             client,
@@ -318,6 +324,7 @@ export function createAssistant(): Assistant {
             contextKey: slackContextKey({ channelId, threadTs }),
           },
           inbound,
+          slack,
         );
         await ackSlackMessage(client, channelId, message.ts, reactionName("accepted"), "accepted");
         await notifySlackFileFailures(client, channelId, threadTs, unattached);

package/src/slack/channel-labels.ts

@@ -0,0 +1,74 @@
+import type { WebClient } from "@slack/web-api";
+import { rememberSessionLabel } from "../be/db/session-labels";
+import { getSlackApp } from "./app";
+import { callSlackWithRetry, slackErrorCode } from "./render-v2";
+
+const LABEL_TTL_MS = 24 * 60 * 60 * 1000;
+const FAILURE_TTL_MS = 10 * 60 * 1000;
+const FAILURE_CACHE_MAX = 500;
+const LOOKUP_QUEUE_MAX = 50;
+const inFlight = new Set<string>();
+const failedUntil = new Map<string, number>();
+let pending = Promise.resolve();
+
+async function channelLabel(client: WebClient, id: string): Promise<string> {
+  const result = await callSlackWithRetry(client, "conversations.info", {
+    channel: id.toUpperCase(),
+  });
+  const channel = result.channel as
+    | { name?: string; is_im?: boolean; is_mpim?: boolean; user?: string }
+    | undefined;
+  if (result.ok === false || !channel) throw new Error("Channel lookup failed");
+  if (channel.is_mpim) return "Group DM";
+  if (channel.is_im && channel.user) {
+    const result = await callSlackWithRetry(client, "users.info", { user: channel.user });
+    const user = result.user as
+      | { profile?: { display_name?: string; real_name?: string }; real_name?: string }
+      | undefined;
+    const name = user?.profile?.display_name || user?.real_name || user?.profile?.real_name;
+    if (result.ok !== false && name) return `DM · ${name}`;
+  } else if (channel.name) {
+    return `#${channel.name}`;
+  }
+  throw new Error("Channel label unavailable");
+}
+
+const CHANNEL_GROUP_KEY = /^shared\/slack\/([^/]+)\/$/;
+
+/**
+ * Queue a Slack lookup for each channel group key (`shared/slack/<channel>/`)
+ * without delaying the tree response. Other keys are ignored.
+ */
+export function warmSlackChannelLabels(groupKeys: string[]): void {
+  const client = getSlackApp()?.client;
+  if (!client) return;
+  for (const groupKey of groupKeys) {
+    const id = CHANNEL_GROUP_KEY.exec(groupKey)?.[1];
+    if (!id) continue;
+    if (inFlight.has(id) || (failedUntil.get(id) ?? 0) > Date.now()) continue;
+    failedUntil.delete(id);
+    if (inFlight.size >= LOOKUP_QUEUE_MAX) continue;
+    // Reserve failure capacity for queued work. Live failures must retain their TTL.
+    if (failedUntil.size + inFlight.size >= FAILURE_CACHE_MAX) {
+      const now = Date.now();
+      for (const [failedId, until] of failedUntil) {
+        if (until <= now) failedUntil.delete(failedId);
+      }
+      if (failedUntil.size + inFlight.size >= FAILURE_CACHE_MAX) continue;
+    }
+    inFlight.add(id);
+    pending = pending.then(async () => {
+      try {
+        const label = await channelLabel(client, id);
+        await rememberSessionLabel(groupKey, label, LABEL_TTL_MS);
+      } catch (error) {
+        failedUntil.set(id, Date.now() + FAILURE_TTL_MS);
+        console.warn(
+          `[Slack] Could not cache a session channel label: ${slackErrorCode(error) ?? "unknown error"}`,
+        );
+      } finally {
+        inFlight.delete(id);
+      }
+    });
+  }
+}

package/src/slack/handlers.ts

@@ -679,6 +679,11 @@ export function registerMessageHandler(app: App): void {
       routingThreadContext,
     );
 
+    const slack = {
+      trigger: "mention" as const,
+      messages: [{ ts: msg.ts, userId: msg.user, text: msg.text ?? "" }],
+    };
+
     if (matches.length === 0) {
       if (!botMentioned && !isImplicitMention) return ignoreSlackInbound("not_addressed");
 
@@ -742,6 +747,7 @@ export function registerMessageHandler(app: App): void {
           contextKey: slackContextKey({ channelId: msg.channel, threadTs }),
         },
         inbound,
+        slack,
       );
       await ackSlackMessage(client, msg.channel, msg.ts, reactionName("accepted"), "accepted");
       await notifySlackFileFailures(client, msg.channel, threadTs, unattached);
@@ -864,6 +870,7 @@ export function registerMessageHandler(app: App): void {
               contextKey: slackContextKey({ channelId: msg.channel, threadTs }),
             },
             inbound,
+            slack,
           );
           const { task } = created;
           unattached.push(...created.unattached);
@@ -888,6 +895,7 @@ export function registerMessageHandler(app: App): void {
             contextKey: slackContextKey({ channelId: msg.channel, threadTs }),
           },
           inbound,
+          slack,
         );
         const { task } = created;
         unattached.push(...created.unattached);

package/src/slack/inbound-files.ts

@@ -22,6 +22,7 @@ import { join } from "node:path";
 import type { WebClient } from "@slack/web-api";
 import { getTaskAttachments, getTaskById, promoteDraftTask, refreshDraftTaskLease } from "../be/db";
 import { MAX_TASK_ATTACHMENT_BYTES, recordTaskAttachmentUpload } from "../be/task-attachment-store";
+import type { TaskCreateEvent } from "../extensions/contract";
 import { providerPath } from "../fs/provider";
 import { getFileStorageProvider } from "../fs/registry";
 import { resolveTemplate } from "../prompts/resolver";
@@ -320,17 +321,19 @@ export async function createSlackTaskWithFiles(
   description: string,
   options: CreateTaskOptions,
   inbound: InboundSlackFiles,
+  slack?: TaskCreateEvent["slack"],
 ): Promise<{ task: AgentTask; unattached: SlackFileFailure[] }> {
   noteSlackInboundSideEffect("task_created");
+  const context = { origin: "slack" as const, slack };
   if (inbound.fetched.length === 0) {
-    const task = await createTaskWithSiblingAwareness(description, options, { origin: "slack" });
+    const task = await createTaskWithSiblingAwareness(description, options, context);
     return { task, unattached: inbound.failed };
   }
 
   const task = await createTaskWithSiblingAwareness(
     description,
     { ...options, status: "draft" },
-    { origin: "slack" },
+    context,
   );
   const unattached = [...inbound.failed];
   // Uploads run one after another and can outlast the abandoned-draft sweep's

package/src/slack/thread-buffer.ts

@@ -313,6 +313,10 @@ async function slackFlush(
         contextKey: slackContextKey({ channelId, threadTs }),
       },
       inbound,
+      {
+        trigger: "thread-buffer",
+        messages: items.map(({ ts, userId, text }) => ({ ts, userId, text })),
+      },
     );
   } catch (error) {
     if (!(error instanceof TaskCreationBlockedError)) throw error;

package/src/tasks/sibling-awareness.ts

@@ -18,7 +18,7 @@ import {
   getInProgressTasksByContextKey,
 } from "../be/db";
 import { applyPreTaskCreate } from "../extensions/apply-task-create";
-import type { TaskCreateOrigin } from "../extensions/contract";
+import type { TaskCreateEvent, TaskCreateOrigin } from "../extensions/contract";
 import type { AgentTask } from "../types";
 import { TaskCreationBlockedError } from "./errors";
 import {
@@ -151,7 +151,11 @@ export type PreparedTaskCreate = { description: string; options: CreateTaskOptio
 export async function prepareTaskWithSiblingAwareness(
   description: string,
   options: CreateTaskOptions,
-  args: { origin?: TaskCreateOrigin; allowCustomModel?: boolean } = {},
+  args: {
+    origin?: TaskCreateOrigin;
+    allowCustomModel?: boolean;
+    slack?: TaskCreateEvent["slack"];
+  } = {},
 ): Promise<PreparedTaskCreate> {
   const preCreate = await applyPreTaskCreate({
     description,
@@ -159,6 +163,7 @@ export async function prepareTaskWithSiblingAwareness(
     // Preserve the plan's REST default for callers without an explicit ingress origin.
     origin: args.origin ?? "rest",
     allowCustomModel: args.allowCustomModel,
+    slack: args.slack,
   });
   if (preCreate.kind === "blocked") {
     throw new TaskCreationBlockedError(preCreate.reason, preCreate.extension);
@@ -169,7 +174,11 @@ export async function prepareTaskWithSiblingAwareness(
 export async function createTaskWithSiblingAwareness(
   description: string,
   options: CreateTaskOptions,
-  args: { origin?: TaskCreateOrigin; allowCustomModel?: boolean } = {},
+  args: {
+    origin?: TaskCreateOrigin;
+    allowCustomModel?: boolean;
+    slack?: TaskCreateEvent["slack"];
+  } = {},
 ): Promise<AgentTask> {
   const { description: d, options: o } = await prepareTaskWithSiblingAwareness(
     description,

package/src/telemetry-context.ts

@@ -12,8 +12,8 @@ import catalog from "./telemetry-contract/catalog.json";
 import {
   COMPANY_ACQUISITION_SOURCES,
   COMPANY_TEAM_SIZES,
-  COMPANY_USE_CASES,
-  USER_FUNCTIONS,
+  reportedUseCase,
+  reportedUserFunction,
 } from "./utils/company-profile";
 
 /** `org_` + 16 lowercase hex (self-host, minted here) or 27 alphanumerics (cloud). Same pattern the proxy enforces. */
@@ -115,10 +115,9 @@ export function buildContext(input: ContextInput): EventContext {
   const orgDomain = validOrgDomain(input.orgDomain);
   const orgWebsite = validOrgDomain(input.orgWebsite);
   const teamSize = COMPANY_TEAM_SIZES.find((value) => value === input.teamSize);
-  const useCase = COMPANY_USE_CASES.find((value) => value === input.useCase);
-  const userFunction = userId
-    ? USER_FUNCTIONS.find((value) => value === input.userFunction)
-    : undefined;
+  // A value the catalog does not list yet is left out, as if unset.
+  const useCase = reportedUseCase(input.useCase);
+  const userFunction = userId ? reportedUserFunction(input.userFunction) : undefined;
   return {
     org_id: input.orgId,
     org_name: orgName ? orgName : null,

package/src/telemetry-identity.ts

@@ -13,7 +13,7 @@
 import { getDbClient } from "./be/db/runtime";
 import { setTelemetryOrgDomain } from "./telemetry";
 import { emailDomain, type TelemetryUserRole } from "./telemetry-context";
-import { USER_FUNCTIONS } from "./utils/company-profile";
+import { reportedUserFunction } from "./utils/company-profile";
 
 const ROLE_TTL_MS = 60 * 60_000;
 const ROLE_CACHE_LIMIT = 1_000;
@@ -21,7 +21,7 @@ const DOMAIN_RECOMPUTE_DEBOUNCE_MS = 2_000;
 
 interface UserRoleEntry {
   role: TelemetryUserRole;
-  userFunction?: (typeof USER_FUNCTIONS)[number];
+  userFunction?: ReturnType<typeof reportedUserFunction>;
   at: number;
 }
 
@@ -40,7 +40,7 @@ async function loadUserRole(userId: string): Promise<UserRoleEntry | undefined>
     );
     return {
       role,
-      userFunction: USER_FUNCTIONS.find((value) => value === user?.jobFunction),
+      userFunction: reportedUserFunction(user?.jobFunction),
       at: Date.now(),
     };
   } catch {

package/src/tests/api-keys-validation.test.ts

@@ -0,0 +1,170 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { Readable } from "node:stream";
+import {
+  closeDb,
+  getAvailableKeyIndices,
+  getDbClient,
+  getKeyStatuses,
+  initDb,
+  recordKeyValidation,
+} from "../be/db";
+import { handleApiKeys } from "../http/api-keys";
+import { getPathSegments, parseQueryParams } from "../http/utils";
+
+const TEST_DB = "./test-api-keys-validation.sqlite";
+const keyType = "ANTHROPIC_API_KEY";
+const rejected = { keyIndex: 0, keySuffix: "aaa11", ok: false, httpStatus: 401 };
+
+async function call(method: string, url: string, body?: unknown) {
+  const req = Readable.from(body === undefined ? [] : [Buffer.from(JSON.stringify(body))]);
+  Object.assign(req, { method, url, headers: { "content-type": "application/json" } });
+  let statusCode = 200;
+  let responseBody = "";
+  const res = {
+    setHeader: () => {},
+    writeHead: (code: number) => {
+      statusCode = code;
+    },
+    end: (chunk?: string) => {
+      responseBody += chunk ?? "";
+    },
+  };
+  const handled = await handleApiKeys(
+    req as never,
+    res as never,
+    getPathSegments(url),
+    parseQueryParams(url),
+  );
+  return { handled, statusCode, body: JSON.parse(responseBody) };
+}
+
+describe("pooled key validation", () => {
+  beforeAll(() => {
+    initDb(TEST_DB);
+  });
+  beforeEach(async () => {
+    await getDbClient().run("DELETE FROM api_key_status");
+  });
+  afterAll(async () => {
+    closeDb();
+    for (const suffix of ["", "-wal", "-shm"]) {
+      await Bun.file(TEST_DB + suffix)
+        .delete()
+        .catch(() => {});
+    }
+  });
+
+  test("HTTP 401 marks the key as rejected", async () => {
+    await recordKeyValidation(keyType, [{ ...rejected, httpStatus: 401 }]);
+    const [row] = await getKeyStatuses(keyType);
+    expect(row).toMatchObject({
+      keyIndex: 0,
+      keySuffix: "aaa11",
+      provider: "claude",
+      lastValidationError: "HTTP 401",
+    });
+    expect(row!.lastValidationFailedAt).not.toBeNull();
+  });
+
+  test("a pass clears rejection and updates the index", async () => {
+    await recordKeyValidation(keyType, [rejected]);
+    await recordKeyValidation(keyType, [{ ...rejected, keyIndex: 2, ok: true }]);
+    expect((await getKeyStatuses(keyType))[0]).toMatchObject({
+      keyIndex: 2,
+      lastValidationError: null,
+      lastValidationFailedAt: null,
+    });
+  });
+
+  // 403 included: a valid key can lack the scope of the list endpoint.
+  test.each([
+    403,
+    500,
+    429,
+    undefined,
+  ])("failure with status %s preserves existing state", async (httpStatus) => {
+    await recordKeyValidation(keyType, [rejected]);
+    const before = await getKeyStatuses(keyType);
+    await recordKeyValidation(keyType, [{ ...rejected, keyIndex: 3, httpStatus }]);
+    expect(await getKeyStatuses(keyType)).toEqual(before);
+    await recordKeyValidation("OPENAI_API_KEY", [{ ...rejected, httpStatus }]);
+    expect(await getKeyStatuses("OPENAI_API_KEY")).toEqual([]);
+  });
+
+  test("a removed suffix cannot block a replacement at the same index", async () => {
+    await recordKeyValidation(keyType, [rejected]);
+    await recordKeyValidation(keyType, [{ keyIndex: 0, keySuffix: "bbb22", ok: true }]);
+    const rows = await getKeyStatuses(keyType);
+    expect(rows.find((row) => row.keySuffix === "aaa11")).toMatchObject({
+      lastValidationError: null,
+      lastValidationFailedAt: null,
+    });
+    expect((await getAvailableKeyIndices(keyType, 1)).availableIndices).toEqual([0]);
+  });
+
+  test("rejections and removed-suffix cleanup stay within their scope and key type", async () => {
+    await recordKeyValidation(keyType, [rejected], "agent", "agent-a");
+    await recordKeyValidation(keyType, [rejected], "agent", "agent-b");
+    await recordKeyValidation("OPENAI_API_KEY", [rejected], "agent", "agent-a");
+    await recordKeyValidation(
+      keyType,
+      [{ keyIndex: 0, keySuffix: "bbb22", ok: true }],
+      "agent",
+      "agent-a",
+    );
+    expect((await getAvailableKeyIndices(keyType, 1, "agent", "agent-a")).availableIndices).toEqual(
+      [0],
+    );
+    expect((await getAvailableKeyIndices(keyType, 1, "agent", "agent-b")).availableIndices).toEqual(
+      [],
+    );
+    expect(
+      (await getAvailableKeyIndices("OPENAI_API_KEY", 1, "agent", "agent-a")).availableIndices,
+    ).toEqual([]);
+  });
+
+  test("availability excludes rejected keys and reports their indices", async () => {
+    await recordKeyValidation(keyType, [rejected, { keyIndex: 1, keySuffix: "bbb22", ok: true }]);
+    expect(await getAvailableKeyIndices(keyType, 3)).toMatchObject({
+      availableIndices: [1, 2],
+      rejectedIndices: [0],
+    });
+  });
+
+  test("availability is empty when every key is rejected", async () => {
+    await recordKeyValidation(keyType, [
+      rejected,
+      { ...rejected, keyIndex: 1, keySuffix: "bbb22" },
+    ]);
+    expect(await getAvailableKeyIndices(keyType, 2)).toMatchObject({
+      availableIndices: [],
+      rejectedIndices: [0, 1],
+    });
+  });
+
+  test("the report handler records validation and exposes it in reads", async () => {
+    expect(
+      await call("POST", "/api/keys/report-validation", { keyType, keys: [rejected] }),
+    ).toEqual({
+      handled: true,
+      statusCode: 200,
+      body: { success: true, message: "Key validation recorded" },
+    });
+    expect(
+      (await call("GET", `/api/keys/available?keyType=${keyType}&totalKeys=2`)).body,
+    ).toMatchObject({
+      availableIndices: [1],
+      rejectedIndices: [0],
+    });
+    const status = await call("GET", `/api/keys/status?keyType=${keyType}`);
+    expect(status.body.keys[0]).toMatchObject({ lastValidationError: "HTTP 401" });
+    expect(status.body.keys[0].lastValidationFailedAt).not.toBeNull();
+  });
+
+  test("the report handler rejects an empty pool", async () => {
+    expect(
+      (await call("POST", "/api/keys/report-validation", { keyType, keys: [] })).statusCode,
+    ).toBe(400);
+    expect(await getKeyStatuses(keyType)).toEqual([]);
+  });
+});

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

@@ -59,6 +59,52 @@ describe("ClaudeManagedAdapter (Phase 1 skeleton)", () => {
     expect(adapter.formatCommand("plan")).toBe("/plan");
   });
 
+  for (const source of ["container", "task", "task-pool"] as const) {
+    test(`uses one Anthropic key from ${source}`, async () => {
+      const originalFetch = globalThis.fetch;
+      const originalKey = process.env.ANTHROPIC_API_KEY;
+      let apiKey: string | null = null;
+      process.env.ANTHROPIC_API_KEY = "example-container-first,example-container-second";
+      globalThis.fetch = (async (input, init) => {
+        apiKey =
+          new Request(input, init).headers.get("authorization")?.slice("Bearer ".length) ?? null;
+        return Response.json(
+          { error: { type: "authentication_error", message: "test rejection" } },
+          { status: 401 },
+        );
+      }) as typeof fetch;
+      try {
+        const adapter = new ClaudeManagedAdapter();
+        await expect(
+          adapter.createSession(
+            tConfig({
+              env:
+                source === "container"
+                  ? {}
+                  : {
+                      ANTHROPIC_API_KEY:
+                        source === "task"
+                          ? "example-task"
+                          : "example-task-first,example-task-second",
+                    },
+            }),
+          ),
+        ).rejects.toThrow("test rejection");
+        expect(
+          source === "container"
+            ? ["example-container-first", "example-container-second"]
+            : source === "task"
+              ? ["example-task"]
+              : ["example-task-first", "example-task-second"],
+        ).toContain(apiKey);
+      } finally {
+        globalThis.fetch = originalFetch;
+        if (originalKey === undefined) delete process.env.ANTHROPIC_API_KEY;
+        else process.env.ANTHROPIC_API_KEY = originalKey;
+      }
+    });
+  }
+
   test("ctor throws when MANAGED_AGENT_ID is missing", () => {
     const saved = process.env.MANAGED_AGENT_ID;
     delete process.env.MANAGED_AGENT_ID;

package/src/tests/claude-routes-e2e.test.ts

@@ -10,10 +10,10 @@
  * auth redacted.
  */
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import { existsSync, mkdtempSync, rmSync } from "node:fs";
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { createRequire } from "node:module";
 import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
+import { basename, dirname, join } from "node:path";
 import { deriveDefaultRoute } from "@desplega/model-routing";
 import { closeDb, createAgent, getAgentById, initDb, updateAgentCredentialState } from "../be/db";
 import { awaitCredentials } from "../commands/credential-wait";
@@ -240,6 +240,11 @@ describe.skipIf(!CLAUDE_BINARY)("claude routes e2e (real CLI, fake endpoints)",
 
           expect(result).toMatchObject({ isError: false, exitCode: 0 });
           expect(result.output).toContain(REPLY);
+          // Trust lands in the session's HOME, never in the host's ~/.claude.json.
+          const claudeJson = JSON.parse(readFileSync(join(env.HOME ?? "", ".claude.json"), "utf8"));
+          expect(
+            Object.keys(claudeJson.projects ?? {}).some((dir) => dir.endsWith(basename(cwd))),
+          ).toBe(true);
 
           const turn = fake.requests.find(
             (req) => req.method === "POST" && route.turnPath.test(req.path),

package/src/tests/codex-credential-pools.test.ts

@@ -0,0 +1,120 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { CodexAdapter } from "../providers/codex-adapter";
+import type { ProviderSessionConfig } from "../providers/types";
+
+const keyVars = ["OPENAI_API_KEY", "OPENROUTER_API_KEY", "ANTHROPIC_API_KEY"];
+let savedEnv: Record<string, string | undefined>;
+let home: string;
+
+beforeEach(async () => {
+  savedEnv = Object.fromEntries(["HOME", ...keyVars].map((key) => [key, process.env[key]]));
+  home = await mkdtemp(join(tmpdir(), "credential-validation-codex-"));
+  process.env.HOME = home;
+  for (const key of keyVars) process.env[key] = "example-first, example-second";
+});
+
+afterEach(async () => {
+  for (const [key, value] of Object.entries(savedEnv)) {
+    if (value === undefined) delete process.env[key];
+    else process.env[key] = value;
+  }
+  await rm(home, { recursive: true, force: true });
+});
+
+function config(env?: Record<string, string>): ProviderSessionConfig {
+  return {
+    agentId: crypto.randomUUID(),
+    prompt: "test",
+    systemPrompt: "",
+    cwd: home,
+    logFile: "/dev/null",
+    env,
+  };
+}
+
+describe("Codex credential pools", () => {
+  for (const source of ["container", "task", "task-pool"] as const) {
+    test(`app-server uses one OpenAI key from ${source}`, async () => {
+      let capturedEnv: Record<string, string> | undefined;
+      const adapter = new CodexAdapter({
+        bypassSubprocess: true,
+        appServerFactory: ({ env }) => {
+          capturedEnv = env;
+          throw new Error("test stops before app-server spawn");
+        },
+      });
+      const env =
+        source === "container"
+          ? {}
+          : {
+              OPENAI_API_KEY:
+                source === "task" ? "example-task" : "example-task-first, example-task-second",
+            };
+      await expect(adapter.createSession(config(env))).rejects.toThrow(
+        "test stops before app-server spawn",
+      );
+      expect(
+        source === "container"
+          ? ["example-first", "example-second"]
+          : source === "task"
+            ? ["example-task"]
+            : ["example-task-first", "example-task-second"],
+      ).toContain(capturedEnv?.OPENAI_API_KEY);
+    });
+
+    test(`subprocess forwards one key per provider from ${source}`, async () => {
+      let capturedEnv: Record<string, string | undefined> | undefined;
+      const spawn = spyOn(Bun, "spawn").mockImplementation(((
+        ...args: Parameters<typeof Bun.spawn>
+      ) => {
+        capturedEnv = args[1]?.env;
+        throw new Error("test stops before subprocess spawn");
+      }) as typeof Bun.spawn);
+      try {
+        const env =
+          source === "container"
+            ? {}
+            : Object.fromEntries(
+                keyVars.map((key) => [
+                  key,
+                  source === "task" ? "example-task" : "example-task-first, example-task-second",
+                ]),
+              );
+        await expect(new CodexAdapter().createSession(config(env))).rejects.toThrow(
+          "test stops before subprocess spawn",
+        );
+        for (const key of keyVars) {
+          expect(
+            source === "container"
+              ? ["example-first", "example-second"]
+              : source === "task"
+                ? ["example-task"]
+                : ["example-task-first", "example-task-second"],
+          ).toContain(capturedEnv?.[key]);
+        }
+      } finally {
+        spawn.mockRestore();
+      }
+    });
+  }
+
+  test("chatgpt mode still removes the OpenAI API key", async () => {
+    await Bun.write(join(home, ".codex", "auth.json"), JSON.stringify({ auth_mode: "chatgpt" }));
+    let capturedEnv: Record<string, string> | undefined;
+    const adapter = new CodexAdapter({
+      bypassSubprocess: true,
+      appServerFactory: ({ env }) => {
+        capturedEnv = env;
+        throw new Error("test stops before app-server spawn");
+      },
+    });
+    await expect(adapter.createSession(config({ OPENAI_API_KEY: "example-task" }))).rejects.toThrow(
+      "test stops before app-server spawn",
+    );
+    expect(capturedEnv).toBeDefined();
+    expect(capturedEnv?.OPENAI_API_KEY).toBeUndefined();
+  });
+});