@desplega.ai/agent-swarm 1.165.0 → 1.167.0

package/src/providers/acp-target-catalog.ts

@@ -1,4 +1,4 @@
-export const ACP_TARGET_IDS = ["opencode", "gemini", "custom"] as const;
+export const ACP_TARGET_IDS = ["opencode", "gemini", "copilot", "custom"] as const;
 
 export type AcpTarget = (typeof ACP_TARGET_IDS)[number];
 
@@ -61,6 +61,40 @@ export const ACP_TARGET_CATALOG: readonly AcpTargetCatalogEntry[] = [
     ],
     knobs: [{ id: "model", label: "Model", category: "model" }],
   },
+  {
+    id: "copilot",
+    label: "GitHub Copilot CLI",
+    description:
+      "GitHub Copilot CLI's ACP server, launched with `copilot --acp`. Uses a Copilot-entitled COPILOT_GITHUB_TOKEN, or a BYOK provider via COPILOT_PROVIDER_*.",
+    command: "copilot",
+    args: ["--acp"],
+    envKeys: [
+      "COPILOT_GITHUB_TOKEN",
+      "COPILOT_GH_HOST",
+      "GH_HOST",
+      "COPILOT_HOME",
+      "COPILOT_MODEL",
+      "COPILOT_AUTO_TIER",
+      "COPILOT_OFFLINE",
+      "COPILOT_PROVIDER_BASE_URL",
+      "COPILOT_PROVIDER_TYPE",
+      "COPILOT_PROVIDER_API_KEY",
+      "COPILOT_PROVIDER_API_KEY_COMMAND",
+      "COPILOT_PROVIDER_BEARER_TOKEN",
+      "COPILOT_PROVIDER_WIRE_API",
+      "COPILOT_PROVIDER_TRANSPORT",
+      "COPILOT_PROVIDER_AZURE_API_VERSION",
+      "COPILOT_PROVIDER_MODEL_ID",
+      "COPILOT_PROVIDER_WIRE_MODEL",
+      "COPILOT_PROVIDER_MAX_PROMPT_TOKENS",
+      "COPILOT_PROVIDER_MAX_OUTPUT_TOKENS",
+      "COPILOT_PROVIDER_HEADERS",
+      "HTTP_PROXY",
+      "HTTPS_PROXY",
+      "NO_PROXY",
+    ],
+    knobs: [{ id: "model", label: "Model", category: "model" }],
+  },
   {
     id: "custom",
     label: "Custom",

package/src/providers/acp-targets.ts

@@ -1,9 +1,16 @@
-import { mkdtemp } from "node:fs/promises";
+import { mkdir, mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { normalizeGrokModel } from "@desplega/model-catalog";
+import type { Config } from "@opencode-ai/sdk";
 import { clampContextPercent, getContextWindowSize } from "../utils/context-window";
-import { type AcpTarget, getAcpTargetCatalogEntry, isAcpTarget } from "./acp-target-catalog";
+import {
+  ACP_TARGET_IDS,
+  type AcpTarget,
+  getAcpTargetCatalogEntry,
+  isAcpTarget,
+} from "./acp-target-catalog";
+import { applyOpenRouterBaseUrlOverride } from "./opencode-adapter";
 import { applyReasoningEffort } from "./reasoning-effort";
 import type { CostData, CostModelUsage, ProviderEvent, ProviderSessionConfig } from "./types";
 
@@ -14,6 +21,8 @@ export interface AcpTargetProfile {
   env(config: ProviderSessionConfig): Record<string, string>;
   configuredOptions(config: ProviderSessionConfig): Record<string, string | boolean>;
   writeSystemPromptArtifact(config: ProviderSessionConfig): Promise<void>;
+  /** Removes what writeSystemPromptArtifact wrote. Called once the session ends or fails to start. */
+  cleanupSystemPromptArtifact?(config: ProviderSessionConfig): Promise<void>;
   /** Target-specific `session/new` `_meta`. Targets without one send none. */
   sessionMeta?(config: ProviderSessionConfig): Record<string, unknown> | undefined;
   /** A clearer message for a target error whose own text misleads, else undefined. */
@@ -117,8 +126,8 @@ function configuredOptions(config: ProviderSessionConfig): Record<string, string
   return options;
 }
 
-function withModelInJsonEnv(env: Record<string, string>, key: string, model: string): void {
-  if (!model.trim()) return;
+function withOpencodeConfig(env: Record<string, string>, model: string): void {
+  const key = "OPENCODE_CONFIG_CONTENT";
   let value: Record<string, unknown> = {};
   const existing = env[key];
   if (existing) {
@@ -131,7 +140,9 @@ function withModelInJsonEnv(env: Record<string, string>, key: string, model: str
       console.warn(`\x1b[33m[acp]\x1b[0m Replacing invalid ${key} JSON for model fallback`);
     }
   }
-  env[key] = JSON.stringify({ ...value, model: model.trim() });
+  if (model.trim()) value.model = model.trim();
+  applyOpenRouterBaseUrlOverride(value as Config, env);
+  env[key] = JSON.stringify(value);
 }
 
 function parseCommand(command: string, args: string | undefined): string[] {
@@ -196,7 +207,8 @@ const opencodeTargetProfile: AcpTargetProfile = {
     const env = baseTargetEnv(config);
     const entry = getAcpTargetCatalogEntry("opencode");
     copyEnvKeys(config, env, entry.envKeys);
-    withModelInJsonEnv(env, "OPENCODE_CONFIG_CONTENT", config.model);
+    copyEnvKeys(config, env, ["OPENROUTER_APP_ATTRIBUTION"]);
+    withOpencodeConfig(env, config.model);
     return env;
   },
   configuredOptions,
@@ -238,6 +250,63 @@ const geminiTargetProfile: AcpTargetProfile = {
   },
 };
 
+/**
+ * Copilot CLI has no system-prompt flag. Under `--acp` it reads custom
+ * instructions from the git root, the cwd, and every directory listed in
+ * COPILOT_CUSTOM_INSTRUCTIONS_DIRS. Verified against 1.0.93: from those extra
+ * directories it loads `.github/instructions/*.instructions.md`, but not
+ * `AGENTS.md`. So the swarm prompt goes into a per-task directory outside the
+ * repo, and the repo's own AGENTS.md is never touched.
+ */
+export function copilotInstructionsDir(config: ProviderSessionConfig): string {
+  const key = new Bun.CryptoHasher("sha256")
+    .update(`${config.agentId}:${config.taskId}:${config.cwd}`)
+    .digest("hex")
+    .slice(0, 16);
+  return join(tmpdir(), "agent-swarm-copilot-instructions", key);
+}
+
+export const COPILOT_INSTRUCTIONS_FILE = join(
+  ".github",
+  "instructions",
+  "agent-swarm.instructions.md",
+);
+
+const copilotTargetProfile: AcpTargetProfile = {
+  target: "copilot",
+  command() {
+    const entry = getAcpTargetCatalogEntry("copilot");
+    return [entry.command!, ...(entry.args ?? [])];
+  },
+  env(config) {
+    const env = baseTargetEnv(config);
+    const entry = getAcpTargetCatalogEntry("copilot");
+    copyEnvKeys(config, env, entry.envKeys);
+    if (config.model.trim()) env.COPILOT_MODEL = config.model.trim();
+    // The image pins the CLI; a self-update would run an unpinned binary.
+    env.COPILOT_AUTO_UPDATE = "false";
+    const operatorDirs = readEnv(config, "COPILOT_CUSTOM_INSTRUCTIONS_DIRS")?.trim();
+    env.COPILOT_CUSTOM_INSTRUCTIONS_DIRS = [copilotInstructionsDir(config), operatorDirs]
+      .filter(Boolean)
+      .join(",");
+    return env;
+  },
+  configuredOptions,
+  async writeSystemPromptArtifact(config) {
+    const dir = copilotInstructionsDir(config);
+    await rm(dir, { recursive: true, force: true });
+    if (!config.systemPrompt) return;
+    await mkdir(join(dir, ".github", "instructions"), { recursive: true });
+    await Bun.write(
+      join(dir, COPILOT_INSTRUCTIONS_FILE),
+      `---\napplyTo: "**"\n---\n\n${config.systemPrompt}\n`,
+    );
+  },
+  async cleanupSystemPromptArtifact(config) {
+    await rm(copilotInstructionsDir(config), { recursive: true, force: true });
+  },
+};
+
 /**
  * Grok CLI env keys passed through to `grok agent stdio`. `GROK_HOME` is the
  * per-session state dir the grok adapter creates; the rest switch off the
@@ -471,7 +540,7 @@ export function resolveAcpTarget(config: ProviderSessionConfig): AcpTargetProfil
   const target = readEnv(config, "ACP_TARGET") ?? "custom";
   if (!isAcpTarget(target)) {
     throw new AcpTargetResolutionError(
-      `Unsupported ACP target "${target}". Supported targets: opencode, gemini, custom.`,
+      `Unsupported ACP target "${target}". Supported targets: ${ACP_TARGET_IDS.join(", ")}.`,
     );
   }
   switch (target) {
@@ -479,6 +548,8 @@ export function resolveAcpTarget(config: ProviderSessionConfig): AcpTargetProfil
       return opencodeTargetProfile;
     case "gemini":
       return geminiTargetProfile;
+    case "copilot":
+      return copilotTargetProfile;
     case "custom":
       return customTargetProfile;
   }

package/src/providers/amp-adapter.ts

@@ -44,7 +44,7 @@ import type {
  * default; the image installs exactly this version and the per-task settings
  * set `amp.updates.mode: "disabled"`. Bump it deliberately, with a live run.
  */
-export const AMP_PACKAGE = "@ampcode/cli@0.0.1791360091-gfb32ce";
+export const AMP_PACKAGE = "@ampcode/cli@0.0.1791460855-g1f688c";
 
 /** MCP server name. Amp exposes its tools as `agent_swarm` / `store_progress` (dashes become underscores). */
 const AMP_MCP_SERVER_NAME = "agent-swarm";

package/src/providers/claude-adapter.ts

@@ -34,6 +34,7 @@ import {
 import { withFileLock } from "../utils/file-lock";
 import { fetchInstalledMcpServers } from "../utils/mcp-server-fetcher";
 import { swarmRuntimeInstanceId } from "../utils/multi-runtime";
+import { getOpenRouterAttributionHeaders } from "../utils/openrouter-base-url";
 import {
   detachedProcessGroup,
   registerProcessGroup,
@@ -738,6 +739,30 @@ export function buildClaudeCodeRuntimeEnv(
   };
 }
 
+/**
+ * `ANTHROPIC_CUSTOM_HEADERS` ("Name: value" per line) with OpenRouter app
+ * attribution appended, when `ANTHROPIC_BASE_URL` points at openrouter.ai.
+ * The operator's lines are kept in order (they may carry gateway
+ * credentials); only lines naming one of our headers are replaced. Returns
+ * `{}` when nothing changes, so the inherited value stays byte-identical.
+ *
+ * Exported for unit testing.
+ */
+export function claudeOpenRouterAttributionEnv(env: Record<string, string | undefined>): {
+  ANTHROPIC_CUSTOM_HEADERS?: string;
+} {
+  const headers = getOpenRouterAttributionHeaders(env.ANTHROPIC_BASE_URL ?? "", env);
+  const names = new Set(Object.keys(headers).map((name) => name.toLowerCase()));
+  if (names.size === 0) return {};
+  const kept = (env.ANTHROPIC_CUSTOM_HEADERS ?? "").split("\n").filter((line) => {
+    const colon = line.indexOf(":");
+    const name = colon === -1 ? "" : line.slice(0, colon).trim().toLowerCase();
+    return line.trim() !== "" && !names.has(name);
+  });
+  const ours = Object.entries(headers).map(([name, value]) => `${name}: ${value}`);
+  return { ANTHROPIC_CUSTOM_HEADERS: [...kept, ...ours].join("\n") };
+}
+
 export function buildClaudeSessionEnvironment(
   config: ProviderSessionConfig,
   model: string,
@@ -751,6 +776,7 @@ export function buildClaudeSessionEnvironment(
     env: {
       ENABLE_PROMPT_CACHING_1H: "1",
       ...sourceEnv,
+      ...claudeOpenRouterAttributionEnv(sourceEnv),
       ...buildClaudeCodeRuntimeEnv(sourceEnv),
       ...buildClaudeCodeOtelEnv(sourceEnv),
       ...(reasoningApplication.kind === "claude-env" ? reasoningApplication.env : {}),

package/src/providers/codex-adapter.ts

@@ -147,6 +147,8 @@ export type ThreadEvent =
       usage?: Usage;
     }
   | { type: "turn.interrupted"; usage?: Usage }
+  /** Latest single-request usage: a context-window snapshot, not billable usage. */
+  | { type: "context.updated"; usage: Usage; contextWindow?: number }
   | { type: "error"; message: string; codexErrorInfo?: string | null; willRetry?: boolean };
 
 interface CodexThread {
@@ -833,8 +835,25 @@ class AppServerCodexThread implements CodexThread {
         }
         break;
       case "thread/tokenUsage/updated": {
-        const tokenUsage = params.tokenUsage as { total?: unknown } | undefined;
+        const tokenUsage = params.tokenUsage as
+          | { total?: unknown; last?: unknown; modelContextWindow?: unknown }
+          | undefined;
+        // `total` is cumulative for the thread and drives cost accounting at
+        // turn end. `last` is the most recent model request, which is the
+        // only figure that reflects what currently sits in the context window.
         this.latestTotalUsage = normalizeUsage(tokenUsage?.total);
+        const last = normalizeUsage(tokenUsage?.last);
+        if (last) {
+          push({
+            type: "context.updated",
+            usage: last,
+            contextWindow:
+              typeof tokenUsage?.modelContextWindow === "number" &&
+              tokenUsage.modelContextWindow > 0
+                ? tokenUsage.modelContextWindow
+                : undefined,
+          });
+        }
         break;
       }
       case "error": {
@@ -1394,6 +1413,9 @@ export class CodexSession implements ProviderSession {
       case "turn.interrupted":
         this.accountUsage(event.usage);
         break;
+      case "context.updated":
+        this.emitContextUsage(event.usage, event.contextWindow ?? this.contextWindow);
+        break;
       case "error": {
         const { message } = this.formatTerminalError(event.message, event.codexErrorInfo);
         if (event.willRetry === true) {
@@ -1420,7 +1442,12 @@ export class CodexSession implements ProviderSession {
             this.accumulatedUsage.reasoning_output_tokens + usage.reasoning_output_tokens,
         }
       : usage;
+    // No context_usage here: a turn's usage sums every model request in the
+    // turn, so it measures consumption, not window occupancy. Context comes
+    // from the per-request `context.updated` snapshots instead.
+  }
 
+  private emitContextUsage(usage: Usage, contextWindow: number): void {
     // Codex input tokens already include the cached read and write subsets.
     // Passing either subset again would inflate context usage.
     const contextUsed = computeContextUsedUnified({
@@ -1432,8 +1459,8 @@ export class CodexSession implements ProviderSession {
     this.emit({
       type: "context_usage",
       contextUsedTokens: contextUsed,
-      contextTotalTokens: this.contextWindow,
-      contextPercent: clampContextPercent(contextUsed, this.contextWindow) ?? 0,
+      contextTotalTokens: contextWindow,
+      contextPercent: clampContextPercent(contextUsed, contextWindow) ?? 0,
       outputTokens: usage.output_tokens,
       contextFormula: CONTEXT_FORMULA,
     });

package/src/providers/codex-oauth/auth-json.ts

@@ -2,7 +2,7 @@
  * Conversion utilities between CodexOAuthCredentials (our internal type)
  * and ~/.codex/auth.json (the format the Codex CLI reads natively).
  *
- * The Codex CLI expects auth.json in this exact format:
+ * The Codex CLI expects these native auth.json fields:
  * {
  *   "auth_mode": "chatgpt",
  *   "OPENAI_API_KEY": null,
@@ -14,6 +14,7 @@
  *   },
  *   "last_refresh": "<ISO 8601>"
  * }
+ * Swarm also writes optional `expires` metadata for lossless conversion.
  *
  * Note: `id_token` is set to the `access_token` value because the token
  * exchange endpoint doesn't return a separate `id_token`. This matches
@@ -23,7 +24,7 @@
  */
 
 import { codexPlanFromClaim } from "../../utils/subscription-plans.js";
-import { extractChatgptPlanType, extractChatgptUserId } from "./flow.js";
+import { decodeJwt, extractChatgptPlanType, extractChatgptUserId } from "./flow.js";
 import type { CodexAuthJson, CodexOAuthCredentials } from "./types.js";
 
 /**
@@ -96,15 +97,31 @@ export function credentialsToAuthJson(
       refresh_token: includeRefreshToken ? creds.refresh : "",
       account_id: creds.accountId,
     },
-    last_refresh: new Date(creds.expires).toISOString(),
+    last_refresh: new Date().toISOString(),
+    // Swarm-only metadata keeps opaque-token round trips lossless. Codex
+    // ignores this field and may drop it when it rewrites auth.json.
+    expires: creds.expires,
   };
 }
 
 export function authJsonToCredentials(auth: CodexAuthJson): CodexOAuthCredentials {
+  // A CLI refresh may replace the access token and discard our metadata.
+  // Prefer its JWT expiry, which describes the token actually in the file.
+  const exp = decodeJwt(auth.tokens.access_token)?.exp;
+  const jwtExpires = typeof exp === "number" ? exp * 1000 : NaN;
+  const expires =
+    Number.isFinite(jwtExpires) && jwtExpires >= 0
+      ? jwtExpires
+      : typeof auth.expires === "number" && Number.isFinite(auth.expires)
+        ? auth.expires
+        : new Date(auth.last_refresh).getTime();
+
   return {
     access: auth.tokens.access_token,
     refresh: auth.tokens.refresh_token,
-    expires: new Date(auth.last_refresh).getTime(),
+    // Legacy swarm files put expiry in last_refresh; keep that fallback
+    // only when neither the token nor the explicit metadata carries it.
+    expires,
     accountId: auth.tokens.account_id,
   };
 }

package/src/providers/codex-oauth/types.ts

@@ -28,6 +28,8 @@ export type CodexAuthJson = {
     account_id: string;
   };
   last_refresh: string;
+  /** Swarm-only access-token expiry (milliseconds); native Codex files omit it. */
+  expires?: number;
 };
 
 type TokenResult =

package/src/providers/cursor-adapter.ts

@@ -35,7 +35,7 @@ import type {
 } from "./types";
 
 /** Pinned in package.json and Dockerfile.worker; bump all three together. */
-export const CURSOR_SDK_VERSION = "1.0.36";
+export const CURSOR_SDK_VERSION = "1.0.37";
 
 /** MCP server name; Cursor reports its tools as `mcp` calls with this `providerIdentifier`. */
 const CURSOR_MCP_SERVER_NAME = "agent-swarm";

package/src/providers/dsh-adapter.ts

@@ -9,7 +9,10 @@ import {
 } from "../utils/context-window";
 import { addDshStepUsage, type DshStepUsage, normalizeDshStepUsage } from "../utils/dsh-usage";
 import { swarmRuntimeInstanceId } from "../utils/multi-runtime";
-import { getOpenRouterBaseUrl } from "../utils/openrouter-base-url";
+import {
+  getOpenRouterAttributionHeaders,
+  getOpenRouterBaseUrl,
+} from "../utils/openrouter-base-url";
 import {
   detachedProcessGroup,
   registerProcessGroup,
@@ -342,6 +345,9 @@ export class DshAdapter implements ProviderAdapter {
     const directory = await mkdtemp(join(tmpdir(), "swarm-dsh-"));
     try {
       const patchPath = join(directory, "patch.json");
+      const openRouterHeaders = openrouter
+        ? getOpenRouterAttributionHeaders(getOpenRouterBaseUrl(env), env)
+        : {};
       const runtimeInstanceId = swarmRuntimeInstanceId();
       // JSON is valid YAML. Values stay data, including arbitrary system prompts.
       await writeFile(
@@ -364,6 +370,9 @@ export class DshAdapter implements ProviderAdapter {
                     openrouter: {
                       apiKeyEnv: keyEnv,
                       baseURL: getOpenRouterBaseUrl(env),
+                      ...(Object.keys(openRouterHeaders).length > 0
+                        ? { headers: openRouterHeaders }
+                        : {}),
                       api: "openai-completions",
                       // Declare the selected ID even if the bundled catalog predates it.
                       models: [

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 };