@desplega.ai/agent-swarm 1.79.4 → 1.80.1

package/src/providers/codex-adapter.ts

@@ -66,6 +66,11 @@ import {
   type WebSearchItem,
 } from "@openai/codex-sdk";
 import { buildRatingsFromLlm, fetchRetrievalsForTask, postRatings } from "../be/memory/raters/llm";
+import {
+  CONTEXT_FORMULA,
+  clampContextPercent,
+  computeContextUsedUnified,
+} from "../utils/context-window";
 import { summarizeSession as runSummarize } from "../utils/internal-ai";
 import { scrubSecrets } from "../utils/secret-scrubber";
 import { type CodexAgentsMdHandle, writeCodexAgentsMd } from "./codex-agents-md";
@@ -523,6 +528,11 @@ class CodexSession implements ProviderSession {
     const inputTokens = usage?.input_tokens ?? 0;
     const cachedInputTokens = usage?.cached_input_tokens ?? 0;
     const outputTokens = usage?.output_tokens ?? 0;
+    // Phase 6: Codex SDK surfaces `reasoning_output_tokens` separately from
+    // `output_tokens` for reasoning models (gpt-5.3-codex, gpt-5.4 thinking).
+    // Pre-fix this number was read into `lastUsage` but never reached
+    // `CostData`, so reasoning-heavy sessions silently under-billed.
+    const reasoningOutputTokens = usage?.reasoning_output_tokens ?? 0;
     return {
       // Runner overrides with its own session id.
       sessionId: "",
@@ -540,9 +550,12 @@ class CodexSession implements ProviderSession {
       ),
       inputTokens,
       outputTokens,
+      reasoningOutputTokens,
       cacheReadTokens: cachedInputTokens,
-      // Codex does not distinguish cache writes in its Usage payload.
-      cacheWriteTokens: 0,
+      // Phase 6: undefined (NOT 0). Codex SDK can't honestly report cache
+      // writes; leaving it undefined preserves that distinction in the DB
+      // instead of mixing genuine zeros with "unknown".
+      cacheWriteTokens: undefined,
       durationMs: Date.now() - this.startedAt,
       numTurns: this.numTurns,
       model: this.resolvedModel,
@@ -760,36 +773,34 @@ class CodexSession implements ProviderSession {
       case "turn.completed": {
         this.lastUsage = event.usage;
         if (event.usage) {
-          // The Codex SDK reports `input_tokens` as the SUM of every prompt
-          // sent to the model across the entire turn (one `codex exec` call
-          // can fan out to dozens of model invocations as MCP tools roundtrip
-          // back and forth). For chatty turns this number routinely exceeds
-          // the model's context window, even though no single model call did.
+          // Phase 9: switch from the codex-specific "peak proxy" formula
+          // (`uncached_input + output`) to the unified
+          // `input + cache_read + cache_create + output` so cross-provider
+          // percent comparisons are meaningful.
           //
-          // For peak-context reporting we want a proxy for "the largest
-          // single-call prompt". We approximate it as the uncached portion
-          // (cached tokens are reused across calls so they count once toward
-          // the actual peak), plus the output. This isn't perfect — the SDK
-          // would have to expose per-call stats for that — but it's far more
-          // representative than `(input + output) / window` which clamps to
-          // 1.0 the moment a turn makes any meaningful tool history.
-          const uncachedInput = Math.max(
-            0,
-            event.usage.input_tokens - event.usage.cached_input_tokens,
-          );
-          const peakProxy = uncachedInput + event.usage.output_tokens;
-          // `contextPercent` is on a 0-100 scale across all providers — claude
-          // emits `(used / total) * 100`, pi-mono passes through `usage.percent`
-          // which is already 0-100. The dashboard at
-          // ui/src/pages/tasks/[id]/page.tsx renders it via `.toFixed(0)`
-          // expecting an integer percent, so a 0-1 fraction would render as
-          // "0%" instead of e.g. "40%".
+          // Note: Codex's `input_tokens` already includes cached_input_tokens
+          // (it's the TOTAL across the turn — see the longer comment that
+          // used to live here, preserved in git history). We therefore pass
+          // `cacheReadTokens: 0` to avoid double-counting the cached portion.
+          // The trade-off the old comment flagged is still real — a chatty
+          // turn can over-report because `input_tokens` is the SUM across
+          // every model call in the turn — but having the SAME formula
+          // everywhere wins over the local optimum. Clamp catches the
+          // chatty-turn overshoot at 100%. Old rows tagged 'peak-proxy'
+          // remain in `task_context_snapshots`; the UI surfaces both.
+          const contextUsed = computeContextUsedUnified({
+            inputTokens: event.usage.input_tokens,
+            cacheReadTokens: 0,
+            cacheCreateTokens: 0,
+            outputTokens: event.usage.output_tokens,
+          });
           this.emit({
             type: "context_usage",
-            contextUsedTokens: peakProxy,
+            contextUsedTokens: contextUsed,
             contextTotalTokens: this.contextWindow,
-            contextPercent: Math.min(100, (peakProxy / this.contextWindow) * 100),
+            contextPercent: clampContextPercent(contextUsed, this.contextWindow) ?? 0,
             outputTokens: event.usage.output_tokens,
+            contextFormula: CONTEXT_FORMULA,
           });
         }
         break;

package/src/providers/codex-models.ts

@@ -126,12 +126,22 @@ export const CODEX_MODEL_PRICING: Record<CodexModel, CodexModelPricing> = {
   },
 };
 
+/**
+ * Phase 6 — one-warning-per-process tracking so unknown models log once
+ * instead of spamming the worker log on every turn.
+ */
+const _warnedUnknownCodexModels = new Set<string>();
+
 /**
  * Compute USD cost from a Codex `Usage` payload. The Codex SDK reports
  * `input_tokens` as the TOTAL input fed to the model across the turn (cached
  * + uncached), so we subtract `cached_input_tokens` before billing the
- * uncached portion at the full rate. Returns 0 for unknown models so we never
- * inflate cost on a typo.
+ * uncached portion at the full rate.
+ *
+ * Phase 6: returns 0 for unknown models AND logs a one-time warning, so an
+ * operator running `MODEL_OVERRIDE=gpt-future-2027` notices that the worker
+ * is silently dropping cost. The server-side recompute path (Phase 2) tags
+ * such rows `costSource='unpriced'`, which surfaces as a yellow UI badge.
  */
 export function computeCodexCostUsd(
   model: string,
@@ -140,7 +150,16 @@ export function computeCodexCostUsd(
   outputTokens: number,
 ): number {
   const pricing = CODEX_MODEL_PRICING[model as CodexModel];
-  if (!pricing) return 0;
+  if (!pricing) {
+    if (!_warnedUnknownCodexModels.has(model)) {
+      _warnedUnknownCodexModels.add(model);
+      console.warn(
+        `[codex] unpriced model ${JSON.stringify(model)} — adapter cost will report $0; ` +
+          "server-side recompute will tag costSource='unpriced' if the pricing table has no rows.",
+      );
+    }
+    return 0;
+  }
   const uncachedInput = Math.max(0, inputTokens - cachedInputTokens);
   const inputCost = (uncachedInput / 1_000_000) * pricing.inputPerMillion;
   const cachedCost = (cachedInputTokens / 1_000_000) * pricing.cachedInputPerMillion;

package/src/providers/devin-adapter.ts

@@ -279,6 +279,12 @@ class DevinSession implements ProviderSession {
     if (this.settled || this.aborted) return;
     this.pollCount += 1;
 
+    // Phase 8: Devin's session API does NOT report per-poll context-window
+    // info (the model is fully managed by Devin). We deliberately don't emit
+    // a synthetic `context_usage` event here — faking one with `contextUsedTokens=0`
+    // would be misleading. `peakContextTokens` stays null for devin tasks,
+    // which the UI surfaces as "not available" rather than "0".
+
     let response: DevinSessionResponse;
     try {
       response = await getSession(this.orgId, this.devinApiKey, this._sessionId!);
@@ -788,6 +794,11 @@ class DevinSession implements ProviderSession {
       numTurns: this.pollCount,
       model: "devin",
       isError,
+      // Phase 3 — tag CostData so the API recompute path engages. Devin's
+      // pricing is ACU-based (one row under `provider='devin', model='*',
+      // token_class='acu'`); the harness USD value above is already correct,
+      // but tagging the row exposes its source to the UI badge.
+      provider: "devin",
     };
   }
 }

package/src/providers/opencode-adapter.ts

@@ -12,7 +12,11 @@ import { existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import type { AssistantMessage, Config, Event as OpencodeEvent } from "@opencode-ai/sdk";
 import { createOpencode } from "@opencode-ai/sdk";
-import { getContextWindowSize } from "../utils/context-window";
+import {
+  CONTEXT_FORMULA,
+  clampContextPercent,
+  getContextWindowSize,
+} from "../utils/context-window";
 import { validateOpencodeCredentials } from "../utils/credentials";
 import { fetchInstalledMcpServers } from "../utils/mcp-server-fetcher";
 import { scrubSecrets } from "../utils/secret-scrubber";
@@ -104,7 +108,7 @@ function resolvePluginPath(): string {
   return join(import.meta.dir, "../../plugin/opencode-plugins/agent-swarm.ts");
 }
 
-class OpencodeSession implements ProviderSession {
+export class OpencodeSession implements ProviderSession {
   private _sessionId: string;
   private listeners: Array<(event: ProviderEvent) => void> = [];
   // Buffer for events emitted before any listener is attached.
@@ -115,6 +119,7 @@ class OpencodeSession implements ProviderSession {
   // leaving agent_tasks.provider/.model NULL. Buffer + flush on first attach.
   private pendingEvents: ProviderEvent[] = [];
   private completionResolve!: (result: ProviderResult) => void;
+  // biome-ignore lint/correctness/noUnusedPrivateClassMembers: reserved for future error-propagation paths; symmetric with completionResolve.
   private completionReject!: (err: Error) => void;
   private completionPromise: Promise<ProviderResult>;
   private server: { url: string; close(): void };
@@ -237,6 +242,15 @@ class OpencodeSession implements ProviderSession {
       case "message.updated": {
         const msg = ev.properties.info;
         if (!isAssistantMessage(msg) || msg.sessionID !== this._sessionId) break;
+        // Phase 9 fix: opencode fires `message.updated` repeatedly during a single
+        // assistant turn (streaming text deltas, tool transitions, etc.) and only
+        // populates `tokens`/`cost` on the FINAL update once `time.completed` is
+        // set. Accumulating on every event would either no-op (zero tokens) or —
+        // if opencode ever back-fills intermediate snapshots — multi-count. Gate
+        // the accumulator AND the context emit on the finalized signal so both
+        // paths see the same canonical "this turn is done" moment.
+        const messageFinalized = msg.time?.completed != null;
+        if (!messageFinalized) break;
         // Accumulate cost from each completed assistant message ("step")
         this.totalCostUsd += msg.cost;
         this.inputTokens += msg.tokens?.input ?? 0;
@@ -247,21 +261,31 @@ class OpencodeSession implements ProviderSession {
         if (!this.model && msg.modelID) this.model = msg.modelID;
 
         // Emit context_usage so the runner can POST /api/tasks/:id/context
-        // (drives the dashboard's context-usage progress bar) and the
-        // dashboard's activity timeline shows per-turn progress.
+        // (drives the dashboard's context-usage progress bar). The runner-side
+        // throttle (CONTEXT_THROTTLE_MS = 30s) means the FIRST emit wins for any
+        // short task — so this MUST carry real numbers, not the zero-tokens
+        // placeholder opencode sends on intermediate streaming updates. The
+        // `time.completed` gate above (in the accumulator block) guarantees we
+        // only land here for finalized messages.
         const turnInput = msg.tokens?.input ?? 0;
         const turnOutput = msg.tokens?.output ?? 0;
         const turnCacheRead = msg.tokens?.cache?.read ?? 0;
         const turnCacheWrite = msg.tokens?.cache?.write ?? 0;
-        const contextUsed = turnInput + turnCacheRead + turnCacheWrite;
+        // Phase 8 + Phase 9: unified `input + cache + output` formula instead
+        // of the previous `input + cache_read + cache_write` (which omitted
+        // output and slightly mis-counted vs every other adapter).
+        const contextUsed = turnInput + turnCacheRead + turnCacheWrite + turnOutput;
         const contextTotal = getContextWindowSize(this.model || msg.modelID || "default");
-        if (contextTotal > 0) {
+        if (contextTotal > 0 && contextUsed > 0) {
           this.emit({
             type: "context_usage",
             contextUsedTokens: contextUsed,
             contextTotalTokens: contextTotal,
-            contextPercent: (contextUsed / contextTotal) * 100,
+            // Phase 8: clamp so a turn that briefly overshoots (e.g. due to
+            // a stale total) doesn't render as a 130% gauge in the UI.
+            contextPercent: clampContextPercent(contextUsed, contextTotal) ?? 0,
             outputTokens: turnOutput,
+            contextFormula: CONTEXT_FORMULA,
           });
         }
         break;

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

@@ -264,7 +264,7 @@ function cleanupAgentsMdSymlink(cwd: string): void {
   }
 }
 
-class PiMonoSession implements ProviderSession {
+export class PiMonoSession implements ProviderSession {
   private listeners: Array<(event: ProviderEvent) => void> = [];
   private eventQueue: ProviderEvent[] = [];
   private _sessionId: string | undefined;
@@ -275,6 +275,14 @@ class PiMonoSession implements ProviderSession {
   private logFileHandle: ReturnType<ReturnType<typeof Bun.file>["writer"]>;
   /** Track last emitted message text to avoid duplicates across turns */
   private lastEmittedMessage = "";
+  /** Phase 7: wallclock start so we can populate `durationMs` on the cost row. */
+  private sessionStartedAt: number = Date.now();
+  /**
+   * Phase 7: previous output-token total — used to derive per-turn delta for
+   * `context_usage.outputTokens` since pi-ai's `getContextUsage()` doesn't
+   * surface it directly.
+   */
+  private prevOutputTokens = 0;
 
   constructor(agentSession: AgentSession, config: ProviderSessionConfig, createdSymlink: boolean) {
     this.agentSession = agentSession;
@@ -282,6 +290,7 @@ class PiMonoSession implements ProviderSession {
     this.createdSymlink = createdSymlink;
     this.logFileHandle = Bun.file(config.logFile).writer();
     this._sessionId = agentSession.sessionId;
+    this.sessionStartedAt = Date.now();
 
     // Emit session_init immediately
     this.emit({ type: "session_init", sessionId: this._sessionId, provider: "pi" });
@@ -293,6 +302,18 @@ class PiMonoSession implements ProviderSession {
     this.completionPromise = this.runSession();
   }
 
+  /**
+   * Canonical model slug for downstream reporting (latestModel, raw_log envelopes).
+   * Composes `${provider}/${id}` from the resolved pi-ai model so the UI snapshot
+   * lookup matches (e.g. `openrouter/deepseek/deepseek-v4-flash`). Falls back to
+   * the configured model string if the session didn't resolve one.
+   */
+  private reportedModel(): string {
+    const m = this.agentSession.model;
+    if (m) return `${m.provider}/${m.id}`;
+    return this.config.model;
+  }
+
   private emit(event: ProviderEvent): void {
     // Scrub secrets from raw_log / raw_stderr content before egress (log file
     // write, listener dispatch, downstream session-logs push + pretty-print).
@@ -329,7 +350,7 @@ class PiMonoSession implements ProviderSession {
                 .trim()
             : String(msg.content || "").trim();
           if (text && text !== this.lastEmittedMessage) {
-            const model = this.agentSession.model?.name ?? this.config.model;
+            const model = this.reportedModel();
             this.emit({
               type: "raw_log",
               content: JSON.stringify({
@@ -344,21 +365,30 @@ class PiMonoSession implements ProviderSession {
             this.lastEmittedMessage = text;
           }
         }
-        // Emit context_usage for dashboard tracking
+        // Emit context_usage for dashboard tracking.
+        // Phase 7: derive `outputTokens` from `SessionStats` delta (pi-ai's
+        // `getContextUsage()` doesn't expose per-turn output tokens, but the
+        // session-stats counter is monotonic so a delta is correct).
         const usage = this.agentSession.getContextUsage();
         if (usage && usage.tokens != null) {
+          const stats = this.agentSession.getSessionStats();
+          const currOutput = stats?.tokens?.output ?? 0;
+          const outputDelta = Math.max(0, currOutput - this.prevOutputTokens);
+          this.prevOutputTokens = currOutput;
           this.emit({
             type: "context_usage",
             contextUsedTokens: usage.tokens,
             contextTotalTokens: usage.contextWindow,
             contextPercent: usage.percent ?? 0,
-            outputTokens: 0,
+            outputTokens: outputDelta,
+            // Phase 9: pi-ai owns the formula — we just relay its number.
+            contextFormula: "pi-delegated",
           });
         }
         break;
       }
       case "tool_execution_start": {
-        const model = this.agentSession.model?.name ?? this.config.model;
+        const model = this.reportedModel();
         this.emit({
           type: "raw_log",
           content: JSON.stringify({
@@ -489,9 +519,11 @@ class PiMonoSession implements ProviderSession {
       outputTokens: stats.tokens.output,
       cacheReadTokens: stats.tokens.cacheRead,
       cacheWriteTokens: stats.tokens.cacheWrite,
-      durationMs: 0, // Not directly available from SessionStats
+      // Phase 7: real wallclock duration; pi-ai SessionStats doesn't carry
+      // one so we track it on this adapter instance.
+      durationMs: Date.now() - this.sessionStartedAt,
       numTurns: stats.userMessages + stats.assistantMessages,
-      model: this.agentSession.model?.name ?? this.config.model,
+      model: this.reportedModel(),
       isError: false,
       provider: "pi",
     };

package/src/providers/pricing-sources.md

@@ -0,0 +1,52 @@
+# Pricing sources
+
+This page lists the sources that feed the `pricing` table at server boot.
+Operators bumping a rate by hand should also update this file.
+
+## Primary: vendored models.dev snapshot
+
+- **Path**: `ui/src/lib/modelsdev-cache.json`
+- **Loaded by**: `src/be/seed-pricing.ts` → `seedPricingFromModelsDev()`,
+  called from `src/server.ts` after `initDb`.
+- **Projection rules** (see the same module for code-level detail):
+  - Anthropic models → rows under `provider='claude'` AND `provider='claude-managed'`.
+    Shortnames (`opus`, `sonnet`, `haiku`) ALSO get rows keyed by the current
+    default full id (e.g. `opus → claude-opus-4-7`). Pi-mono uses the same
+    shortname forms, so they're projected under `provider='pi'` as well.
+  - OpenAI models → rows under `provider='codex'`.
+  - OpenRouter models → rows under `provider='opencode'`. Any `google/...`
+    row additionally gets projected under `provider='gemini'` (both the
+    stripped name and the full `google/...` id) so internal-ai callers find
+    a hit either way.
+
+- **Refresh procedure** (the only place to update the snapshot):
+  - Run `bun run scripts/refresh-modelsdev-pricing.ts` (Phase 2 — adds the
+    script). It fetches the latest snapshot from models.dev, diffs against
+    the vendored copy, prints a summary, and writes the new file.
+  - Commit the regenerated `modelsdev-cache.json` together with a bump
+    note in the PR description.
+
+## Manual overrides
+
+Two cost components models.dev doesn't carry are encoded in
+`MANUAL_PRICING_OVERRIDES` inside `src/be/seed-pricing.ts`:
+
+| Provider         | Model | Token class    | Rate         | Source                                                                         | Verified   |
+|------------------|-------|----------------|--------------|---------------------------------------------------------------------------------|------------|
+| `claude-managed` | `*`   | `runtime_hour` | $0.08 / hour | <https://docs.claude.com/en/api/agent-sdk/managed-runtime#pricing>             | 2026-04-28 |
+| `devin`          | `*`   | `acu`          | $2.25 / ACU  | <https://devin.ai/pricing>                                                      | 2026-04-28 |
+
+The `pricePerMillionUsd` column carries these as `rate * 1_000_000` so the
+same schema fits — the adapter scales by the underlying unit (hours / ACUs),
+not by tokens. The unit convention is specific to those `token_class` values.
+
+## When a model is missing
+
+If `POST /api/session-costs` arrives with a `(provider, model)` pair that has
+no input/output pricing rows at the lookup time, the row is persisted with
+`costSource='unpriced'` (rather than 'harness'). The UI surfaces this as a
+yellow badge.
+
+To fix: either add the model to `modelsdev-cache.json` (preferred — the
+upstream snapshot probably needs refreshing) or add a manual override row via
+the existing admin route `POST /api/pricing`.

package/src/providers/swarm-events-shared.ts

@@ -167,8 +167,10 @@ export function createSwarmEventHandler(
 
   const progressContextUsage = (event: {
     contextUsedTokens: number;
-    contextTotalTokens: number;
-    contextPercent: number;
+    // Migration 063: nullable for adapters that can't resolve a window.
+    contextTotalTokens: number | null;
+    contextPercent: number | null;
+    contextFormula?: string;
   }): void => {
     if (opts.taskId && shouldRun("context-progress", CONTEXT_THROTTLE_MS)) {
       fireAndForget(`${opts.apiUrl}/api/tasks/${encodeURIComponent(opts.taskId)}/context`, {
@@ -178,8 +180,9 @@ export function createSwarmEventHandler(
           eventType: "progress",
           sessionId: sessionId ?? `${opts.sessionIdFallbackPrefix ?? "session"}-${opts.taskId}`,
           contextUsedTokens: event.contextUsedTokens,
-          contextTotalTokens: event.contextTotalTokens,
-          contextPercent: event.contextPercent,
+          contextTotalTokens: event.contextTotalTokens ?? undefined,
+          contextPercent: event.contextPercent ?? undefined,
+          contextFormula: event.contextFormula,
         }),
       });
     }
@@ -239,6 +242,7 @@ export function createSwarmEventHandler(
             contextUsedTokens: event.contextUsedTokens,
             contextTotalTokens: event.contextTotalTokens,
             contextPercent: event.contextPercent,
+            contextFormula: event.contextFormula,
           });
           break;
         }

package/src/providers/types.ts

@@ -7,18 +7,30 @@ export interface CostData {
   inputTokens?: number;
   outputTokens?: number;
   cacheReadTokens?: number;
+  /**
+   * Migration 063: undefined means "the harness can't report this" (e.g. the
+   * Codex SDK has no cache-write field). Zero is reserved for "really zero".
+   */
   cacheWriteTokens?: number;
+  /** Migration 063: codex reasoning_output_tokens (and similar) for reasoning models. */
+  reasoningOutputTokens?: number;
+  /** Migration 063: claude extended-thinking tokens from CLI's `usage.thinking_input_tokens`. */
+  thinkingTokens?: number;
   durationMs: number;
-  numTurns: number;
+  /**
+   * Migration 063: nullable — some adapters (claude when `num_turns` is absent)
+   * can't honestly report a turn count; null is preferred over a faked 1.
+   */
+  numTurns: number | null;
   model: string;
   isError: boolean;
   /**
-   * Phase 6: tells the API which recompute path to use on
-   * `POST /api/session-costs`. Codex triggers the pricing-table recompute
-   * (when DB pricing rows exist for all three token classes); Claude / pi
-   * always trust the harness-reported `totalCostUsd` as-is.
+   * Phase 6 (extended migration 063): tells the API which recompute path to
+   * use on `POST /api/session-costs`. After Phase 2 the recompute path runs
+   * for every provider with seeded pricing rows, so every adapter should
+   * populate this field.
    */
-  provider?: "claude" | "codex" | "pi" | "opencode";
+  provider?: "claude" | "claude-managed" | "codex" | "pi" | "opencode" | "devin";
 }
 
 import type { ProviderName } from "../types";
@@ -43,14 +55,25 @@ export type ProviderEvent =
   | {
       type: "context_usage";
       contextUsedTokens: number;
-      contextTotalTokens: number;
-      contextPercent: number;
-      outputTokens: number;
+      // Migration 063: nullable so adapters (e.g. devin without a context API)
+      // can emit a snapshot that records cumulative tokens without faking a window.
+      contextTotalTokens: number | null;
+      // Migration 063: null if contextTotalTokens is missing (no divide-by-zero).
+      contextPercent: number | null;
+      // Migration 063: null when the adapter can't honestly report output tokens.
+      outputTokens: number | null;
+      /**
+       * Migration 063 — the formula the adapter used to compute
+       * contextUsedTokens. See `ContextFormulaSchema` in `src/types.ts` for the
+       * canonical value list. Adapters should always populate this going
+       * forward; it powers cross-provider apples-to-apples comparison.
+       */
+      contextFormula?: string;
     }
   | {
       type: "compaction";
       preCompactTokens: number;
-      compactTrigger: "auto" | "manual";
+      compactTrigger: "auto" | "manual" | "auto-inferred";
       contextTotalTokens: number;
     };
 

package/src/scripts-runtime/ctx.ts

@@ -0,0 +1,23 @@
+import { stdlib } from "./stdlib";
+import type { SwarmConfig } from "./swarm-config";
+import { createSwarmSdk } from "./swarm-sdk";
+
+export type RuntimeCtx = {
+  swarm: Record<string, unknown> & { config: SwarmConfig };
+  stdlib: typeof stdlib;
+  logger: {
+    log: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+  };
+};
+
+export function buildCtx({ swarmConfig }: { swarmConfig: SwarmConfig }): RuntimeCtx {
+  const swarm = createSwarmSdk(swarmConfig) as Record<string, unknown> & { config: SwarmConfig };
+  swarm.config = swarmConfig;
+  return {
+    swarm,
+    stdlib,
+    logger: console,
+  };
+}

package/src/scripts-runtime/eval-harness.ts

@@ -0,0 +1,39 @@
+import { buildCtx } from "./ctx";
+import type { SwarmConfigPayload } from "./executors/types";
+import { SwarmConfig } from "./swarm-config";
+
+function requiredEnv(name: string): string {
+  const value = process.env[name];
+  if (!value) throw new Error(`Missing required env ${name}`);
+  return value;
+}
+
+try {
+  const stdin = await Bun.stdin.text();
+  if (!stdin.trim()) {
+    console.error("Swarm script config payload was empty");
+    process.exit(2);
+  }
+
+  const payload = JSON.parse(stdin) as SwarmConfigPayload;
+  const swarmConfig = new SwarmConfig(payload);
+  const rawArgs = JSON.parse(await Bun.file(requiredEnv("SWARM_SCRIPT_ARGS_FILE")).text());
+  // Accept both shapes: callers may pass an already-serialized JSON string.
+  const parsedArgs = typeof rawArgs === "string" ? JSON.parse(rawArgs) : rawArgs;
+  const ctx = buildCtx({ swarmConfig });
+
+  const sourceText = await Bun.file(requiredEnv("SWARM_SCRIPT_SOURCE_FILE")).text();
+  const userModulePath = `${requiredEnv("SWARM_SCRIPT_TMPDIR")}/user-script.ts`;
+  await Bun.write(userModulePath, sourceText);
+
+  const mod = await import(userModulePath);
+  if (typeof mod.default !== "function") {
+    throw new Error("Swarm script must export a default function");
+  }
+
+  const result = await mod.default(parsedArgs, ctx);
+  await Bun.write(requiredEnv("SWARM_SCRIPT_RESULT_FILE"), JSON.stringify(result ?? null));
+} catch (error) {
+  console.error(error instanceof Error ? error.stack || error.message : String(error));
+  process.exit(1);
+}