@desplega.ai/agent-swarm 1.158.0 → 1.160.0

package/src/providers/codex-models.ts

@@ -1,139 +1,73 @@
 /**
- * Codex API-addressable models, verified from https://developers.openai.com/api/docs/models
- * and https://developers.openai.com/api/docs/deprecations as of 2026-09-23.
+ * Codex model facts, read from the model catalog (model-catalog phase 4).
  *
- * NOTE: `gpt-5.3-codex-spark` is intentionally excluded. It is a ChatGPT Pro
- * research preview and is NOT API-addressable via the Codex SDK at launch.
- * Including it here would cause runtime errors if selected via MODEL_OVERRIDE.
+ * There is no hand-maintained Codex allowlist, context-window table or price
+ * table any more: every lookup reads the runtime catalog
+ * (`src/utils/runtime-model-catalog.ts` — the API's `model_catalog` + overlay
+ * rows, pulled over HTTP; the vendored models.dev snapshot offline). A new
+ * OpenAI model is therefore listed, windowed and priced as soon as it lands
+ * in `model_catalog`, with no code change and no redeploy.
  *
- * Bump this file when the CLI / SDK adds new models. Kept separate from the
- * adapter so the onboarding UI and model selector can import it without
- * pulling in the SDK.
+ * Which OpenAI SKUs count as Codex-drivable is a rule, not a list:
+ * `isHarnessCatalogModel("codex", ...)` in `@desplega/model-catalog`.
+ *
+ * Kept separate from the adapter so the onboarding UI and model selector can
+ * import it without pulling in the SDK.
  */
-import modelsDevCache from "../be/modelsdev-cache.json";
+import { harnessModelIds } from "@desplega/model-catalog";
+import { DEFAULT_MODEL_TIER_MAP } from "../types";
+import { runtimeCatalogModel, runtimeCatalogSection } from "../utils/runtime-model-catalog";
+
+/** Codex models from the catalog, newest first. Drives selectors and pricing tests. */
+export function listCodexModels(): string[] {
+  return harnessModelIds("codex", runtimeCatalogSection("openai"));
+}
 
 /**
- * List of Codex models we know about (drives the onboarding model selector,
- * the pricing table, and the context-window map). The resolver does NOT
- * constrain inputs to this list — it passes unknown strings through to the
- * SDK, so new OpenAI models work without a code change.
+ * The baseline default when neither MODEL_OVERRIDE nor task.model is set:
+ * the codex `regular` tier default (operators move it with
+ * `MODEL_TIER_CODEX_REGULAR`, resolved server-side at claim time).
  */
-export const CODEX_MODELS = [
-  "gpt-6-astra", // most capable model for complex reasoning, coding, and agentic work
-  "gpt-6-sol", // complex coding and agentic workflows
-  "gpt-6-luna", // focused, high-volume tasks
-  "gpt-5.6-sol", // frontier GPT-5.6 tier for complex reasoning/coding
-  "gpt-5.6-terra", // balanced GPT-5.6 tier
-  "gpt-5.6-luna", // fast/cheap GPT-5.6 tier for high-volume workloads
-  "gpt-5.5", // previous frontier coding/professional-work model
-  "gpt-5.4", // previous mainline reasoning model w/ frontier coding
-  "gpt-5.4-mini", // faster/cheaper
-  "gpt-5.3-codex", // coding-specialized legacy model
-  "gpt-5.2-codex", // legacy — scheduled for retirement, see openai deprecations page
-] as const;
-
-export type CodexModel = (typeof CODEX_MODELS)[number];
-
-/** The baseline default when neither MODEL_OVERRIDE nor task.model is set. */
-export const CODEX_DEFAULT_MODEL: CodexModel = "gpt-5.6-terra";
+export const CODEX_DEFAULT_MODEL: string = DEFAULT_MODEL_TIER_MAP.codex.regular;
 
 /**
- * Map claude-style shortnames (that flow through MODEL_OVERRIDE / task.model)
- * to Codex equivalents. Mirrors `pi-mono-adapter.ts:71-75` shortnames map so
- * a task authored for Claude works unchanged when pointed at a Codex worker.
+ * Claude-style shortnames (that flow through MODEL_OVERRIDE / task.model)
+ * map to the codex tier with the same intent, so a task authored for Claude
+ * works unchanged when pointed at a Codex worker.
  */
-const CLAUDE_SHORTNAMES: Record<string, CodexModel> = {
-  fable: "gpt-5.6-sol",
-  opus: "gpt-5.6-sol",
-  sonnet: "gpt-5.6-terra",
-  haiku: "gpt-5.6-luna",
-};
+const CLAUDE_SHORTNAME_TIER = {
+  fable: "ultra",
+  opus: "smart",
+  sonnet: "regular",
+  haiku: "smol",
+} as const;
 
 /**
  * Resolve a model string (shortname or full Codex model id) into the literal
  * id we hand to the Codex SDK. Behavior:
  *   - empty/undefined → `CODEX_DEFAULT_MODEL`
- *   - claude shortname (opus/sonnet/haiku) → mapped Codex id
+ *   - claude shortname (opus/sonnet/haiku/fable) → codex tier default
  *   - anything else → passthrough (lowercased), so new OpenAI models work
  *     without a code change. The SDK is the source of truth for validity.
  */
 export function resolveCodexModel(modelStr: string | undefined): string {
   if (!modelStr) return CODEX_DEFAULT_MODEL;
   const normalized = modelStr.toLowerCase();
-  return CLAUDE_SHORTNAMES[normalized] ?? normalized;
-}
-
-interface ModelsDevOpenAiModel {
-  limit?: {
-    context?: number;
-  };
-  cost?: {
-    input?: number;
-    cache_read?: number;
-    output?: number;
-  };
+  const tier = CLAUDE_SHORTNAME_TIER[normalized as keyof typeof CLAUDE_SHORTNAME_TIER];
+  return tier ? DEFAULT_MODEL_TIER_MAP.codex[tier] : normalized;
 }
 
-const MODELSDEV_OPENAI_MODELS =
-  (
-    modelsDevCache as {
-      openai?: {
-        models?: Record<string, ModelsDevOpenAiModel>;
-      };
-    }
-  ).openai?.models ?? {};
-
-const FALLBACK_CODEX_MODEL_CONTEXT_WINDOWS: Record<CodexModel, number> = {
-  "gpt-6-astra": 1_050_000,
-  "gpt-6-sol": 1_050_000,
-  "gpt-6-luna": 1_050_000,
-  "gpt-5.6-sol": 1_050_000,
-  "gpt-5.6-terra": 1_050_000,
-  "gpt-5.6-luna": 1_050_000,
-  "gpt-5.5": 1_050_000,
-  "gpt-5.4": 1_050_000,
-  "gpt-5.4-mini": 400_000,
-  "gpt-5.3-codex": 400_000,
-  "gpt-5.2-codex": 200_000,
-};
-
-/**
- * Per-model approximate context window (tokens). The Codex SDK does not
- * expose these at runtime, so we read the vendored models.dev cache used by
- * the pricing seeder and fall back only for legacy/incomplete cache entries.
- * The values are used by the `context_usage` percent calculation inside
- * `CodexSession`.
- */
-export const CODEX_MODEL_CONTEXT_WINDOWS: Record<CodexModel, number> = Object.fromEntries(
-  CODEX_MODELS.map((model) => [
-    model,
-    MODELSDEV_OPENAI_MODELS[model]?.limit?.context ?? FALLBACK_CODEX_MODEL_CONTEXT_WINDOWS[model],
-  ]),
-) as Record<CodexModel, number>;
+const UNKNOWN_CONTEXT_WINDOW = 200_000;
 
 /**
- * Return the context window in tokens for a given Codex model. Unknown models
- * (passthrough strings) get the 200k default — keeps `context_usage` finite
- * even on a model id we haven't catalogued yet.
+ * Context window in tokens for a Codex model, from the catalog. Unknown
+ * models (passthrough strings) get 200k — keeps `context_usage` finite.
  */
 export function getCodexContextWindow(model: string): number {
-  return CODEX_MODEL_CONTEXT_WINDOWS[model as CodexModel] ?? 200_000;
+  const context = runtimeCatalogModel("openai", model)?.limit?.context;
+  return typeof context === "number" && context > 0 ? context : UNKNOWN_CONTEXT_WINDOW;
 }
 
-/**
- * Per-model pricing in USD per million tokens, sourced from the vendored
- * models.dev cache (`src/be/modelsdev-cache.json`). The fallback below mirrors
- * that snapshot for known models and covers legacy models that models.dev no
- * longer lists.
- *
- * The Codex SDK does NOT report dollar cost in `Usage`, so this map is what
- * powers `totalCostUsd` on the `result` event. Refresh models.dev whenever
- * OpenAI changes pricing or adds new models.
- *
- * `gpt-5.2-codex` is not on the current pricing page (legacy / retired); it
- * inherits the `gpt-5.3-codex` rate as a best-effort fallback so old tasks
- * pinned to it still report a non-zero cost instead of silently $0.
- */
 export interface CodexModelPricing {
   /** USD per million input tokens (uncached). */
   inputPerMillion: number;
@@ -144,99 +78,33 @@ export interface CodexModelPricing {
 }
 
 /**
- * Advisory only: the canonical price is the API server's recompute against
- * the runtime-refreshed pricing table. `agentswarm.cost.drift.usd` is the
- * watchdog for divergence between this worker-local fallback and that table.
- * Exported so tests can pin the fallback values directly — through
- * `computeCodexCostUsd` the models.dev snapshot always wins, leaving this
- * table unreachable when both agree.
+ * Per-model pricing from the catalog (USD per million tokens). Advisory only:
+ * the canonical price is the API server's recompute against the pricing
+ * table (`agentswarm.cost.drift.usd` watches the divergence). A catalog row
+ * without a cache-read price bills cached input at 10% of input, OpenAI's
+ * standard discount.
  */
-export const FALLBACK_CODEX_MODEL_PRICING: Record<CodexModel, CodexModelPricing> = {
-  "gpt-6-astra": {
-    inputPerMillion: 10.0,
-    cachedInputPerMillion: 1.0,
-    outputPerMillion: 50.0,
-  },
-  "gpt-6-sol": {
-    inputPerMillion: 2.0,
-    cachedInputPerMillion: 0.2,
-    outputPerMillion: 10.0,
-  },
-  "gpt-6-luna": {
-    inputPerMillion: 0.1,
-    cachedInputPerMillion: 0.01,
-    outputPerMillion: 0.5,
-  },
-  "gpt-5.6-sol": {
-    inputPerMillion: 4.0,
-    cachedInputPerMillion: 0.4,
-    outputPerMillion: 20.0,
-  },
-  "gpt-5.6-terra": {
-    inputPerMillion: 2.0,
-    cachedInputPerMillion: 0.2,
-    outputPerMillion: 12.0,
-  },
-  "gpt-5.6-luna": {
-    inputPerMillion: 0.2,
-    cachedInputPerMillion: 0.02,
-    outputPerMillion: 1.2,
-  },
-  "gpt-5.5": {
-    inputPerMillion: 5.0,
-    cachedInputPerMillion: 0.5,
-    outputPerMillion: 30.0,
-  },
-  "gpt-5.4": {
-    inputPerMillion: 2.5,
-    cachedInputPerMillion: 0.25,
-    outputPerMillion: 15.0,
-  },
-  "gpt-5.4-mini": {
-    inputPerMillion: 0.75,
-    cachedInputPerMillion: 0.075,
-    outputPerMillion: 4.5,
-  },
-  "gpt-5.3-codex": {
-    inputPerMillion: 1.75,
-    cachedInputPerMillion: 0.175,
-    outputPerMillion: 14.0,
-  },
-  // Legacy — not on the current pricing page; inherit from gpt-5.3-codex.
-  "gpt-5.2-codex": {
-    inputPerMillion: 1.75,
-    cachedInputPerMillion: 0.175,
-    outputPerMillion: 14.0,
-  },
-};
-
-function getModelsDevCodexPricing(model: CodexModel): CodexModelPricing | undefined {
-  const cost = MODELSDEV_OPENAI_MODELS[model]?.cost;
-  if (
-    typeof cost?.input !== "number" ||
-    typeof cost.cache_read !== "number" ||
-    typeof cost.output !== "number"
-  ) {
-    return undefined;
-  }
+export function getCodexModelPricing(model: string): CodexModelPricing | undefined {
+  const cost = runtimeCatalogModel("openai", model)?.cost;
+  if (typeof cost?.input !== "number" || typeof cost.output !== "number") return undefined;
   return {
     inputPerMillion: cost.input,
-    cachedInputPerMillion: cost.cache_read,
+    cachedInputPerMillion: typeof cost.cache_read === "number" ? cost.cache_read : cost.input / 10,
     outputPerMillion: cost.output,
   };
 }
 
-export const CODEX_MODEL_PRICING: Record<CodexModel, CodexModelPricing> = Object.fromEntries(
-  CODEX_MODELS.map((model) => [
-    model,
-    getModelsDevCodexPricing(model) ?? FALLBACK_CODEX_MODEL_PRICING[model],
-  ]),
-) as Record<CodexModel, CodexModelPricing>;
+/** Priced Codex models, keyed by id (every `listCodexModels()` entry the catalog prices). */
+export function codexModelPricingTable(): Record<string, CodexModelPricing> {
+  const table: Record<string, CodexModelPricing> = {};
+  for (const model of listCodexModels()) {
+    const pricing = getCodexModelPricing(model);
+    if (pricing) table[model] = pricing;
+  }
+  return table;
+}
 
-/**
- * Phase 6 — one-warning-per-process tracking so unknown models log once
- * instead of spamming the worker log on every turn.
- */
+/** One warning per model per process, so unpriced models don't spam the log. */
 const _warnedUnknownCodexModels = new Set<string>();
 
 /**
@@ -245,10 +113,9 @@ const _warnedUnknownCodexModels = new Set<string>();
  * + uncached), so we subtract `cached_input_tokens` before billing the
  * 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.
+ * Returns 0 for models the catalog does not price AND logs a one-time
+ * warning. The server-side recompute tags such rows `costSource='unpriced'`,
+ * which surfaces as a yellow UI badge.
  */
 export function computeCodexCostUsd(
   model: string,
@@ -256,13 +123,13 @@ export function computeCodexCostUsd(
   cachedInputTokens: number,
   outputTokens: number,
 ): number {
-  const pricing = CODEX_MODEL_PRICING[model as CodexModel];
+  const pricing = getCodexModelPricing(model);
   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.",
+          "add it to the model catalog (refresh or overlay row). Server-side recompute will tag costSource='unpriced' if the pricing table has no rows.",
       );
     }
     return 0;

package/src/providers/devin-adapter.ts

@@ -836,6 +836,7 @@ export class DevinAdapter implements ProviderAdapter {
     // enumerate the installed skills.
     return {
       hasMcp,
+      hasToolSearch: false,
       nativeSkillDiscovery: false,
       hasLocalEnvironment: false,
       steerModes: ["queue"],

package/src/providers/dsh-adapter.ts

@@ -21,7 +21,7 @@ import type {
 } from "./types";
 
 // npm's `latest` is older and lacks the JSON/stdin contract used here.
-export const DSH_PACKAGE = "@deepseek-ai/dsh@0.1.7-alpha.2";
+export const DSH_PACKAGE = "@deepseek-ai/dsh@0.2.0-rc.2";
 
 export function checkDshCredentials(env: Record<string, string | undefined>): CredStatus {
   return env.DEEPSEEK_API_KEY?.trim() || env.OPENROUTER_API_KEY?.trim()
@@ -163,6 +163,7 @@ export class DshAdapter implements ProviderAdapter {
   readonly name = "dsh";
   readonly traits: ProviderTraits = {
     hasMcp: false,
+    hasToolSearch: false,
     nativeSkillDiscovery: false,
     hasLocalEnvironment: true,
     steerModes: [],

package/src/providers/harness-version.ts

@@ -1,10 +1,14 @@
 import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { delimiter, dirname, join } from "node:path";
 
-type PackageJson = { version?: unknown };
+type PackageJson = { name?: unknown; version?: unknown };
 
 type ReadPkgVersionOptions = {
   requirePackageJson?: (specifier: string) => PackageJson;
   spawn?: typeof spawnSync;
+  /** Version of the package that owns `command` on PATH, or undefined. No process is spawned. */
+  readInstalledVersion?: (command: string, packageName: string) => string | undefined;
 };
 
 const cliVersionCommands: Record<string, { command: string; args: string[] }> = {
@@ -12,6 +16,9 @@ const cliVersionCommands: Record<string, { command: string; args: string[] }> =
   "@opencode-ai/sdk": { command: "opencode", args: ["--version"] },
 };
 
+// The CLI does not change under a running process, so spawn it at most once.
+const spawnedCliVersions = new Map<string, string | undefined>();
+
 function normalizeVersion(value: unknown): string | undefined {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
 }
@@ -20,19 +27,87 @@ function parseCliVersion(output: string): string | undefined {
   return output.match(/\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?/)?.[0];
 }
 
-function readCliVersion(packageName: string, spawn: typeof spawnSync): string | undefined {
-  const command = cliVersionCommands[packageName];
-  if (!command) return undefined;
+function findOnPath(command: string): string | undefined {
+  for (const dir of (process.env.PATH ?? "").split(delimiter)) {
+    if (!dir) continue;
+    const candidate = join(dir, command);
+    if (existsSync(candidate)) return candidate;
+  }
+  return undefined;
+}
+
+/**
+ * Reads the version of the npm package a CLI shim belongs to by walking up from the shim's real
+ * path to the package.json that names `packageName`. `pi --version` prints exactly that file's
+ * `version`, so this gives the same answer without starting a process.
+ */
+export function readInstalledCliPackageVersion(
+  command: string,
+  packageName: string,
+): string | undefined {
+  const binPath = findOnPath(command);
+  if (!binPath) return undefined;
+
+  let dir: string;
+  try {
+    dir = dirname(realpathSync(binPath));
+  } catch {
+    return undefined;
+  }
+
+  for (;;) {
+    try {
+      const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8")) as PackageJson;
+      if (pkg.name === packageName) return normalizeVersion(pkg.version);
+    } catch {
+      // No package.json at this level, or not valid JSON: keep walking up.
+    }
+    const parent = dirname(dir);
+    if (parent === dir) return undefined;
+    dir = parent;
+  }
+}
 
+function spawnCliVersion(
+  packageName: string,
+  command: { command: string; args: string[] },
+  spawn: typeof spawnSync,
+): string | undefined {
+  // Only the real spawnSync is cached; an injected one (tests) must run every call.
+  const cacheable = spawn === spawnSync;
+  if (cacheable && spawnedCliVersions.has(packageName)) return spawnedCliVersions.get(packageName);
+
+  let version: string | undefined;
   try {
     const result = spawn(command.command, command.args, {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"],
+      timeout: 5_000,
+      killSignal: "SIGKILL",
     });
-    return parseCliVersion(`${result.stdout ?? ""}\n${result.stderr ?? ""}`);
+    version = parseCliVersion(`${result.stdout ?? ""}\n${result.stderr ?? ""}`);
   } catch {
-    return undefined;
+    version = undefined;
   }
+  if (cacheable) spawnedCliVersions.set(packageName, version);
+  return version;
+}
+
+function readCliVersion(
+  packageName: string,
+  spawn: typeof spawnSync,
+  readInstalledVersion: NonNullable<ReadPkgVersionOptions["readInstalledVersion"]>,
+): string | undefined {
+  const command = cliVersionCommands[packageName];
+  if (!command) return undefined;
+
+  // Prefer reading the installed package: a synchronous spawn blocks this thread for the whole
+  // child run, and on Bun 1.4.0 a `pi --version` spawnSync intermittently never returns (the child
+  // exits and stays a zombie while the parent spins), which wedged CI test workers for 20 minutes.
+  const installed = readInstalledVersion(command.command, packageName);
+  if (installed) return installed;
+
+  return spawnCliVersion(packageName, command, spawn);
 }
 
 export function readPkgVersion(
@@ -40,9 +115,10 @@ export function readPkgVersion(
   {
     requirePackageJson = (specifier) => require(specifier) as PackageJson,
     spawn = spawnSync,
+    readInstalledVersion = readInstalledCliPackageVersion,
   }: ReadPkgVersionOptions = {},
 ): string | undefined {
-  const cliVersion = readCliVersion(packageName, spawn);
+  const cliVersion = readCliVersion(packageName, spawn, readInstalledVersion);
   if (cliVersion) return cliVersion;
 
   try {

package/src/providers/opencode-adapter.ts

@@ -10,7 +10,7 @@
 
 import { existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
-import type { AssistantMessage, Config, Event as OpencodeEvent } from "@opencode-ai/sdk";
+import type { AssistantMessage, Config, Event as OpencodeEvent, TextPart } from "@opencode-ai/sdk";
 import { createOpencode } from "@opencode-ai/sdk";
 import {
   CONTEXT_FORMULA,
@@ -301,6 +301,13 @@ export class OpencodeSession implements ProviderSession {
   // Keep the latest snapshot per message so those replays do not double-count.
   private finalizedMessages = new Map<string, FinalizedMessageUsage>();
   private missingMessageIdCounter = 0;
+  // Assistant text for the runner's final-message capture (`trackAssistantText`),
+  // which is how codex tasks with an outputSchema get their final message
+  // validated. Text parts stream in around the message's own updates, so buffer
+  // the latest snapshot per part and emit per message once its role is known.
+  private textParts = new Map<string, Map<string, string>>();
+  private assistantMessageIds = new Set<string>();
+  private emittedText = new Map<string, string>();
   private startedAt = Date.now();
   private model: string;
   private agentId: string;
@@ -462,6 +469,7 @@ export class OpencodeSession implements ProviderSession {
       case "message.updated": {
         const msg = ev.properties.info;
         if (!isAssistantMessage(msg) || msg.sessionID !== this._sessionId) break;
+        if (typeof msg.id === "string") this.assistantMessageIds.add(msg.id);
         // 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
@@ -487,6 +495,7 @@ export class OpencodeSession implements ProviderSession {
           cacheReadTokens: msg.tokens?.cache?.read ?? 0,
           cacheWriteTokens: msg.tokens?.cache?.write ?? 0,
         });
+        this.emitAssistantText(msg.id);
         if (!this.model && msg.modelID) this.model = msg.modelID;
 
         // Emit context_usage so the runner can POST /api/tasks/:id/context
@@ -521,6 +530,12 @@ export class OpencodeSession implements ProviderSession {
       }
 
       case "message.part.updated": {
+        // Text parts are matched to this session by their own `sessionID`
+        // (checked in `recordTextPart`), not by the tool branch's check below.
+        if (ev.properties.part?.type === "text") {
+          this.recordTextPart(ev.properties.part);
+          break;
+        }
         // Bridge opencode's part.state lifecycle to swarm's tool_start/tool_end
         // so the dashboard's Activity timeline mirrors what other providers
         // emit. We fire tool_start the first time we see a tool part (any
@@ -612,6 +627,36 @@ export class OpencodeSession implements ProviderSession {
     }
   }
 
+  /** Keep the latest snapshot of a text part (`part.text` is cumulative). */
+  private recordTextPart(part: TextPart): void {
+    // Synthetic and ignored parts are opencode-injected context, not model output.
+    if (part.sessionID !== this._sessionId || part.synthetic || part.ignored) return;
+    if (typeof part.messageID !== "string" || typeof part.id !== "string") return;
+    let parts = this.textParts.get(part.messageID);
+    if (!parts) {
+      parts = new Map();
+      this.textParts.set(part.messageID, parts);
+    }
+    parts.set(part.id, part.text ?? "");
+    // A part can land after its message was finalized; re-emit the fuller text.
+    if (this.finalizedMessages.has(part.messageID)) this.emitAssistantText(part.messageID);
+  }
+
+  /**
+   * Emit an assistant message's text as a normal `message` event. Only assistant
+   * messages qualify, and unchanged text is not re-emitted (opencode replays
+   * finalized snapshots). The runner keeps the last non-empty one.
+   */
+  private emitAssistantText(messageId: string): void {
+    if (!this.assistantMessageIds.has(messageId)) return;
+    const parts = this.textParts.get(messageId);
+    if (!parts) return;
+    const text = [...parts.values()].join("").trim();
+    if (!text || this.emittedText.get(messageId) === text) return;
+    this.emittedText.set(messageId, text);
+    this.emit({ type: "message", role: "assistant", content: text, messageId });
+  }
+
   private emitError(message: string): void {
     const errorEvent: ProviderEvent = { type: "error", message };
     for (const l of this.listeners) l(errorEvent);
@@ -719,6 +764,7 @@ export class OpencodeAdapter implements ProviderAdapter {
 
   readonly traits: ProviderTraits = {
     hasMcp: true,
+    hasToolSearch: false,
     // Same inline-resolver pattern as codex (`resolveSlashSkillPrompt`) — no
     // ambient skill awareness, so the system prompt enumerates them.
     nativeSkillDiscovery: false,
@@ -760,6 +806,12 @@ export class OpencodeAdapter implements ProviderAdapter {
         headers: {
           Authorization: `Bearer ${config.apiKey}`,
           "X-Agent-ID": config.agentId,
+          // Per-task identity, same as claude/codex. Without it `store-progress`
+          // has no default task, so the model must hand-type a UUID and can
+          // copy a sibling's or parent's id from the prompt. The config file
+          // and `opencode serve` are already per task, so this is not shared.
+          "X-Source-Task-Id": taskId,
+          ...(config.contextKey ? { "X-Context-Key": config.contextKey } : {}),
           ...(runtimeInstanceId ? { "X-Runtime-Instance-ID": runtimeInstanceId } : {}),
         },
       },

package/src/providers/pi-binary-root/src/extensions/codemode/worker.ts

@@ -0,0 +1,11 @@
+/**
+ * Codemode sandbox worker for the compiled agent-swarm binary.
+ *
+ * In a Bun binary, pi's `getCodemodeWorkerUrl()` loads the worker from
+ * `./src/extensions/codemode/worker.js` next to the executable. The build
+ * passes this file as an extra entrypoint with
+ * `--root ./src/providers/pi-binary-root`, which embeds it at that path.
+ * Keep the Dockerfile.worker compile line and both package.json
+ * build:binary scripts in sync.
+ */
+import "@earendil-works/pi-codemode/worker";

package/src/providers/pi-codemode-runtime.ts

@@ -0,0 +1,17 @@
+/**
+ * Point pi's codemode at the QuickJS wasm that `bun build --compile` embeds.
+ *
+ * pi resolves the wasm with `createRequire(import.meta.url).resolve(...)`
+ * unless an embedded path was set, and that resolve fails inside a compiled
+ * binary's `$bunfs`. pi's own Bun binary sets the path in its entry
+ * (dist/bun/runtime-setup.js); our binary has a different entry, so this
+ * module does the same. Outside a binary, the import is the file on disk.
+ *
+ * `setEmbeddedQuickJSWasmPath` is not in the package `exports` map, so the
+ * import goes through the file path. It is the same module instance pi's
+ * codemode reads, and tsc fails if pi moves or drops it.
+ */
+import quickjsWasmPath from "quickjs-wasi/quickjs.wasm" with { type: "file" };
+import { setEmbeddedQuickJSWasmPath } from "../../node_modules/@earendil-works/pi-coding-agent/dist/config.js";
+
+setEmbeddedQuickJSWasmPath(quickjsWasmPath);