@desplega.ai/agent-swarm 1.166.0 → 1.167.0

package/src/providers/grok-adapter.ts

@@ -3,7 +3,10 @@ import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { normalizeGrokModel } from "@desplega/model-catalog";
-import { getOpenRouterBaseUrl } from "../utils/openrouter-base-url";
+import {
+  getOpenRouterAttributionHeaders,
+  getOpenRouterBaseUrl,
+} from "../utils/openrouter-base-url";
 import { registerVolatileSecret } from "../utils/secret-scrubber";
 import { ACPAdapter } from "./acp-adapter";
 import { grokTargetProfile, isGrokOpenRouterModel } from "./acp-targets";
@@ -64,6 +67,8 @@ export interface GrokCustomModel {
   baseUrl: string;
   /** Env var holding the endpoint's API key. */
   envKey: string;
+  /** Sent verbatim on every request to the endpoint (`extra_headers`). */
+  headers?: Record<string, string>;
 }
 
 /** `openrouter/<vendor>/<id>` -> a `[model."openrouter/<vendor>/<id>"]` block on OpenRouter. */
@@ -73,14 +78,24 @@ export function grokOpenRouterModel(
 ): GrokCustomModel | null {
   const id = model.trim();
   if (!isGrokOpenRouterModel(id)) return null;
+  const baseUrl = getOpenRouterBaseUrl(env);
   return {
     id,
     model: id.slice("openrouter/".length),
-    baseUrl: getOpenRouterBaseUrl(env),
+    baseUrl,
     envKey: "OPENROUTER_API_KEY",
+    headers: getOpenRouterAttributionHeaders(baseUrl, env),
   };
 }
 
+/** `key = { "k" = "v", ... }`, or nothing for an empty map. JSON strings are valid TOML basic strings. */
+function tomlInlineTable(key: string, entries: Record<string, string> | undefined): string[] {
+  const pairs = Object.entries(entries ?? {});
+  if (pairs.length === 0) return [];
+  const body = pairs.map(([k, v]) => `${JSON.stringify(k)} = ${JSON.stringify(v)}`).join(", ");
+  return [`${key} = { ${body} }`];
+}
+
 /** `$GROK_HOME/config.toml` for one swarm session. */
 export function buildGrokConfigToml(
   disabledPlugins: readonly string[],
@@ -95,6 +110,7 @@ export function buildGrokConfigToml(
         `base_url = ${JSON.stringify(customModel.baseUrl)}`,
         `env_key = ${JSON.stringify(customModel.envKey)}`,
         `api_backend = "chat_completions"`,
+        ...tomlInlineTable("extra_headers", customModel.headers),
       ]
     : [];
   return [

package/src/providers/opencode-adapter.ts

@@ -20,7 +20,11 @@ import {
 import { validateOpencodeCredentials } from "../utils/credentials";
 import { fetchInstalledMcpServers } from "../utils/mcp-server-fetcher";
 import { swarmRuntimeInstanceId } from "../utils/multi-runtime";
-import { DEFAULT_OPENROUTER_BASE_URL, getOpenRouterBaseUrl } from "../utils/openrouter-base-url";
+import {
+  DEFAULT_OPENROUTER_BASE_URL,
+  getOpenRouterAttributionHeaders,
+  getOpenRouterBaseUrl,
+} from "../utils/openrouter-base-url";
 import { scrubSecrets } from "../utils/secret-scrubber";
 import { resolveSlashSkillPrompt } from "./codex-skill-resolver";
 import { CTX_MODE_NUDGE_EVERY } from "./ctx-mode-env";
@@ -177,22 +181,34 @@ function formatUnknownError(err: unknown): string {
  * Route OpenRouter traffic through the configured gateway (see
  * src/utils/openrouter-base-url.ts). opencode's bundled openrouter provider
  * honors `provider.openrouter.options.baseURL`. Mutates `opencodeConfig` in
- * place; no-op when `OPENROUTER_BASE_URL` is unset/blank/default, so default
- * openrouter.ai behavior is preserved. Exported for tests.
+ * place, and attribute direct OpenRouter requests to Agent Swarm.
  */
 export function applyOpenRouterBaseUrlOverride(
   opencodeConfig: Config,
   env: Record<string, string | undefined> = process.env,
 ): void {
   const openRouterBaseUrl = getOpenRouterBaseUrl(env as NodeJS.ProcessEnv);
-  if (openRouterBaseUrl === DEFAULT_OPENROUTER_BASE_URL) return;
+  const headers = getOpenRouterAttributionHeaders(openRouterBaseUrl, env);
+  const overrideBaseUrl = openRouterBaseUrl !== DEFAULT_OPENROUTER_BASE_URL;
+  if (!overrideBaseUrl && Object.keys(headers).length === 0) return;
   opencodeConfig.provider = {
     ...opencodeConfig.provider,
     openrouter: {
       ...opencodeConfig.provider?.openrouter,
       options: {
         ...opencodeConfig.provider?.openrouter?.options,
-        baseURL: openRouterBaseUrl,
+        ...(overrideBaseUrl ? { baseURL: openRouterBaseUrl } : {}),
+        ...(Object.keys(headers).length > 0
+          ? {
+              headers: {
+                ...(opencodeConfig.provider?.openrouter?.options?.headers as
+                  | Record<string, string>
+                  | undefined),
+                ...headers,
+                "X-Title": "Agent Swarm",
+              },
+            }
+          : {}),
       },
     },
   };

package/src/providers/pi-mono-extension.ts

@@ -11,6 +11,7 @@ import { buildRatingsFromLlm, fetchRetrievalsForTask, postRatings } from "../be/
 import { checkToolLoop, clearToolHistory } from "../hooks/tool-loop-detection";
 import { summarizeSession as runSummarize } from "../utils/internal-ai";
 import { getMemoryRaterNames } from "../utils/memory-raters";
+import { getOpenRouterAttributionHeaders } from "../utils/openrouter-base-url";
 import { scrubSecrets } from "../utils/secret-scrubber";
 
 export interface SwarmHooksConfig {
@@ -421,6 +422,24 @@ export async function summarizeSessionForPi(
   }
 }
 
+/** `customType` of the advisory messages this extension sends to the model. */
+export const SWARM_NUDGE_CUSTOM_TYPE = "swarm-nudge";
+
+/**
+ * Deliver an advisory nudge to the model. pi runs extensions in-process and
+ * never feeds their stdout to the model, so a console.log here only reaches
+ * the worker log. `sendMessage` steers the text in after the current tool
+ * batch while the agent is streaming, and otherwise appends it to the session
+ * so the next prompt carries it.
+ */
+function sendNudge(pi: Parameters<ExtensionFactory>[0], text: string): void {
+  pi.sendMessage({
+    customType: SWARM_NUDGE_CUSTOM_TYPE,
+    content: [{ type: "text", text }],
+    display: false,
+  });
+}
+
 /**
  * Create the swarm hooks extension factory for pi-mono.
  *
@@ -431,6 +450,13 @@ export function createSwarmHooksExtension(config: SwarmHooksConfig): ExtensionFa
   return (pi) => {
     let lastContextPostTime = 0;
 
+    pi.on("before_provider_headers", (event, ctx) => {
+      Object.assign(
+        event.headers,
+        getOpenRouterAttributionHeaders(ctx.model?.baseUrl ?? "", config.env),
+      );
+    });
+
     // === session_start → SessionStart ===
     pi.on("session_start", async (_event, _ctx) => {
       // Installed MCP servers: pi's MCP extension connects them in the
@@ -458,7 +484,7 @@ export function createSwarmHooksExtension(config: SwarmHooksConfig): ExtensionFa
       if (config.isLead) {
         const ctx = await fetchConcurrentContext(config);
         if (ctx) {
-          console.log(ctx);
+          sendNudge(pi, ctx);
         }
       }
     });
@@ -498,7 +524,7 @@ export function createSwarmHooksExtension(config: SwarmHooksConfig): ExtensionFa
         }
 
         if (loopResult.severity === "warning" && loopResult.reason) {
-          console.log(`Warning: ${loopResult.reason}`);
+          sendNudge(pi, `Warning: ${loopResult.reason}`);
         }
       }
 
@@ -586,7 +612,8 @@ export function createSwarmHooksExtension(config: SwarmHooksConfig): ExtensionFa
 
       // Reminders
       if (config.isLead && event.toolName?.endsWith("send-task")) {
-        console.log(
+        sendNudge(
+          pi,
           "Task sent successfully. Monitor progress using the get-task-details tool periodically.",
         );
       }
@@ -594,29 +621,30 @@ export function createSwarmHooksExtension(config: SwarmHooksConfig): ExtensionFa
       return undefined;
     });
 
-    // === context → PreCompact ===
-    // The context event allows injecting messages before compaction.
-    // We log the goal reminder to console (it gets captured in context).
-    pi.on("context", async (_event, ctx) => {
-      if (!config.taskId) return undefined;
-
-      try {
-        const taskDetails = await fetchTaskDetails(config);
-        if (taskDetails) {
-          const reminder = [
-            "=== GOAL REMINDER (injected before context compaction) ===",
-            `Task ID: ${taskDetails.id}`,
-            `Task: ${taskDetails.task}`,
-          ];
-          if (taskDetails.progress) {
-            reminder.push(`Current Progress: ${taskDetails.progress}`);
-          }
-          reminder.push("=== Continue working on this task after compaction ===");
-          console.log(reminder.join("\n"));
+    // === session_compact → PreCompact ===
+    // Re-anchor the model on its task once compaction has summarized the
+    // history. `context` fires before every LLM call, so it cannot carry this.
+    pi.on("session_compact", async () => {
+      if (!config.taskId) return;
+
+      const taskDetails = await fetchTaskDetails(config);
+      if (taskDetails) {
+        const reminder = [
+          "=== GOAL REMINDER (injected before context compaction) ===",
+          `Task ID: ${taskDetails.id}`,
+          `Task: ${taskDetails.task}`,
+        ];
+        if (taskDetails.progress) {
+          reminder.push(`Current Progress: ${taskDetails.progress}`);
         }
-      } catch {
-        /* don't block compaction */
+        reminder.push("=== Continue working on this task after compaction ===");
+        sendNudge(pi, reminder.join("\n"));
       }
+    });
+
+    // === context (before every LLM call) ===
+    pi.on("context", async (_event, ctx) => {
+      if (!config.taskId) return undefined;
 
       // Report context usage as a compaction event
       const usage = ctx.getContextUsage?.();
@@ -644,7 +672,10 @@ export function createSwarmHooksExtension(config: SwarmHooksConfig): ExtensionFa
         const { cancelled, reason } = await isTaskCancelled(config);
         if (cancelled) {
           const cancelReason = reason || "Task cancelled by lead or creator";
-          console.log(
+          // "handled" skips the turn; the nudge lands in the session for the
+          // next one instead of paying for a turn on a cancelled task.
+          sendNudge(
+            pi,
             `🛑 TASK CANCELLED: ${cancelReason}. Stop working and use store-progress to acknowledge.`,
           );
           return { action: "handled" as const };

package/src/providers/pricing-sources.md

@@ -178,6 +178,8 @@ and heartbeat-classified roots are omitted, and the metrics remain separate.
 - **Codex usage:** the app-server reports cumulative token counters, including cache writes.
   The adapter calculates each turn's delta before adding it to the session total.
   This prevents repeated billing of earlier turns when the adapter processes queued input.
+  Context occupancy is separate: it comes from the per-request `tokenUsage.last`
+  snapshot (and `modelContextWindow` when present), never from the turn delta.
 - **Claude breakdown validity is all-or-nothing:** the claude adapter drops the
   entire `modelUsage` breakdown when any entry carries a missing, non-finite,
   or negative token counter — zero-filling would let the server price a

package/src/server.ts

@@ -196,6 +196,7 @@ import {
   registerTriggerWorkflowTool,
   registerUpdateWorkflowTool,
 } from "./tools/workflows";
+import { parseEnabledTools } from "./utils/enabled-tools";
 import { resolveScriptsOnlyMode } from "./utils/scripts-only-mode";
 
 // Every known capability, including the ones disabled by default. Exported for
@@ -293,18 +294,75 @@ export function isScriptsOnlyMcp(): boolean {
   return resolveScriptsOnlyMode({ env: process.env.SCRIPTS_ONLY_MCP });
 }
 
+const loggedToolAllowlistWarnings = new Set<string>();
+
+function warnToolAllowlistOnce(message: string): void {
+  if (loggedToolAllowlistWarnings.has(message)) return;
+  loggedToolAllowlistWarnings.add(message);
+  console.warn(message);
+}
+
+/**
+ * SWARM_ENABLED_TOOLS: an optional explicit allowlist for the externally
+ * exposed MCP surface. Returns undefined (capability-driven surface) when the
+ * value is unset, blank, or invalid. Never logs the raw value.
+ */
+function resolveToolAllowlist(value: string | undefined): string[] | undefined {
+  if (value === undefined) return undefined;
+  try {
+    const tools = parseEnabledTools(value);
+    if (!tools) {
+      warnToolAllowlistOnce("[MCP] SWARM_ENABLED_TOOLS is set but lists no tools; ignoring it");
+    }
+    return tools;
+  } catch {
+    warnToolAllowlistOnce("[MCP] Invalid SWARM_ENABLED_TOOLS; ignoring it");
+    return undefined;
+  }
+}
+
+/** Drop every registered tool the allowlist does not name; warn on unknown names. */
+function applyToolAllowlist(server: McpServer, allowlist: readonly string[]): void {
+  const tools = (server as unknown as { _registeredTools: Record<string, { remove(): void }> })
+    ._registeredTools;
+  const allowed = new Set(allowlist);
+  for (const [name, tool] of Object.entries(tools)) {
+    if (!allowed.has(name)) tool.remove();
+  }
+  const unknown = allowlist.filter((name) => !Object.hasOwn(tools, name));
+  if (unknown.length > 0) {
+    warnToolAllowlistOnce(
+      `[MCP] SWARM_ENABLED_TOOLS names unknown tools, ignoring them: ${unknown.join(", ")}`,
+    );
+  }
+}
+
 export async function createServer(
-  opts: { scriptsOnly?: boolean; fullSurface?: boolean; preloadedTools?: readonly string[] } = {},
+  opts: {
+    scriptsOnly?: boolean;
+    fullSurface?: boolean;
+    preloadedTools?: readonly string[];
+    /** Raw SWARM_ENABLED_TOOLS value for this session; defaults to the env. */
+    enabledTools?: string;
+  } = {},
 ) {
   // Reload env
   await loadGlobalConfigsIntoEnv(true);
 
+  // The tool allowlist replaces CAPABILITIES and SCRIPTS_ONLY_MCP when set.
+  // Full-surface consumers (the scripts SDK bridge) ignore it.
+  const toolAllowlist =
+    opts.fullSurface === true
+      ? undefined
+      : resolveToolAllowlist(opts.enabledTools ?? process.env.SWARM_ENABLED_TOOLS);
+
   // Capability flags shape the externally exposed MCP tool list only. Internal
   // full-surface consumers (the scripts SDK bridge, drift-check tests) pass
   // fullSurface to register every tool group regardless of CAPABILITIES.
+  // An allowlist also registers every group, then prunes to the listed names.
   // This shadows the module-level hasCapability for the registrations below.
   const hasCapability = (cap: CAPABILITIES_T): boolean =>
-    opts.fullSurface === true || getCapabilities().has(cap);
+    opts.fullSurface === true || toolAllowlist !== undefined || getCapabilities().has(cap);
 
   // Initialize database with WAL mode
   // Uses DATABASE_PATH env var for Docker volume compatibility (WAL needs .sqlite, .sqlite-wal, .sqlite-shm on same filesystem)
@@ -355,7 +413,7 @@ export async function createServer(
   // Scripts-only surface (experimental code-mode): register just the script
   // catalog tools and stop. script-connections / script-apis stay out — they
   // are lead-only security admin and excluded from the scripts SDK too.
-  if (opts.scriptsOnly ?? isScriptsOnlyMcp()) {
+  if (toolAllowlist === undefined && (opts.scriptsOnly ?? isScriptsOnlyMcp())) {
     registerScriptSearchTool(server);
     registerScriptRunTool(server);
     registerScriptUpsertTool(server);
@@ -630,5 +688,7 @@ export async function createServer(
     registerUpdateServiceStatusTool(server);
   }
 
+  if (toolAllowlist) applyToolAllowlist(server, toolAllowlist);
+
   return server;
 }

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

@@ -1,6 +1,6 @@
 import { afterEach, describe, expect, spyOn, test } from "bun:test";
 import { chmodSync, existsSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
-import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
+import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { Usage } from "@agentclientprotocol/sdk";
@@ -64,20 +64,29 @@ function baseConfig(overrides: Partial<ProviderSessionConfig> = {}): ProviderSes
 
 /**
  * Start a minimal swarm API stub that handles POST /api/sessions/tokens and
- * DELETE /api/sessions/tokens/:id. Returns the server and its base URL.
- * The caller is responsible for closing the server.
+ * DELETE /api/sessions/tokens/:id. Returns its base URL and `close()`, which
+ * the caller must await. The adapter revokes a minted token fire-and-forget,
+ * so closing before that DELETE lands fails it and leaks a revoke warning
+ * into a later test.
  */
 async function startTokenStubServer(
   tokenId: string,
   plaintext: string,
-): Promise<{ server: Server; apiUrl: string }> {
+): Promise<{ apiUrl: string; close: () => Promise<void> }> {
+  let minted = false;
+  let resolveRevoked!: () => void;
+  const revoked = new Promise<void>((resolve) => {
+    resolveRevoked = resolve;
+  });
   const stub = createServer(async (req: IncomingMessage, res: ServerResponse) => {
     if (req.method === "POST" && req.url === "/api/sessions/tokens") {
+      minted = true;
       res.writeHead(200, { "Content-Type": "application/json" });
       res.end(JSON.stringify({ tokenId, plaintext }));
     } else if (req.method === "DELETE" && req.url?.startsWith("/api/sessions/tokens/")) {
       res.writeHead(204);
       res.end();
+      resolveRevoked();
     } else {
       res.writeHead(404);
       res.end();
@@ -85,7 +94,13 @@ async function startTokenStubServer(
   });
   await new Promise<void>((resolve) => stub.listen(0, "127.0.0.1", resolve));
   const addr = stub.address() as import("net").AddressInfo;
-  return { server: stub, apiUrl: `http://127.0.0.1:${addr.port}` };
+  const close = async () => {
+    // A minted token is always revoked; wait for it, bounded so a failed test
+    // still tears down.
+    if (minted) await Promise.race([revoked, Bun.sleep(5_000)]);
+    await new Promise<void>((resolve) => stub.close(() => resolve()));
+  };
+  return { apiUrl: `http://127.0.0.1:${addr.port}`, close };
 }
 
 describe("ACPAdapter", () => {
@@ -305,7 +320,7 @@ new AgentSideConnection((connection) => new FakeAgent(connection), stream);
 `,
     );
 
-    const { server: tokenStub, apiUrl } = await startTokenStubServer(
+    const { close: closeTokenStub, apiUrl } = await startTokenStubServer(
       "stub-token-id",
       "aseph_stubtokenfortest1234567890",
     );
@@ -503,7 +518,7 @@ new AgentSideConnection((connection) => new FakeAgent(connection), stream);
         closeDb();
       }
     } finally {
-      await new Promise<void>((resolve) => tokenStub.close(() => resolve()));
+      await closeTokenStub();
     }
   });
 
@@ -537,10 +552,132 @@ new AgentSideConnection((connection) => new FakeAgent(connection), stream);
       ),
     ).toMatchObject({
       OPENAI_API_KEY: "example-test-key",
-      OPENCODE_CONFIG_CONTENT: JSON.stringify({ theme: "dark", model: "opencode/model" }),
+      OPENCODE_CONFIG_CONTENT: JSON.stringify({
+        theme: "dark",
+        model: "opencode/model",
+        provider: {
+          openrouter: {
+            options: {
+              headers: {
+                "HTTP-Referer": "https://agent-swarm.dev",
+                "X-OpenRouter-Title": "Agent Swarm",
+                "X-OpenRouter-Categories": "personal-agent,cloud-agent",
+                "X-Title": "Agent Swarm",
+              },
+            },
+          },
+        },
+      }),
     });
   });
 
+  test("OpenCode preset merges the OpenRouter gateway with model and provider config", () => {
+    const config = baseConfig({
+      model: " openrouter/openai/gpt-4o-mini ",
+      env: {
+        ACP_TARGET: "opencode",
+        OPENROUTER_BASE_URL: " http://127.0.0.1:8080/api/v1/ ",
+        OPENCODE_CONFIG_CONTENT: JSON.stringify({
+          theme: "dark",
+          provider: { openrouter: { options: { apiKey: "dummy" } } },
+        }),
+      },
+    });
+    const env = resolveAcpTarget(config).env(config);
+    expect(JSON.parse(env.OPENCODE_CONFIG_CONTENT!)).toEqual({
+      theme: "dark",
+      model: "openrouter/openai/gpt-4o-mini",
+      provider: {
+        openrouter: { options: { apiKey: "dummy", baseURL: "http://127.0.0.1:8080/api/v1" } },
+      },
+    });
+  });
+
+  test("OpenCode preset omits gateway override for unset, blank, or default URL", () => {
+    for (const url of [undefined, "", "https://openrouter.ai/api/v1/"]) {
+      const config = baseConfig({
+        env: { ACP_TARGET: "opencode", OPENROUTER_BASE_URL: url },
+      });
+      const env = resolveAcpTarget(config).env(config);
+      const content = JSON.parse(env.OPENCODE_CONFIG_CONTENT!);
+      expect(content).toEqual({
+        model: config.model,
+        provider: {
+          openrouter: {
+            options: {
+              headers: {
+                "HTTP-Referer": "https://agent-swarm.dev",
+                "X-OpenRouter-Title": "Agent Swarm",
+                "X-OpenRouter-Categories": "personal-agent,cloud-agent",
+                "X-Title": "Agent Swarm",
+              },
+            },
+          },
+        },
+      });
+      expect(content.provider.openrouter.options.baseURL).toBeUndefined();
+    }
+  });
+
+  test("OpenCode preset adds attribution headers to OPENCODE_CONFIG_CONTENT for an OpenRouter host", () => {
+    const config = baseConfig({
+      model: "",
+      env: {
+        ACP_TARGET: "opencode",
+        OPENROUTER_BASE_URL: "https://openrouter.ai/api/v1",
+        OPENCODE_CONFIG_CONTENT: JSON.stringify({
+          theme: "dark",
+          provider: { openrouter: { options: { headers: { "X-Custom": "preserved" } } } },
+        }),
+      },
+    });
+    const env = resolveAcpTarget(config).env(config);
+    expect(JSON.parse(env.OPENCODE_CONFIG_CONTENT!)).toEqual({
+      theme: "dark",
+      provider: {
+        openrouter: {
+          options: {
+            headers: {
+              "X-Custom": "preserved",
+              "HTTP-Referer": "https://agent-swarm.dev",
+              "X-OpenRouter-Title": "Agent Swarm",
+              "X-OpenRouter-Categories": "personal-agent,cloud-agent",
+              "X-Title": "Agent Swarm",
+            },
+          },
+        },
+      },
+    });
+  });
+
+  test("OpenCode preset leaves OPENCODE_CONFIG_CONTENT unchanged when attribution is disabled", () => {
+    const content = JSON.stringify({
+      theme: "dark",
+      provider: { openrouter: { options: { headers: { "X-Custom": "preserved" } } } },
+    });
+    const config = baseConfig({
+      model: "",
+      env: {
+        ACP_TARGET: "opencode",
+        OPENROUTER_BASE_URL: "https://openrouter.ai/api/v1",
+        OPENROUTER_APP_ATTRIBUTION: "false",
+        OPENCODE_CONFIG_CONTENT: content,
+      },
+    });
+    expect(resolveAcpTarget(config).env(config).OPENCODE_CONFIG_CONTENT).toBe(content);
+  });
+
+  test("OpenCode preset injects gateway even without a model fallback", () => {
+    const config = baseConfig({
+      model: "",
+      env: { ACP_TARGET: "opencode", OPENROUTER_BASE_URL: "http://127.0.0.1:8080/api/v1" },
+    });
+    const env = resolveAcpTarget(config).env(config);
+    expect(JSON.parse(env.OPENCODE_CONFIG_CONTENT!).provider.openrouter.options.baseURL).toBe(
+      "http://127.0.0.1:8080/api/v1",
+    );
+  });
+
   test("Gemini preset supplies command, credentials, trust, and a model environment fallback", () => {
     const config = baseConfig({
       model: "gemini-3-flash-preview",
@@ -687,7 +824,10 @@ new AgentSideConnection((connection) => new FakeCopilot(connection), stream);
     chmodSync(copilotStub, 0o755);
     mkdirSync(join(binDir, "home"));
 
-    const { server, apiUrl } = await startTokenStubServer("copilot-token-id", "example-aseph_x");
+    const { close: closeTokenStub, apiUrl } = await startTokenStubServer(
+      "copilot-token-id",
+      "example-aseph_x",
+    );
     try {
       const config = baseConfig({
         cwd,
@@ -721,7 +861,7 @@ new AgentSideConnection((connection) => new FakeCopilot(connection), stream);
       while (existsSync(captured.dir) && Date.now() < deadline) await Bun.sleep(10);
       expect(existsSync(captured.dir)).toBe(false);
     } finally {
-      await new Promise<void>((resolve) => server.close(() => resolve()));
+      await closeTokenStub();
     }
   });
 
@@ -1077,7 +1217,7 @@ const stream = ndJsonStream(Writable.toWeb(process.stdout), Readable.toWeb(proce
 new AgentSideConnection((connection) => new FakeAgent(connection), stream);
 `,
     );
-    const { server: tokenStub, apiUrl } = await startTokenStubServer(
+    const { close: closeTokenStub, apiUrl } = await startTokenStubServer(
       "stub-token-id",
       "aseph_stubtokenfortest1234567890",
     );
@@ -1140,7 +1280,7 @@ new AgentSideConnection((connection) => new FakeAgent(connection), stream);
         closeDb();
       }
     } finally {
-      await new Promise<void>((resolve) => tokenStub.close(() => resolve()));
+      await closeTokenStub();
     }
   });
 });

package/src/tests/ci-unit-test-report.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, test } from "bun:test";
+import { buildPayload, parseJunit } from "../../scripts/ci-unit-test-report";
+
+// Shape emitted by `bun test --reporter=junit` (bun 1.4): one testsuite per file,
+// nested testsuites per describe, and attribute values XML-escaped.
+const JUNIT = `<?xml version="1.0" encoding="UTF-8"?>
+<testsuites name="bun test" tests="6" assertions="5" failures="1" skipped="2" time="0.3">
+  <testsuite name="src/a.test.ts" file="src/a.test.ts" tests="4" failures="1" skipped="1" time="0.2">
+    <testsuite name="outer" file="src/a.test.ts" line="3" tests="4" time="0">
+      <testsuite name="inner &amp; &quot;nested&quot;" file="src/a.test.ts" line="4" tests="2" time="0">
+        <testcase name="slow one" classname="inner" time="0.120" file="src/a.test.ts" line="5" assertions="1" />
+        <testcase name="breaks &lt;sometimes&gt;" classname="inner" time="0.004" file="src/a.test.ts" line="6" assertions="1">
+          <failure type="AssertionError" message="expect(received).toBe(expected)&#10;">AssertionError&#10;</failure>
+        </testcase>
+      </testsuite>
+      <testcase name="fast" classname="outer" time="0.000010" file="src/a.test.ts" line="8" assertions="1" />
+      <testcase name="later" classname="outer" time="0" file="src/a.test.ts" line="9" assertions="0">
+        <skipped message="TODO" />
+      </testcase>
+    </testsuite>
+  </testsuite>
+  <testsuite name="src/b.test.ts" file="src/b.test.ts" tests="2" failures="0" skipped="1" time="0.1">
+    <testcase name="top level" classname="" time="0.06" file="src/b.test.ts" line="2" assertions="2" />
+    <testcase name="skipped" classname="" time="0" file="src/b.test.ts" line="3" assertions="0">
+      <skipped />
+    </testcase>
+  </testsuite>
+</testsuites>`;
+
+describe("ci-unit-test-report", () => {
+  test("parses describe chains, statuses, durations and XML entities", () => {
+    expect(parseJunit(JUNIT)).toEqual([
+      {
+        file: "src/a.test.ts",
+        name: 'outer > inner & "nested" > slow one',
+        ms: 120,
+        status: "pass",
+      },
+      {
+        file: "src/a.test.ts",
+        name: 'outer > inner & "nested" > breaks <sometimes>',
+        ms: 4,
+        status: "fail",
+      },
+      { file: "src/a.test.ts", name: "outer > fast", ms: 0, status: "pass" },
+      { file: "src/a.test.ts", name: "outer > later", ms: 0, status: "skip" },
+      { file: "src/b.test.ts", name: "top level", ms: 60, status: "pass" },
+      { file: "src/b.test.ts", name: "skipped", ms: 0, status: "skip" },
+    ]);
+  });
+
+  test("keeps every non-pass and every test at or above minMs, with per-file totals", () => {
+    const payload = buildPayload(parseJunit(JUNIT), new Map([["src/a.test.ts", "abc123"]]), 50);
+    expect(payload.totals).toEqual({ tests: 6, pass: 3, fail: 1, skip: 2, testMs: 184 });
+    expect(payload.files).toEqual([
+      ["src/a.test.ts", "abc123", 4, 1, 124],
+      ["src/b.test.ts", null, 2, 0, 60],
+    ]);
+    expect(payload.tests).toEqual([
+      [0, 'outer > inner & "nested" > slow one', 120, "p"],
+      [0, 'outer > inner & "nested" > breaks <sometimes>', 4, "f"],
+      [0, "outer > later", 0, "s"],
+      [1, "top level", 60, "p"],
+      [1, "skipped", 0, "s"],
+    ]);
+  });
+
+  test("an empty report parses to no tests", () => {
+    expect(
+      parseJunit('<?xml version="1.0"?><testsuites name="bun test" tests="0"></testsuites>'),
+    ).toEqual([]);
+  });
+});