@desplega.ai/agent-swarm 1.166.0 → 1.167.0

package/src/commands/runner.ts

@@ -21,7 +21,10 @@ import {
 import { type RelevantMemory, renderMemoriesPrompt } from "../prompts/memories.ts";
 import { configureHttpResolver, resolveTemplateAsync } from "../prompts/resolver.ts";
 import { renderSteeringDelivery } from "../prompts/steering-delivery.ts";
-import { authJsonToCredentialSelection } from "../providers/codex-oauth/auth-json.js";
+import {
+  authJsonToCredentialSelection,
+  credentialsToAuthJson,
+} from "../providers/codex-oauth/auth-json.js";
 import { materializeCodexAuthJson } from "../providers/codex-oauth/auth-json-fs.js";
 import {
   CODEX_OAUTH_POOL_SLOTS_ENV,
@@ -1937,17 +1940,9 @@ export async function resolveCodexOAuthCredentialInfo(
           await materializeCodexAuthJson(selectedSlot, slotEntry.creds, {
             includeRefreshToken: false,
           });
-          const authJson = {
-            auth_mode: "chatgpt" as const,
-            OPENAI_API_KEY: null,
-            tokens: {
-              id_token: slotEntry.creds.access,
-              access_token: slotEntry.creds.access,
-              refresh_token: slotEntry.creds.refresh,
-              account_id: slotEntry.creds.accountId,
-            },
-            last_refresh: new Date(slotEntry.creds.expires).toISOString(),
-          };
+          const authJson = credentialsToAuthJson(slotEntry.creds, {
+            includeRefreshToken: false,
+          });
           const sel = {
             ...authJsonToCredentialSelection(authJson, selectedSlot, slots.length),
             authFailureFence,

package/src/heartbeat/heartbeat.ts

@@ -1,3 +1,4 @@
+import pkg from "../../package.json";
 import {
   autoCancelStaleApprovalRequests,
   timeoutExpiredApprovalRequests,
@@ -247,6 +248,15 @@ function isHeartbeatChecklistDisabled(): boolean {
   return isEnvFlagEnabled("HEARTBEAT_CHECKLIST_DISABLE", false);
 }
 
+/**
+ * Whether to create the boot-triage task even when the boot is clean (no
+ * interrupted, stalled, orphaned, or resume-less superseded work). Off by
+ * default: a clean boot only logs a one-line note.
+ */
+function isBootTriageAlways(): boolean {
+  return isEnvFlagEnabled("HEARTBEAT_BOOT_TRIAGE_ALWAYS", false);
+}
+
 // ============================================================================
 // Types
 // ============================================================================
@@ -1576,24 +1586,7 @@ export async function gatherSystemStatus(options?: { isBootTriage?: boolean }):
     }
 
     // Orphaned pending/offered tasks (assigned to workers with no active session)
-    const orphanedTasks: AgentTask[] = [];
-
-    for (const status of ["pending", "offered"] as const) {
-      const tasks = await getTasksByStatus(status);
-
-      for (const task of tasks) {
-        // 'pending' tasks carry their holder in agentId; 'offered' tasks have
-        // not been accepted yet, so agentId is still NULL and the offeree
-        // lives in offeredTo instead (#1190) — `!task.agentId` alone used to
-        // skip every offered row here, hiding this whole class of orphan.
-        const holderId = status === "offered" ? task.offeredTo : task.agentId;
-        if (!holderId) continue;
-        const agent = agents.find((a) => a.id === holderId);
-        if (!agent || agent.status === "offline") {
-          orphanedTasks.push(task);
-        }
-      }
-    }
+    const orphanedTasks = await getOrphanedPendingOrOfferedTasks(agents);
 
     if (orphanedTasks.length > 0) {
       sections.push("");
@@ -1617,6 +1610,60 @@ export async function gatherSystemStatus(options?: { isBootTriage?: boolean }):
   return sections.join("\n");
 }
 
+/** Pending/offered tasks whose holder is offline or no longer registered. */
+async function getOrphanedPendingOrOfferedTasks(
+  agents: Awaited<ReturnType<typeof getAllAgents>>,
+): Promise<AgentTask[]> {
+  const orphanedTasks: AgentTask[] = [];
+
+  for (const status of ["pending", "offered"] as const) {
+    const tasks = await getTasksByStatus(status);
+
+    for (const task of tasks) {
+      // 'pending' tasks carry their holder in agentId; 'offered' tasks have
+      // not been accepted yet, so agentId is still NULL and the offeree
+      // lives in offeredTo instead (#1190) — `!task.agentId` alone used to
+      // skip every offered row here, hiding this whole class of orphan.
+      const holderId = status === "offered" ? task.offeredTo : task.agentId;
+      if (!holderId) continue;
+      const agent = agents.find((a) => a.id === holderId);
+      if (!agent || agent.status === "offline") {
+        orphanedTasks.push(task);
+      }
+    }
+  }
+
+  return orphanedTasks;
+}
+
+export interface BootTriageFindings {
+  rebootInterrupted: number;
+  stalled: number;
+  orphaned: number;
+  supersededWithoutResume: number;
+}
+
+/**
+ * Count the boot signals the Lead would have to act on. All zero means a
+ * clean boot: nothing was interrupted, stuck, orphaned, or left without a
+ * resume, so a Lead task would only echo the deploy.
+ */
+export async function getBootTriageFindings(): Promise<BootTriageFindings> {
+  const now = Date.now();
+  const agents = await getAllAgents();
+  return {
+    rebootInterrupted: getRebootAffectedTasks().length,
+    stalled: (await getStalledInProgressTasks(stallThresholdMinutes())).length,
+    orphaned: (await getOrphanedPendingOrOfferedTasks(agents)).length,
+    supersededWithoutResume: (
+      await getSupersededTasksWithoutResume(
+        new Date(now - ORPHAN_SUPERSEDE_MIN_AGE_MS).toISOString(),
+        new Date(now - ORPHAN_SUPERSEDE_MAX_AGE_MS).toISOString(),
+      )
+    ).length,
+  };
+}
+
 /**
  * Check HEARTBEAT.md content and create a checklist task for the lead if needed.
  */
@@ -1858,6 +1905,8 @@ export function stopHeartbeat(): void {
 /**
  * Create a one-off boot triage task for the lead after a server restart.
  * Uses the same HEARTBEAT.md content but with reboot-specific context prepended.
+ * Skipped on a clean boot (see getBootTriageFindings) unless
+ * HEARTBEAT_BOOT_TRIAGE_ALWAYS is set.
  */
 export async function createBootTriageTask(): Promise<void> {
   const lead = await getLeadAgent();
@@ -1876,7 +1925,30 @@ export async function createBootTriageTask(): Promise<void> {
   );
   if (existing) return;
 
-  const systemStatus = await gatherSystemStatus({ isBootTriage: true });
+  if (!isBootTriageAlways()) {
+    // A failed read falls through to the Lead task: an unknown boot is not a
+    // clean one.
+    const findings = await getBootTriageFindings().catch((err) => {
+      console.error(
+        "[Heartbeat] Boot triage findings failed, creating Lead task:",
+        scrubSecrets(err instanceof Error ? err.message : String(err)),
+      );
+      return null;
+    });
+    if (findings && Object.values(findings).every((count) => count === 0)) {
+      console.log(
+        `[Heartbeat] Clean boot (v${pkg.version}): 0 interrupted, stalled, orphaned, or resume-less superseded tasks; no boot-triage task for lead ${lead.name}`,
+      );
+      return;
+    }
+  }
+
+  // A reader that failed above can fail again here; the task must still land.
+  const systemStatus = await gatherSystemStatus({ isBootTriage: true }).catch((err) => {
+    const reason = scrubSecrets(err instanceof Error ? err.message : String(err));
+    console.error("[Heartbeat] Boot triage status gathering failed:", reason);
+    return `## System status unavailable\n\nStatus gathering failed after this boot (${reason}). Investigate the task, agent, and DB state directly.`;
+  });
 
   const result = resolveTemplate("heartbeat.boot-triage", {
     system_status: systemStatus,

package/src/hooks/hook.ts

@@ -168,12 +168,25 @@ export async function postHookProfileUpdate({
 }
 
 /**
- * Hook response for blocking actions
+ * Hook JSON responses. Claude Code parses stdout as JSON only when the whole
+ * stdout is one JSON object, so these must be the only stdout of the event.
  * See: https://code.claude.com/docs/en/hooks
  */
-interface HookBlockResponse {
-  decision: "block";
-  reason: string;
+type HookBlockResponse =
+  | {
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse";
+        permissionDecision: "deny";
+        permissionDecisionReason: string;
+      };
+    }
+  | { decision: "block"; reason: string };
+
+interface HookContextResponse {
+  hookSpecificOutput: {
+    hookEventName: "PreToolUse" | "PostToolUse";
+    additionalContext: string;
+  };
 }
 
 /**
@@ -850,12 +863,33 @@ export async function handleHook(): Promise<void> {
 
   /**
    * Output a blocking response to stop Claude from continuing.
-   * This is used when a task has been cancelled.
+   * Must be the only stdout of the event: any plain line before it makes
+   * Claude Code read the whole stdout as text and run the tool anyway.
    */
   const outputBlockResponse = (reason: string): void => {
-    const response: HookBlockResponse = {
-      decision: "block",
-      reason,
+    const response: HookBlockResponse =
+      msg.hook_event_name === "PreToolUse"
+        ? {
+            hookSpecificOutput: {
+              hookEventName: "PreToolUse",
+              permissionDecision: "deny",
+              permissionDecisionReason: reason,
+            },
+          }
+        : { decision: "block", reason };
+    console.log(JSON.stringify(response));
+  };
+
+  /**
+   * Output context for the model on a tool event. Plain stdout on PreToolUse
+   * and PostToolUse never reaches the model; additionalContext does.
+   */
+  const outputToolContext = (
+    hookEventName: "PreToolUse" | "PostToolUse",
+    additionalContext: string,
+  ): void => {
+    const response: HookContextResponse = {
+      hookSpecificOutput: { hookEventName, additionalContext },
     };
     console.log(JSON.stringify(response));
   };
@@ -988,8 +1022,23 @@ export async function handleHook(): Promise<void> {
   // Get current agent info
   const agentInfo = await getAgentInfo();
 
-  // Always output agent status with system tray
-  if (agentInfo) {
+  // A block must be the only stdout of the event, so a cancelled task is
+  // checked before the status line goes out.
+  if (
+    msg.hook_event_name === "UserPromptSubmit" &&
+    agentInfo &&
+    !agentInfo.isLead &&
+    agentInfo.status === "busy"
+  ) {
+    if (await checkAndBlockIfCancelled(true)) {
+      return;
+    }
+  }
+
+  // Output agent status with system tray. Skipped on tool events: their plain
+  // stdout never reaches the model and would break a JSON decision.
+  const isToolEvent = msg.hook_event_name === "PreToolUse" || msg.hook_event_name === "PostToolUse";
+  if (agentInfo && !isToolEvent) {
     // Base status line
     console.log(
       `You are registered as ${agentInfo.isLead ? "lead" : "worker"} agent "${agentInfo.name}" (ID: ${agentInfo.id}, status: ${agentInfo.status}).`,
@@ -1004,7 +1053,7 @@ export async function handleHook(): Promise<void> {
     }
   } else if (
     shouldShowRegistrationNudge({
-      agentInfoPresent: false,
+      agentInfoPresent: Boolean(agentInfo),
       eventType: msg.hook_event_name,
       hasAgentIdHeader: hasAgentIdHeader(),
     })
@@ -1131,8 +1180,7 @@ export async function handleHook(): Promise<void> {
       }
 
       // Block `gh pr create|edit` when the body for a public repo leaks internal
-      // identifiers. Exit code 2 blocks the call even though the status line
-      // above already went to stdout, and stderr reaches the model.
+      // identifiers. Exit code 2 blocks the call and stderr reaches the model.
       if (msg.tool_name === "Bash") {
         const prBodyBlock = await guardGhPrBody(msg.tool_input, msg.cwd ?? process.cwd());
         if (prBodyBlock) {
@@ -1142,6 +1190,9 @@ export async function handleHook(): Promise<void> {
         }
       }
 
+      // Emitted last, so a later block stays the only stdout of the event.
+      let loopWarning: string | undefined;
+
       // Tool loop detection (workers only, when processing a task)
       if (agentInfo && !agentInfo.isLead && agentInfo.status === "busy") {
         const loopTaskFile = await readTaskFile();
@@ -1162,7 +1213,7 @@ export async function handleHook(): Promise<void> {
           }
 
           if (loopResult.severity === "warning" && loopResult.reason) {
-            console.log(`Warning: ${loopResult.reason}`);
+            loopWarning = `Warning: ${loopResult.reason}`;
           }
         }
       }
@@ -1179,6 +1230,9 @@ export async function handleHook(): Promise<void> {
         }
       }
 
+      if (loopWarning) {
+        outputToolContext("PreToolUse", loopWarning);
+      }
       break;
     }
 
@@ -1200,7 +1254,8 @@ export async function handleHook(): Promise<void> {
           method: "PUT",
           headers: mcpConfig!.headers,
         }).catch((e) => {
-          console.debug("Failed to update agent activity timestamp:", e);
+          // stderr: stdout on this event is reserved for one JSON object.
+          console.error("Failed to update agent activity timestamp:", e);
         });
       }
 
@@ -1270,7 +1325,8 @@ export async function handleHook(): Promise<void> {
           if (msg.tool_name?.endsWith("send-task")) {
             const maybeTaskId = (msg.tool_response as { task?: { id?: string } })?.task?.id;
 
-            console.log(
+            outputToolContext(
+              "PostToolUse",
               `Task sent successfully.${maybeTaskId ? ` Task ID: ${maybeTaskId}.` : ""} Monitor progress using the get-task-details tool periodically.`,
             );
           }
@@ -1278,17 +1334,6 @@ export async function handleHook(): Promise<void> {
       }
       break;
 
-    case "UserPromptSubmit": {
-      // For worker agents, check if their task has been cancelled
-      // This catches cancellations at the start of a new iteration
-      if (agentInfo && !agentInfo.isLead && agentInfo.status === "busy") {
-        if (await checkAndBlockIfCancelled(true)) {
-          return; // Exit early
-        }
-      }
-      break;
-    }
-
     case "Stop":
       // Clean up any artifact tunnels managed by PM2
       try {

package/src/http/mcp.ts

@@ -244,6 +244,11 @@ export async function handleMcp(
       }
       const server = await createServer({
         preloadedTools,
+        // Agent row, then global row, then deployment env. A blank agent row
+        // resolves to "unset" for that agent.
+        enabledTools:
+          configs.find((config) => config.key === "SWARM_ENABLED_TOOLS")?.value ??
+          process.env.SWARM_ENABLED_TOOLS,
         scriptsOnly: resolveScriptsOnlyMode({
           env: process.env.SCRIPTS_ONLY_MCP,
           configValue,

package/src/http/onboarding.ts

@@ -21,6 +21,7 @@ import {
 } from "../be/onboarding";
 import { assertUrlSafe, publicEndpointSsrfOptions } from "../oauth/mcp-wrapper";
 import { ProviderNameSchema } from "../types";
+import { getOpenRouterAttributionHeaders } from "../utils/openrouter-base-url";
 import { ensureConfigAdmin } from "./config";
 import { scheduleIntegrationsReload } from "./core";
 import { route } from "./route-def";
@@ -255,6 +256,7 @@ async function handleMemoryProbe(body: OnboardingMemoryRequest): Promise<Onboard
     const client = new OpenAI({
       baseURL: endpoint.toString(),
       apiKey,
+      defaultHeaders: getOpenRouterAttributionHeaders(endpoint.toString()),
       timeout: 15_000,
       maxRetries: 0,
       fetchOptions: { redirect: "manual" },

package/src/providers/acp-targets.ts

@@ -2,6 +2,7 @@ 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 {
   ACP_TARGET_IDS,
@@ -9,6 +10,7 @@ import {
   getAcpTargetCatalogEntry,
   isAcpTarget,
 } from "./acp-target-catalog";
+import { applyOpenRouterBaseUrlOverride } from "./opencode-adapter";
 import { applyReasoningEffort } from "./reasoning-effort";
 import type { CostData, CostModelUsage, ProviderEvent, ProviderSessionConfig } from "./types";
 
@@ -124,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) {
@@ -138,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[] {
@@ -203,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,

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.1791403257-g05ffa9";
+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/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: [