@desplega.ai/agent-swarm 1.171.0 → 1.172.0

package/src/providers/opencode-adapter.ts

@@ -1,17 +1,15 @@
 /**
- * Opencode provider adapter.
+ * Opencode provider adapter (OpenCode 2).
  *
- * Sub-4 added the OpencodeAdapter skeleton; sub-5 added the full session
- * lifecycle (SSE events, cost accumulation, raw_log persistence); sub-6 (DES-300)
- * adds per-task isolation: agent file, OPENCODE_CONFIG, OPENCODE_DATA_HOME.
- * Sub-7 (DES-301) wires the agent-swarm opencode plugin for cancellation,
- * heartbeat, identity sync, system.transform, compacting, and idle hooks.
+ * OpenCode 2 runs in-process through `@opencode/sdk`: one embedded host per
+ * task, no `opencode serve` child, no port, no config or data-home files.
+ * Config travels as a string, the database is in memory, and the swarm plugin
+ * is a plain object (`opencode-swarm-plugin.ts`) passed to `OpenCode.create`.
  */
 
-import { existsSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
-import type { AssistantMessage, Config, Event as OpencodeEvent, TextPart } from "@opencode-ai/sdk";
-import { createOpencode } from "@opencode-ai/sdk";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import type { OpenCode, OpenCodeEvent } from "@opencode/sdk";
 import {
   CONTEXT_FORMULA,
   clampContextPercent,
@@ -29,7 +27,15 @@ import {
 import { scrubSecrets } from "../utils/secret-scrubber";
 import { resolveSlashSkillPrompt } from "./codex-skill-resolver";
 import { CTX_MODE_NUDGE_EVERY } from "./ctx-mode-env";
-import { readPkgVersion } from "./harness-version";
+import { createOpencodeSwarmPlugin, type OpencodeToolLister } from "./opencode-swarm-plugin";
+import {
+  apiHeaders,
+  autoIndexMemoryFile,
+  fireAndForget,
+  type SwarmHooksConfig,
+  summarizeTranscript,
+  syncIdentityFilesToServer,
+} from "./pi-mono-extension";
 import { applyReasoningEffort, type ReasoningEffort } from "./reasoning-effort";
 import type {
   CostData,
@@ -45,6 +51,22 @@ import type {
   SteerDeliveryResult,
 } from "./types";
 
+/**
+ * The subset of OpenCode's V1-shaped config we write. OpenCode 2 still reads
+ * V1 config (`opencode.json`, `OPENCODE_CONFIG_CONTENT`) and normalizes it in
+ * memory, so the ACP target and this adapter share one shape.
+ */
+export type OpencodeConfig = {
+  provider?: Record<
+    string,
+    {
+      options?: Record<string, unknown>;
+      models?: Record<string, { options?: Record<string, unknown> }>;
+    }
+  >;
+  [key: string]: unknown;
+};
+
 /**
  * Map opencode model strings to the env var that satisfies them. Opencode
  * uses the same `provider/model-id` shape as pi-mono — the prefix tells us
@@ -64,7 +86,7 @@ function opencodeModelToCredKey(modelStr: string | undefined): string | null {
 /**
  * Opencode is satisfied by ANY of:
  *   1. `~/.local/share/opencode/auth.json` exists (the file `opencode auth login`
- *      writes).
+ *      writes; OpenCode 2 imports it into its credential store on start).
  *   2. `MODEL_OVERRIDE` resolves to a provider-prefixed model — only that
  *      provider's key is required.
  *   3. Otherwise any one of OPENROUTER_API_KEY / ANTHROPIC_API_KEY /
@@ -103,79 +125,58 @@ export function checkOpencodeCredentials(
   };
 }
 
-function isAssistantMessage(msg: unknown): msg is AssistantMessage {
-  return (
-    typeof msg === "object" &&
-    msg !== null &&
-    (msg as AssistantMessage).role === "assistant" &&
-    typeof (msg as AssistantMessage).cost === "number"
-  );
-}
-
-type FinalizedMessageUsage = {
-  cost: number;
-  inputTokens: number;
-  outputTokens: number;
-  reasoningOutputTokens: number;
-  cacheReadTokens: number;
-  cacheWriteTokens: number;
-};
-
-const DOCKER_PLUGIN_PATH = "/home/worker/.config/opencode/plugins/agent-swarm.ts";
-
 function defaultOpencodeSkillsDir(): string {
   if (process.env.OPENCODE_SKILLS_DIR) {
     return process.env.OPENCODE_SKILLS_DIR;
   }
   return join(process.env.HOME ?? "/home/worker", ".opencode", "skills");
 }
-const MODEL_CACHE_REFRESH_TIMEOUT_MS = 15_000;
-// opencode cold-start on E2B disk regularly exceeds the SDK's 5s default
-// server-start timeout (@opencode-ai/sdk dist/server.js), failing the spawn with
-// "Timeout waiting for server to start after 5000ms". Override via
-// OPENCODE_SERVER_TIMEOUT_MS.
-const DEFAULT_SERVER_START_TIMEOUT_MS = 30_000;
-// Event-stream reconnects before the session gives up on a dead local server.
-// The SDK backs off 3s, 6s, 12s, 24s between attempts, so ~45s in total.
-export const OPENCODE_SSE_MAX_RETRY_ATTEMPTS = 5;
-
-function serverStartTimeoutMs(): number {
-  return Number(process.env.OPENCODE_SERVER_TIMEOUT_MS) || DEFAULT_SERVER_START_TIMEOUT_MS;
-}
 
-/** Reject with `message` if `promise` has not settled within `ms`. */
-async function withTimeout<T>(promise: Promise<T>, ms: number, message: string): Promise<T> {
-  let timer: ReturnType<typeof setTimeout> | undefined;
-  const timeout = new Promise<never>((_, reject) => {
-    timer = setTimeout(() => {
-      // The abandoned promise may still settle later; keep it from surfacing
-      // as an unhandled rejection.
-      promise.catch(() => {});
-      reject(new Error(message));
-    }, ms);
-  });
-  try {
-    return await Promise.race([promise, timeout]);
-  } finally {
-    clearTimeout(timer);
+// The worker image installs `@opencode/sdk` with `npm install -g`. It stays on
+// disk instead of being bundled into the compiled binary because it carries
+// native modules (pty, file watcher, tree-sitter).
+const OPENCODE_SDK_GLOBAL_ROOTS = ["/usr/lib/node_modules", "/usr/local/lib/node_modules"];
+const OPENCODE_SDK_SUBPATH = "@opencode/sdk/dist/index.js";
+
+/**
+ * `OPENCODE_SDK_PATH` wins, then the global npm roots, then the bare package
+ * name (resolved from the repo's node_modules when running from source).
+ */
+export function resolveOpencodeSdkSpecifier(): string {
+  const override = process.env.OPENCODE_SDK_PATH;
+  if (override) return override;
+  for (const root of OPENCODE_SDK_GLOBAL_ROOTS) {
+    const candidate = join(root, OPENCODE_SDK_SUBPATH);
+    if (existsSync(candidate)) return candidate;
   }
+  return "@opencode/sdk";
 }
 
-function isOpenRouterModel(model: string | undefined): boolean {
-  return Boolean(model?.toLowerCase().startsWith("openrouter/"));
-}
+type OpencodeSdk = typeof import("@opencode/sdk");
+type LoadedOpencodeSdk = { sdk: OpencodeSdk; version?: string };
 
-function isModelNotFoundError(message: string): boolean {
-  return /model not found:/i.test(message);
+/** The embedded host reports no version of its own; read the SDK's package.json. */
+function readOpencodeSdkVersion(entry: string): string | undefined {
+  try {
+    const pkg = JSON.parse(readFileSync(join(dirname(entry), "..", "package.json"), "utf8"));
+    return typeof pkg.version === "string" ? pkg.version : undefined;
+  } catch {
+    return undefined;
+  }
 }
 
-async function readSpawnOutput(stream: ReadableStream<Uint8Array> | null): Promise<string> {
-  if (!stream) return "";
-  return await new Response(stream).text();
+// A variable specifier keeps `bun build --compile` from bundling the SDK.
+async function loadOpencodeSdk(): Promise<LoadedOpencodeSdk> {
+  const specifier = resolveOpencodeSdkSpecifier();
+  const sdk = (await import(specifier)) as OpencodeSdk;
+  const entry = specifier.startsWith("/") ? specifier : Bun.resolveSync(specifier, import.meta.dir);
+  return { sdk, version: readOpencodeSdkVersion(entry) };
 }
 
-function formatUnknownError(err: unknown): string {
-  return err instanceof Error ? err.message : String(err);
+let loadOpencodeSdkImpl = loadOpencodeSdk;
+
+export function _setOpencodeSdkLoaderForTests(fn: (() => Promise<LoadedOpencodeSdk>) | null): void {
+  loadOpencodeSdkImpl = fn ?? loadOpencodeSdk;
 }
 
 /**
@@ -185,7 +186,7 @@ function formatUnknownError(err: unknown): string {
  * place, and attribute direct OpenRouter requests to Agent Swarm.
  */
 export function applyOpenRouterBaseUrlOverride(
-  opencodeConfig: Config,
+  opencodeConfig: OpencodeConfig,
   env: Record<string, string | undefined> = process.env,
 ): void {
   const openRouterBaseUrl = getOpenRouterBaseUrl(env as NodeJS.ProcessEnv);
@@ -215,164 +216,132 @@ export function applyOpenRouterBaseUrlOverride(
   };
 }
 
-async function refreshOpenRouterModelCache(
-  opencodeConfig: Config & { plugin?: string[] },
-  configFilePath: string,
-  dataHomePath: string,
-): Promise<void> {
-  const binary = process.env.OPENCODE_BINARY || "opencode";
-  const proc = Bun.spawn([binary, "models", "--refresh", "openrouter"], {
-    stdout: "pipe",
-    stderr: "pipe",
-    env: {
-      ...process.env,
-      OPENCODE_CONFIG: configFilePath,
-      OPENCODE_CONFIG_CONTENT: JSON.stringify(opencodeConfig),
-      OPENCODE_DATA_HOME: dataHomePath,
-    },
-  });
-
-  let timedOut = false;
-  const timeout = setTimeout(() => {
-    timedOut = true;
-    proc.kill();
-  }, MODEL_CACHE_REFRESH_TIMEOUT_MS);
-
-  const [stdout, stderr, exitCode] = await Promise.all([
-    readSpawnOutput(proc.stdout),
-    readSpawnOutput(proc.stderr),
-    proc.exited,
-  ]).finally(() => clearTimeout(timeout));
-
-  if (timedOut) {
-    throw new Error(
-      `opencode models --refresh openrouter timed out after ${MODEL_CACHE_REFRESH_TIMEOUT_MS}ms`,
-    );
-  }
-  if (exitCode !== 0) {
-    const detail = scrubSecrets([stderr.trim(), stdout.trim()].filter(Boolean).join("\n"));
-    throw new Error(
-      `opencode models --refresh openrouter exited with code ${exitCode}${detail ? `: ${detail}` : ""}`,
-    );
-  }
-}
-
-let refreshOpenRouterModelCacheImpl = refreshOpenRouterModelCache;
+const SWARM_AGENT_NAME = "swarm";
+const TRANSCRIPT_TAIL_CHARS = 20_000;
+const TOOL_RESULT_PREVIEW_CHARS = 500;
+
+/** The swarm MCP server's name in the OpenCode config. */
+const SWARM_MCP_SERVER = "swarm";
+/** Swarm tools a session cannot report without. OpenCode keys them `swarm_<tool>`. */
+const REQUIRED_SWARM_TOOLS = ["store-progress"];
+const ADMISSION_POLL_MS = 250;
+
+type SessionEndHooks = {
+  /** Cap on session-end network work; host close and completion never wait longer. */
+  budgetMs: number;
+  /** Cap on swarm MCP connect plus tool discovery before the first prompt. */
+  admissionTimeoutMs: number;
+  syncIdentity: typeof syncIdentityFilesToServer;
+};
+const DEFAULT_SESSION_HOOKS: SessionEndHooks = {
+  budgetMs: 10_000,
+  admissionTimeoutMs: 30_000,
+  syncIdentity: syncIdentityFilesToServer,
+};
+let sessionHooks = DEFAULT_SESSION_HOOKS;
 
-export function _setOpenRouterModelCacheRefreshForTests(
-  fn: typeof refreshOpenRouterModelCache | null,
-): void {
-  refreshOpenRouterModelCacheImpl = fn ?? refreshOpenRouterModelCache;
+export function _setOpencodeSessionHooksForTests(hooks: Partial<SessionEndHooks> | null): void {
+  sessionHooks = hooks ? { ...DEFAULT_SESSION_HOOKS, ...hooks } : DEFAULT_SESSION_HOOKS;
 }
 
-function resolvePluginPath(): string {
-  const override = process.env.OPENCODE_SWARM_PLUGIN_PATH;
-  if (override) return override;
-  if (existsSync(DOCKER_PLUGIN_PATH)) return DOCKER_PLUGIN_PATH;
-  return join(import.meta.dir, "../../plugin/opencode-plugins/agent-swarm.ts");
+/** Resolve after `promise` settles or `ms` elapses, whichever is first. Never rejects. */
+async function settleWithin(promise: Promise<unknown>, ms: number, signal?: AbortSignal) {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const cut = new Promise<void>((resolve) => {
+    timer = setTimeout(resolve, ms);
+    signal?.addEventListener("abort", () => resolve(), { once: true });
+  });
+  try {
+    await Promise.race([promise.catch(() => {}), cut]);
+  } finally {
+    clearTimeout(timer);
+  }
 }
 
-// context-mode is installed globally via `npm install -g` (Dockerfile.worker),
-// which places it under the npm global modules dir. opencode resolves bare
-// plugin names with `import(await Bun.resolve(name, ...))`, which does NOT walk
-// the npm global dir — a bare "context-mode" entry only resolves if Bun
-// auto-installs from the registry at runtime, which fails on network-sandboxed
-// workers. So we hand opencode the ABSOLUTE path to the package's built
-// opencode-plugin entry, which imports cleanly with no network.
-const CONTEXT_MODE_GLOBAL_ROOTS = ["/usr/lib/node_modules", "/usr/local/lib/node_modules"];
-const CONTEXT_MODE_PLUGIN_SUBPATH = "context-mode/build/adapters/opencode/plugin.js";
-
 /**
- * Resolve the absolute path to context-mode's opencode plugin entry, or `null`
- * if it can't be found on disk. `CONTEXT_MODE_OPENCODE_PLUGIN_PATH` overrides
- * the lookup (and must itself exist). Returning `null` lets the caller skip the
- * plugin gracefully instead of handing opencode an unresolvable entry.
+ * Wait until the swarm MCP server is connected and its required tools are
+ * registered. OpenCode turns a refused or unauthorized server into a status
+ * and keeps going, so without this check a session would run without
+ * `store-progress`. Returns null when admitted, else the reason.
  */
-export function resolveContextModePluginPath(): string | null {
-  const override = process.env.CONTEXT_MODE_OPENCODE_PLUGIN_PATH;
-  if (override) return existsSync(override) ? override : null;
-  for (const root of CONTEXT_MODE_GLOBAL_ROOTS) {
-    const candidate = join(root, CONTEXT_MODE_PLUGIN_SUBPATH);
-    if (existsSync(candidate)) return candidate;
+export async function checkSwarmMcpAdmission(
+  host: Pick<OpenCode.Interface, "mcp">,
+  directory: string,
+  listTools: () => OpencodeToolLister | undefined,
+  timeoutMs: number,
+  isCancelled: () => boolean = () => false,
+): Promise<string | null> {
+  const deadline = Date.now() + timeoutMs;
+  let last = "swarm MCP server is not registered";
+  while (!isCancelled()) {
+    const servers = await host.mcp.list({ location: { directory } });
+    const status = servers.data.find((server) => server.name === SWARM_MCP_SERVER)?.status;
+    if (status?.status === "failed" || status?.status === "needs_auth") {
+      return `swarm MCP server ${status.status}: ${status.error}`;
+    }
+    if (status?.status === "disabled") return "swarm MCP server is disabled";
+    if (status?.status === "connected") {
+      const lister = listTools();
+      const ids = new Set(lister ? (await lister()).map((tool) => tool.id) : []);
+      const missing = REQUIRED_SWARM_TOOLS.filter((tool) => !ids.has(`swarm_${tool}`));
+      if (missing.length === 0) return null;
+      last = `swarm MCP server connected without required tools: ${missing.join(", ")}`;
+    } else if (status) {
+      last = `swarm MCP server still ${status.status}`;
+    }
+    if (Date.now() >= deadline) return `${last} after ${timeoutMs}ms`;
+    await Bun.sleep(ADMISSION_POLL_MS);
   }
   return null;
 }
 
+function errorMessage(error: unknown, fallback: string): string {
+  if (error && typeof error === "object" && "message" in error) {
+    return String((error as { message?: unknown }).message ?? fallback);
+  }
+  return error === undefined ? fallback : String(error);
+}
+
+function toolResultText(content: ReadonlyArray<{ type: string; text?: string }> | undefined) {
+  return (content ?? [])
+    .map((part) => (part.type === "text" ? (part.text ?? "") : `[${part.type}]`))
+    .join("");
+}
+
 export class OpencodeSession implements ProviderSession {
-  private _sessionId: string;
   private listeners: Array<(event: ProviderEvent) => void> = [];
-  // Buffer for events emitted before any listener is attached.
-  // The runner attaches its listener after `await adapter.createSession(...)`
-  // resolves, but events queued via Promise.resolve().then(...) inside
-  // createSession fire on the next microtask — *before* that listener call —
-  // so the runner would miss session_init and never PUT /session,
-  // leaving agent_tasks.provider/.model NULL. Buffer + flush on first attach.
+  // The runner attaches its listener after `createSession` resolves; buffer
+  // events (session_init first) until then so none are lost.
   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 client: Awaited<ReturnType<typeof createOpencode>>["client"];
-  private server: { url: string; close(): void };
   private aborted = false;
   private completed = false;
-
-  // Opencode can re-emit finalized snapshots for the same assistant message.
-  // 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>();
+  // Cancels session-end network work when the session is aborted mid-finish.
+  private readonly sessionEnd = new AbortController();
   private startedAt = Date.now();
-  private model: string;
-  private agentId: string;
-  private taskId: string;
-
-  // Per-task isolation paths (for cleanup)
-  private agentFilePath: string;
-  private configFilePath: string;
-  private dataHomePath: string;
-  private retryAfterModelRefresh?: () => Promise<boolean>;
-  private modelRefreshRecoveryInFlight = false;
-  /** Reasoning/effort level actually applied (Phase 4) — null when `applyReasoningEffort()` returned noop. */
-  private appliedReasoningEffort: ReasoningEffort | null;
-
-  // Track which tool callIDs have already emitted tool_start, so transitions
-  // through pending → running → completed don't fire duplicate events.
-  private toolStartsEmitted = new Set<string>();
+
+  // `session.usage.updated` carries the cumulative session totals.
+  private usage = {
+    cost: 0,
+    tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+  };
+  private steps = 0;
+  private toolNames = new Map<string, string>();
+  // Assistant text by message, in part order; the runner keeps the last emit.
+  private textByMessage = new Map<string, string[]>();
+  private transcript: string[] = [];
 
   constructor(
-    sessionId: string,
-    client: Awaited<ReturnType<typeof createOpencode>>["client"],
-    server: { url: string; close(): void },
-    model: string,
-    agentId: string,
-    taskId: string,
-    agentFilePath: string,
-    configFilePath: string,
-    dataHomePath: string,
-    retryAfterModelRefresh?: () => Promise<boolean>,
-    appliedReasoningEffort: ReasoningEffort | null = null,
+    private readonly host: OpenCode.Interface,
+    private readonly _sessionId: string,
+    private model: string,
+    private readonly swarm: SwarmHooksConfig,
+    private readonly cwd: string,
+    private readonly appliedReasoningEffort: ReasoningEffort | null = null,
   ) {
-    this._sessionId = sessionId;
-    this.client = client;
-    this.server = server;
-    this.model = model;
-    this.agentId = agentId;
-    this.taskId = taskId;
-    this.agentFilePath = agentFilePath;
-    this.configFilePath = configFilePath;
-    this.dataHomePath = dataHomePath;
-    this.retryAfterModelRefresh = retryAfterModelRefresh;
-    this.appliedReasoningEffort = appliedReasoningEffort;
-    this.completionPromise = new Promise<ProviderResult>((resolve, reject) => {
+    this.completionPromise = new Promise<ProviderResult>((resolve) => {
       this.completionResolve = resolve;
-      this.completionReject = reject;
     });
   }
 
@@ -384,13 +353,11 @@ export class OpencodeSession implements ProviderSession {
     return this.completed;
   }
 
-  /** Emit the synthetic session_init event. Called by the adapter immediately
-   * after construction; buffers if no listener is attached yet. */
-  emitSessionInit(provider: "opencode", harnessVariantMeta?: Record<string, unknown>): void {
+  emitSessionInit(harnessVariantMeta?: Record<string, unknown>): void {
     this.emit({
       type: "session_init",
       sessionId: this._sessionId,
-      provider,
+      provider: "opencode",
       harnessVariant: "stock",
       ...(harnessVariantMeta ? { harnessVariantMeta } : {}),
     });
@@ -400,6 +367,10 @@ export class OpencodeSession implements ProviderSession {
     this.emit(event);
   }
 
+  recordUserPrompt(text: string): void {
+    this.transcript.push(`[user]: ${text}`);
+  }
+
   onEvent(listener: (event: ProviderEvent) => void): void {
     const wasEmpty = this.listeners.length === 0;
     this.listeners.push(listener);
@@ -410,19 +381,6 @@ export class OpencodeSession implements ProviderSession {
     }
   }
 
-  private emit(event: ProviderEvent): void {
-    if (this.listeners.length === 0) {
-      this.pendingEvents.push(event);
-    } else {
-      for (const l of this.listeners) l(event);
-    }
-    // Also emit a raw_log for every event (scrubbed)
-    if (event.type !== "raw_log") {
-      const raw = scrubSecrets(JSON.stringify(event));
-      this.emitDirect({ type: "raw_log", content: raw });
-    }
-  }
-
   private emitDirect(event: ProviderEvent): void {
     if (this.listeners.length === 0) {
       this.pendingEvents.push(event);
@@ -431,294 +389,184 @@ export class OpencodeSession implements ProviderSession {
     for (const l of this.listeners) l(event);
   }
 
-  emitModelCacheRefreshProgress(): void {
-    this.emit({
-      type: "progress",
-      message: "opencode model cache is stale; refreshing OpenRouter models and retrying once",
-    });
+  /** Emit `event` plus its scrubbed `raw_log` mirror. */
+  private emit(event: ProviderEvent): void {
+    this.emitDirect(event);
+    this.emitDirect({ type: "raw_log", content: scrubSecrets(JSON.stringify(event)) });
   }
 
-  emitModelCacheRefreshFailure(message: string, err: unknown): void {
-    this.emitError(`${message}; OpenRouter model cache refresh failed: ${formatUnknownError(err)}`);
-  }
+  /** Process one OpenCode 2 event. */
+  handleOpencodeEvent(ev: OpenCodeEvent): void {
+    if (this.aborted || this.completed) return;
 
-  private recoverFromModelNotFound(message: string): void {
-    if (!this.retryAfterModelRefresh || this.modelRefreshRecoveryInFlight) {
-      this.emitError(message);
+    if (ev.type === "filesystem.changed") {
+      this.onFileChanged(ev.data.file);
       return;
     }
-    this.modelRefreshRecoveryInFlight = true;
-    this.emitModelCacheRefreshProgress();
-    this.retryAfterModelRefresh()
-      .then((retried) => {
-        if (!retried) this.emitError(message);
-      })
-      .catch((err: unknown) => {
-        this.emitModelCacheRefreshFailure(message, err);
-      });
-  }
+    const data = (ev as { data?: { sessionID?: string } }).data;
+    if (data?.sessionID !== this._sessionId) return;
 
-  /** Best-effort cleanup of per-task isolation files and directories. */
-  private async cleanupFiles(): Promise<void> {
-    try {
-      await Bun.$`rm -f ${this.agentFilePath}`.quiet().nothrow();
-    } catch {
-      // best-effort
-    }
-    try {
-      await Bun.$`rm -f ${this.configFilePath}`.quiet().nothrow();
-    } catch {
-      // best-effort
-    }
-    try {
-      await Bun.$`rm -rf ${this.dataHomePath}`.quiet().nothrow();
-    } catch {
-      // best-effort
-    }
-  }
+    this.emitDirect({ type: "raw_log", content: scrubSecrets(JSON.stringify(ev)) });
 
-  /** Process a single opencode SSE event */
-  handleOpencodeEvent(ev: OpencodeEvent): void {
-    if (this.aborted || this.completed) return;
+    switch (ev.type) {
+      case "session.step.started": {
+        // OpenCode 2 runs its default model when the configured one is not in
+        // its catalog, with no error event. Fail instead of billing the task
+        // to a model nobody asked for.
+        const actual = `${ev.data.model.providerID}/${ev.data.model.id}`;
+        if (this.model.includes("/") && actual !== this.model) {
+          this.fail(
+            `opencode ran ${actual} instead of the requested model ${this.model}; the requested model is not in OpenCode's catalog`,
+          );
+        }
+        break;
+      }
 
-    // Always emit the raw event as a scrubbed raw_log
-    const rawContent = scrubSecrets(JSON.stringify(ev));
-    this.emitDirect({ type: "raw_log", content: rawContent });
+      case "session.tool.input.started":
+        this.toolNames.set(ev.data.id, ev.data.name);
+        break;
 
-    switch (ev.type) {
-      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
-        // 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;
-        // Keep the latest finalized snapshot for each assistant message.
-        // A missing/empty id must not collapse distinct messages into one
-        // entry (silent undercount) — degrade to counting them separately,
-        // which matches the pre-dedup over-count-safe behavior.
-        const messageKey =
-          typeof msg.id === "string" && msg.id.length > 0
-            ? msg.id
-            : `missing-id-${this.missingMessageIdCounter++}`;
-        this.finalizedMessages.set(messageKey, {
-          cost: msg.cost,
-          inputTokens: msg.tokens?.input ?? 0,
-          outputTokens: msg.tokens?.output ?? 0,
-          reasoningOutputTokens: msg.tokens?.reasoning ?? 0,
-          cacheReadTokens: msg.tokens?.cache?.read ?? 0,
-          cacheWriteTokens: msg.tokens?.cache?.write ?? 0,
+      case "session.tool.called": {
+        const toolName = this.toolNames.get(ev.data.id) ?? "tool";
+        this.transcript.push(`[tool:${toolName}]: ${JSON.stringify(ev.data.input)}`);
+        this.emit({
+          type: "tool_start",
+          toolCallId: ev.data.id,
+          toolName,
+          args: ev.data.input,
+        });
+        break;
+      }
+
+      case "session.tool.success":
+      case "session.tool.failed": {
+        const isError = ev.type === "session.tool.failed";
+        const result = isError
+          ? errorMessage(ev.data.error, "tool failed")
+          : toolResultText(ev.data.content);
+        this.transcript.push(`[tool result]: ${result.slice(0, TOOL_RESULT_PREVIEW_CHARS)}`);
+        this.emit({
+          type: "tool_end",
+          toolCallId: ev.data.id,
+          toolName: this.toolNames.get(ev.data.id) ?? "tool",
+          result,
+          isError,
         });
-        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
-        // (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;
-        // 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");
+        break;
+      }
+
+      case "session.text.ended": {
+        const parts = this.textByMessage.get(ev.data.assistantMessageID) ?? [];
+        parts[ev.data.ordinal] = ev.data.text;
+        this.textByMessage.set(ev.data.assistantMessageID, parts);
+        const text = parts.join("").trim();
+        if (!text) break;
+        this.transcript.push(`[assistant]: ${ev.data.text}`);
+        this.emit({
+          type: "message",
+          role: "assistant",
+          content: text,
+          messageId: ev.data.assistantMessageID,
+        });
+        break;
+      }
+
+      case "session.step.ended": {
+        this.steps++;
+        // Per-step usage drives the dashboard's context gauge.
+        const t = ev.data.tokens;
+        const contextUsed = t.input + t.cache.read + t.cache.write + t.output;
+        const contextTotal = getContextWindowSize(this.model || "default");
         if (contextTotal > 0 && contextUsed > 0) {
           this.emit({
             type: "context_usage",
             contextUsedTokens: contextUsed,
             contextTotalTokens: contextTotal,
-            // 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,
+            outputTokens: t.output,
             contextFormula: CONTEXT_FORMULA,
           });
         }
         break;
       }
 
-      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
-        // status); tool_end fires once when state transitions to "completed".
-        const props = (ev as { properties: { sessionID?: string; part?: unknown } }).properties;
-        if (props.sessionID !== this._sessionId) break;
-        const part = props.part as
-          | {
-              type?: string;
-              tool?: string;
-              callID?: string;
-              id?: string;
-              state?: { status?: string; input?: unknown; output?: unknown };
-            }
-          | undefined;
-        if (!part || part.type !== "tool") break;
-        const callId = part.callID ?? part.id ?? "";
-        if (!callId) break;
-        const toolName = part.tool ?? "tool";
-
-        if (!this.toolStartsEmitted.has(callId)) {
-          this.toolStartsEmitted.add(callId);
-          this.emit({
-            type: "tool_start",
-            toolCallId: callId,
-            toolName,
-            args: part.state?.input,
-          });
-        }
-        if (part.state?.status === "completed") {
-          this.emit({
-            type: "tool_end",
-            toolCallId: callId,
-            toolName,
-            result: part.state.output,
-          });
-        }
+      case "session.usage.updated":
+        this.usage = { cost: ev.data.cost, tokens: ev.data.tokens };
         break;
-      }
 
-      case "session.idle": {
-        if (ev.properties.sessionID !== this._sessionId) break;
+      case "session.execution.succeeded": {
         const cost = this.buildCostData(false);
-        const resultEvent: ProviderEvent = {
-          type: "result",
-          cost,
-          isError: false,
-        };
-        // Emit result (raw_log will be auto-emitted via emit())
-        for (const l of this.listeners) l(resultEvent);
-        const raw = scrubSecrets(JSON.stringify(resultEvent));
-        this.emitDirect({ type: "raw_log", content: raw });
-        void this.finish({
-          exitCode: 0,
-          sessionId: this._sessionId,
-          cost,
-          isError: false,
-        });
+        this.emit({ type: "result", cost, isError: false });
+        void this.finish({ exitCode: 0, sessionId: this._sessionId, cost, isError: false });
         break;
       }
 
-      case "session.error": {
-        if (ev.properties.sessionID !== undefined && ev.properties.sessionID !== this._sessionId)
-          break;
-        const errMsg =
-          ev.properties.error && "message" in ev.properties.error
-            ? String((ev.properties.error as { message?: string }).message ?? "unknown error")
-            : "opencode session error";
-        if (isModelNotFoundError(errMsg)) {
-          this.recoverFromModelNotFound(errMsg);
-          break;
-        }
-        this.emitError(errMsg);
+      case "session.execution.failed":
+        this.fail(errorMessage(ev.data.error, "opencode session error"));
+        break;
+
+      case "session.execution.interrupted":
+        this.fail("opencode session was interrupted");
         break;
-      }
 
-      case "permission.updated": {
-        if (ev.properties.sessionID !== this._sessionId) break;
-        // Headless worker cannot interactively approve permissions — treat as error
-        this.emitError(
-          `Permission request received in headless mode (id=${ev.properties.id}); aborting session`,
+      case "permission.asked":
+        // A headless worker cannot answer a permission prompt.
+        this.fail(
+          `Permission request received in headless mode (id=${ev.data.id}); aborting session`,
         );
         break;
-      }
 
       default:
         break;
     }
   }
 
-  /** 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);
+  /** Same file triggers the claude and pi hooks act on. */
+  private onFileChanged(file: string): void {
+    const path = file.startsWith("/") ? file : join(this.cwd, file);
+    if (
+      path === "/workspace/SOUL.md" ||
+      path === "/workspace/IDENTITY.md" ||
+      path === "/workspace/TOOLS.md" ||
+      path === "/workspace/CLAUDE.md"
+    ) {
+      void syncIdentityFilesToServer(this.swarm, "self_edit");
+    }
+    if (
+      path.startsWith("/workspace/personal/memory/") ||
+      path.startsWith("/workspace/shared/memory/")
+    ) {
+      void autoIndexMemoryFile(this.swarm, path);
     }
-    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);
-    const raw = scrubSecrets(JSON.stringify(errorEvent));
-    this.emitDirect({ type: "raw_log", content: raw });
-    const cost = this.buildCostData(true);
+  /** Settle the session as failed; also used when the event stream dies. */
+  fail(message: string): void {
+    if (this.aborted || this.completed) return;
+    this.emit({ type: "error", message });
     void this.finish({
       exitCode: 1,
       sessionId: this._sessionId,
-      cost,
+      cost: this.buildCostData(true),
       isError: true,
       failureReason: message,
     });
   }
 
   private buildCostData(isError: boolean): CostData {
-    let totalCostUsd = 0;
-    let inputTokens = 0;
-    let outputTokens = 0;
-    let reasoningOutputTokens = 0;
-    let cacheReadTokens = 0;
-    let cacheWriteTokens = 0;
-    for (const message of this.finalizedMessages.values()) {
-      totalCostUsd += message.cost;
-      inputTokens += message.inputTokens;
-      outputTokens += message.outputTokens;
-      reasoningOutputTokens += message.reasoningOutputTokens;
-      cacheReadTokens += message.cacheReadTokens;
-      cacheWriteTokens += message.cacheWriteTokens;
-    }
-
+    const { cost, tokens } = this.usage;
     return {
       sessionId: this._sessionId,
-      taskId: this.taskId,
-      agentId: this.agentId,
-      totalCostUsd,
-      inputTokens,
-      outputTokens,
-      reasoningOutputTokens,
-      cacheReadTokens,
-      cacheWriteTokens,
+      taskId: this.swarm.taskId,
+      agentId: this.swarm.agentId,
+      totalCostUsd: cost,
+      inputTokens: tokens.input,
+      outputTokens: tokens.output,
+      reasoningOutputTokens: tokens.reasoning,
+      cacheReadTokens: tokens.cache.read,
+      cacheWriteTokens: tokens.cache.write,
       durationMs: Date.now() - this.startedAt,
-      numTurns: this.finalizedMessages.size,
+      numTurns: this.steps,
       model: this.model,
       isError,
       provider: "opencode",
@@ -729,21 +577,51 @@ export class OpencodeSession implements ProviderSession {
     return this.completionPromise;
   }
 
+  /** Identity sync, session summary, and session close (Stop-hook parity). */
+  private async runSessionEnd(signal: AbortSignal): Promise<void> {
+    await sessionHooks.syncIdentity(this.swarm, "session_sync", signal);
+    if (process.env.SKIP_SESSION_SUMMARY) {
+      console.debug("session_summary skipped (opencode): SKIP_SESSION_SUMMARY is set");
+    } else {
+      const transcript = this.transcript.join("\n").slice(-TRANSCRIPT_TAIL_CHARS);
+      void summarizeTranscript(this.swarm, "opencode", transcript);
+    }
+    fireAndForget(`${this.swarm.apiUrl}/api/sessions/${this._sessionId}/close`, {
+      method: "POST",
+      headers: apiHeaders(this.swarm),
+    });
+  }
+
+  /**
+   * Settle the session. Session-end work is bounded and cancellable, so the
+   * host always closes and completion always resolves.
+   */
   private async finish(result: ProviderResult): Promise<void> {
     if (this.completed) return;
     this.completed = true;
+    const { signal } = this.sessionEnd;
     try {
-      this.server.close();
-    } catch {
-      // best-effort
+      if (!this.aborted) {
+        await settleWithin(this.runSessionEnd(signal), sessionHooks.budgetMs, signal);
+      }
+    } finally {
+      this.sessionEnd.abort();
+      await settleWithin(this.host.close(), sessionHooks.budgetMs);
+      this.completionResolve({ ...result, appliedReasoningEffort: this.appliedReasoningEffort });
     }
-    await this.cleanupFiles();
-    this.completionResolve({ ...result, appliedReasoningEffort: this.appliedReasoningEffort });
   }
 
   async abort(): Promise<void> {
     if (this.aborted) return;
+    if (this.completed) {
+      // Already finishing: cut the session-end work short and wait for cleanup.
+      this.aborted = true;
+      this.sessionEnd.abort();
+      await this.completionPromise;
+      return;
+    }
     this.aborted = true;
+    await this.host.sessions.interrupt({ sessionID: this._sessionId }).catch(() => {});
     await this.finish({
       exitCode: 1,
       sessionId: this._sessionId,
@@ -754,23 +632,16 @@ export class OpencodeSession implements ProviderSession {
 
   async deliverSteering({ mode, text }: SteerDelivery): Promise<SteerDeliveryResult> {
     if (this.completed || this.aborted) {
-      // `finish()` has closed the local server and `handleOpencodeEvent()`
-      // ignores further events — a promptAsync now would start a turn nobody
-      // observes while falsely reporting `delivered`. Fail closed so the
-      // server promotes the message to a follow-up task (same as pi).
+      // The host is closed; fail closed so the server promotes the message
+      // to a follow-up task (same as pi).
       return { delivered: false, reason: "opencode session already completed" };
     }
     try {
-      // Always queue. `steer` used to abort first and re-prompt, but E2E showed
-      // the re-prompt fails once the session has been aborted, so the message
-      // was lost to the undeliverable path. `steerModes` advertises queue only,
-      // so a "steer" request has already been degraded upstream — this branch
-      // exists for a caller that reaches us anyway, and reports queue honestly.
+      // `steerModes` advertises queue only, so a "steer" request has already
+      // been degraded upstream. Say so explicitly: OpenCode 2 defaults to steer.
       void mode;
-      await this.client.session.promptAsync({
-        path: { id: this._sessionId },
-        body: { parts: [{ type: "text", text }] },
-      });
+      await this.host.sessions.prompt({ sessionID: this._sessionId, text, delivery: "queue" });
+      this.recordUserPrompt(text);
       return { delivered: true, mode: "queue" };
     } catch (err) {
       return { delivered: false, reason: String(err) };
@@ -797,18 +668,7 @@ export class OpencodeAdapter implements ProviderAdapter {
 
   async createSession(config: ProviderSessionConfig): Promise<ProviderSession> {
     const taskId = config.taskId;
-    const agentName = `swarm-${taskId}`;
-    const agentFilePath = join(config.cwd, ".opencode", "agents", `${agentName}.md`);
-    const configFilePath = `/tmp/opencode-${taskId}.json`;
-    const dataHomePath = `/tmp/opencode-data-${taskId}`;
-
-    // Write per-task agent file (best-effort; contains the system prompt)
-    try {
-      mkdirSync(join(config.cwd, ".opencode", "agents"), { recursive: true });
-      await Bun.write(agentFilePath, config.systemPrompt ?? "");
-    } catch {
-      // best-effort
-    }
+    const env = config.env ?? process.env;
 
     // Build MCP config: swarm endpoint + installed MCP servers
     const installedMcp =
@@ -818,17 +678,15 @@ export class OpencodeAdapter implements ProviderAdapter {
     // tools require it in multi-runtime mode, and it travels as request
     // context, not as a tool argument.
     const runtimeInstanceId = swarmRuntimeInstanceId();
-    const mcpConfig: Config["mcp"] = {
+    const mcp: Record<string, unknown> = {
       swarm: {
         type: "remote",
         url: `${config.apiUrl}/mcp`,
         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.
+          // Per-task identity, same as claude/codex: gives `store-progress` a
+          // default task. The host is 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 } : {}),
@@ -836,45 +694,20 @@ export class OpencodeAdapter implements ProviderAdapter {
       },
       ...installedMcp,
     };
-
-    // Resolve the agent-swarm plugin path. Three layers, in priority order:
-    //   1. OPENCODE_SWARM_PLUGIN_PATH env (explicit override)
-    //   2. The well-known Docker location (Dockerfile.worker COPYs the plugin
-    //      to /home/worker/.config/opencode/plugins/agent-swarm.ts)
-    //   3. The dev path relative to this source file
-    // The previous one-liner used `import.meta.dir` only, which resolves to
-    // `/usr/local/bin` for the bundled binary and produced the non-existent
-    // `/plugin/opencode-plugins/agent-swarm.ts`. Docker only worked because
-    // opencode auto-discovers plugins from ~/.config/opencode/plugins/ —
-    // an accident, not a contract.
-    const pluginPath = resolvePluginPath();
-
-    // context-mode ships as an in-process opencode plugin (NOT an MCP server).
-    // Its built plugin entry registers both the native ctx_* tools and the 5
-    // hook surrogates. It must NOT also appear in the `mcp` block — dual
-    // registration yields zero tools. We push the ABSOLUTE path to the globally
-    // installed package's opencode plugin entry, not the bare name (see
-    // resolveContextModePluginPath for why a bare name fails to resolve offline).
-    // Gated by CONTEXT_MODE_DISABLED so builds/deploys without it opt out.
-    const plugins = [pluginPath];
+    // context-mode ships only a V1 opencode plugin, which OpenCode 2 cannot
+    // load, so wire its stdio MCP server instead (same as codex).
     if (!isEnvFlagEnabled("CONTEXT_MODE_DISABLED", false)) {
-      const contextModePluginPath = resolveContextModePluginPath();
-      if (contextModePluginPath) {
-        plugins.push(contextModePluginPath);
-      } else {
-        console.warn(
-          "[opencode] context-mode is enabled but its opencode plugin entry was not found on disk; " +
-            "skipping it for this session. Set CONTEXT_MODE_OPENCODE_PLUGIN_PATH to override, or " +
-            "CONTEXT_MODE_DISABLED=true to silence.",
-        );
-      }
+      mcp["context-mode"] = {
+        type: "local",
+        command: ["context-mode"],
+        environment: { CONTEXT_MODE_EXTERNAL_MCP_NUDGE_EVERY: CTX_MODE_NUDGE_EVERY },
+      };
     }
 
-    // Build per-task opencode config (plugin field carries the swarm plugin)
-    const opencodeConfig: Config & { plugin?: string[] } = {
+    const opencodeConfig: OpencodeConfig = {
       $schema: "https://opencode.ai/config.json",
       model: config.model,
-      mcp: mcpConfig,
+      mcp,
       permission: {
         edit: "allow",
         bash: "allow",
@@ -882,13 +715,16 @@ export class OpencodeAdapter implements ProviderAdapter {
         doom_loop: "allow",
         external_directory: "allow",
       },
-      plugin: plugins,
+      // The system prompt lives on a config-defined agent; nothing is written
+      // into the task's working directory.
+      agent: {
+        [SWARM_AGENT_NAME]: { mode: "primary", prompt: config.systemPrompt ?? "" },
+      },
     };
 
-    // Phase 4 (reasoning-effort plan): splice the provider-keyed reasoning
-    // options into `provider[providerId].models[modelId].options`. `off`
-    // (and any capability-rejected level) resolves to `noop` — no keys added,
-    // provider's own default applies.
+    // Splice the provider-keyed reasoning options into
+    // `provider[providerId].models[modelId].options`. `off` (and any
+    // capability-rejected level) resolves to `noop`.
     const reasoningApplication = applyReasoningEffort(
       "opencode",
       config.model,
@@ -898,225 +734,108 @@ export class OpencodeAdapter implements ProviderAdapter {
       reasoningApplication.kind === "opencode-options" ? (config.reasoningEffort ?? null) : null;
     if (reasoningApplication.kind === "opencode-options") {
       const { providerId, modelId, options } = reasoningApplication;
+      const provider = opencodeConfig.provider?.[providerId];
       opencodeConfig.provider = {
         ...opencodeConfig.provider,
         [providerId]: {
-          ...opencodeConfig.provider?.[providerId],
+          ...provider,
           models: {
-            ...opencodeConfig.provider?.[providerId]?.models,
+            ...provider?.models,
             [modelId]: {
-              ...opencodeConfig.provider?.[providerId]?.models?.[modelId],
-              options: {
-                ...opencodeConfig.provider?.[providerId]?.models?.[modelId]?.options,
-                ...options,
-              },
+              ...provider?.models?.[modelId],
+              options: { ...provider?.models?.[modelId]?.options, ...options },
             },
           },
         },
       };
     }
 
-    applyOpenRouterBaseUrlOverride(opencodeConfig, config.env ?? process.env);
-
-    // Write per-task config file
-    try {
-      await Bun.write(configFilePath, JSON.stringify(opencodeConfig, null, 2));
-    } catch {
-      // best-effort
-    }
+    applyOpenRouterBaseUrlOverride(opencodeConfig, env);
 
-    // Set per-task data home before spawning the opencode process
-    process.env.OPENCODE_DATA_HOME = dataHomePath;
-
-    // Set SWARM_* env vars so the plugin can read them (inherited by child process)
-    const swarmEnvSnapshot = {
-      SWARM_API_URL: process.env.SWARM_API_URL,
-      SWARM_API_KEY: process.env.SWARM_API_KEY,
-      SWARM_AGENT_ID: process.env.SWARM_AGENT_ID,
-      SWARM_TASK_ID: process.env.SWARM_TASK_ID,
-      SWARM_IS_LEAD: process.env.SWARM_IS_LEAD,
-      OPENROUTER_BASE_URL: process.env.OPENROUTER_BASE_URL,
+    const swarm: SwarmHooksConfig = {
+      apiUrl: config.apiUrl,
+      apiKey: config.apiKey,
+      agentId: config.agentId,
+      taskId,
+      isLead: config.role === "lead",
+      env: config.env,
     };
-    process.env.SWARM_API_URL = config.apiUrl;
-    process.env.SWARM_API_KEY = config.apiKey;
-    process.env.SWARM_AGENT_ID = config.agentId;
-    process.env.SWARM_TASK_ID = config.taskId;
-    process.env.SWARM_IS_LEAD = config.role === "lead" ? "true" : "false";
-    // Mirror the resolved OpenRouter gateway into the spawn env: the
-    // summarize plugin (and any other plugin OpenRouter fetch) reads its own
-    // process.env inside the opencode subprocess, which inherits OURS — a
-    // per-task swarm_config value in `config.env` would otherwise be
-    // invisible there and the plugin would bypass the gateway.
-    const spawnOpenRouterBaseUrl = getOpenRouterBaseUrl(
-      (config.env ?? process.env) as NodeJS.ProcessEnv,
-    );
-    if (spawnOpenRouterBaseUrl !== DEFAULT_OPENROUTER_BASE_URL) {
-      process.env.OPENROUTER_BASE_URL = spawnOpenRouterBaseUrl;
-    }
-    process.env.CONTEXT_MODE_EXTERNAL_MCP_NUDGE_EVERY = CTX_MODE_NUDGE_EVERY;
-
-    // Set OPENCODE_CONFIG scoped to the spawn call (save + restore)
-    const prevOpencodeConfig = process.env.OPENCODE_CONFIG;
-    process.env.OPENCODE_CONFIG = configFilePath;
-
-    let client: Awaited<ReturnType<typeof createOpencode>>["client"];
-    let server: Awaited<ReturnType<typeof createOpencode>>["server"];
-    try {
-      ({ client, server } = await createOpencode({
-        hostname: "127.0.0.1",
-        port: 0,
-        timeout: serverStartTimeoutMs(),
-        config: opencodeConfig,
-      }));
-    } finally {
-      // Restore OPENCODE_CONFIG after the process has been spawned
-      if (prevOpencodeConfig === undefined) {
-        delete process.env.OPENCODE_CONFIG;
-      } else {
-        process.env.OPENCODE_CONFIG = prevOpencodeConfig;
-      }
-      // Restore SWARM_* env vars
-      for (const [key, val] of Object.entries(swarmEnvSnapshot)) {
-        if (val === undefined) {
-          delete process.env[key];
-        } else {
-          process.env[key] = val;
-        }
-      }
-    }
+    const { sdk, version: opencodeVersion } = await loadOpencodeSdkImpl();
+    let listTools: OpencodeToolLister | undefined;
+    const host = await sdk.OpenCode.create({
+      config: { content: JSON.stringify(opencodeConfig) },
+      plugins: [
+        createOpencodeSwarmPlugin(swarm, {
+          onToolRegistry: (lister) => {
+            listTools = lister;
+          },
+        }),
+      ],
+      log: {
+        level: "warn",
+        emit: (entry) => console.warn(scrubSecrets(`[opencode] ${entry.message}`)),
+      },
+    });
 
-    // Create the opencode session (project directory = config.cwd). The first
-    // session in a fresh data home installs plugins and fetches the models
-    // list, and on a cold container that call has hung with no opencode events
-    // at all. Bound it with the same budget as the server start so a hang
-    // fails fast as a spawn failure instead of stalling the worker.
-    const sessionCreateTimeoutMs = serverStartTimeoutMs();
-    let createResult: Awaited<ReturnType<typeof client.session.create>>;
+    let sessionId: string;
     try {
-      createResult = await withTimeout(
-        client.session.create({ query: { directory: config.cwd } }),
-        sessionCreateTimeoutMs,
-        `opencode session create timed out after ${sessionCreateTimeoutMs}ms`,
-      );
+      const created = await host.sessions.create({
+        location: { directory: config.cwd },
+        agent: SWARM_AGENT_NAME,
+      });
+      sessionId = created.id;
     } catch (err) {
-      server.close();
+      await host.close().catch(() => {});
       throw err;
     }
-    if (!createResult.data) {
-      server.close();
-      throw new Error("Failed to create opencode session");
-    }
-    const opencodeSession = createResult.data;
-    const sessionId = opencodeSession.id;
-
-    let promptRefreshAttempted = false;
-    let promptRefreshPromise: Promise<boolean> | undefined;
-    let session: OpencodeSession | undefined;
-    const sendPrompt = async () => {
-      const resolvedPrompt = await resolveSlashSkillPrompt(config.prompt, {
-        providerLabel: "opencode",
-        skillsDir: defaultOpencodeSkillsDir(),
-        emit: (event) => session?.emitProviderEvent(event),
-        onInline: config.onPromptSkill,
-      });
-      await client.session.prompt({
-        path: { id: sessionId },
-        query: { directory: config.cwd },
-        body: {
-          agent: agentName,
-          parts: [{ type: "text", text: resolvedPrompt }],
-        },
-      });
-    };
-    const refreshOpenRouterAndRetryPrompt = async (): Promise<boolean> => {
-      if (promptRefreshPromise) return await promptRefreshPromise;
-      if (promptRefreshAttempted || !isOpenRouterModel(config.model)) return false;
-      promptRefreshAttempted = true;
-      promptRefreshPromise = (async () => {
-        await refreshOpenRouterModelCacheImpl(opencodeConfig, configFilePath, dataHomePath);
-        await sendPrompt();
-        return true;
-      })();
-      return await promptRefreshPromise;
-    };
 
-    session = new OpencodeSession(
+    const session = new OpencodeSession(
+      host,
       sessionId,
-      client,
-      server,
       config.model,
-      config.agentId,
-      config.taskId,
-      agentFilePath,
-      configFilePath,
-      dataHomePath,
-      isOpenRouterModel(config.model) ? refreshOpenRouterAndRetryPrompt : undefined,
+      swarm,
+      config.cwd,
       appliedReasoningEffort,
     );
-
-    // Emit session_init synchronously; the session buffers events until the
-    // runner's `onEvent(listener)` call attaches a listener.
-    const opcVersion = readPkgVersion("@opencode-ai/sdk");
-    session.emitSessionInit("opencode", opcVersion ? { version: opcVersion } : undefined);
-
-    // Subscribe to SSE events and drive the session. The SDK's SSE client
-    // retries a dropped connection forever by default, so a dead `opencode
-    // serve` child would keep the stream (and the session promise) pending
-    // and hold the worker's slot. Cap the retries so the stream ends.
-    client.event
-      .subscribe({
-        query: { directory: config.cwd },
-        sseMaxRetryAttempts: OPENCODE_SSE_MAX_RETRY_ATTEMPTS,
-      })
-      .then(async ({ stream }) => {
-        for await (const event of stream) {
-          session.handleOpencodeEvent(event as OpencodeEvent);
+    session.emitSessionInit(opencodeVersion ? { version: opencodeVersion } : undefined);
+
+    // Drive the session from the host's event stream. Closing the host ends
+    // the stream; ending without a terminal event means the host died.
+    void (async () => {
+      try {
+        for await (const event of host.events.subscribe()) {
+          session.handleOpencodeEvent(event);
           if (session.isFinished) break;
         }
-        // The stream ended without session.idle: the opencode server closed
-        // or died. Settle the session so the runner releases the slot.
-        if (!session.isFinished) {
-          session.handleOpencodeEvent({
-            type: "session.error",
-            properties: {
-              sessionID: sessionId,
-              error: {
-                message: "runner exited without result: opencode event stream ended",
-              } as never,
-            },
-          });
-        }
-      })
-      .catch((err: unknown) => {
-        session.handleOpencodeEvent({
-          type: "session.error",
-          properties: { sessionID: sessionId, error: { message: String(err) } as never },
-        });
-      });
-
-    // Fire-and-forget: send the prompt using the per-task agent
-    sendPrompt().catch((err: unknown) => {
-      const message = formatUnknownError(err);
-      if (isModelNotFoundError(message) && isOpenRouterModel(config.model)) {
-        session.emitModelCacheRefreshProgress();
-        refreshOpenRouterAndRetryPrompt()
-          .then((retried) => {
-            if (retried) return;
-            session.handleOpencodeEvent({
-              type: "session.error",
-              properties: { sessionID: sessionId, error: { message } as never },
-            });
-          })
-          .catch((retryErr: unknown) => {
-            session.emitModelCacheRefreshFailure(message, retryErr);
-          });
+        session.fail("runner exited without result: opencode event stream ended");
+      } catch (err) {
+        session.fail(String(err));
+      }
+    })();
+
+    void (async () => {
+      // Without the swarm tools the model cannot report; fail before prompting.
+      const refused = await checkSwarmMcpAdmission(
+        host,
+        config.cwd,
+        () => listTools,
+        sessionHooks.admissionTimeoutMs,
+        () => session.isFinished,
+      );
+      if (refused) {
+        session.fail(scrubSecrets(`swarm MCP admission failed: ${refused}`));
         return;
       }
-      session.handleOpencodeEvent({
-        type: "session.error",
-        properties: { sessionID: sessionId, error: { message } as never },
+      if (session.isFinished) return;
+      const prompt = await resolveSlashSkillPrompt(config.prompt, {
+        providerLabel: "opencode",
+        skillsDir: defaultOpencodeSkillsDir(),
+        emit: (event) => session.emitProviderEvent(event),
+        onInline: config.onPromptSkill,
       });
-    });
+      session.recordUserPrompt(prompt);
+      await host.sessions.prompt({ sessionID: sessionId, text: prompt, delivery: "queue" });
+    })().catch((err: unknown) => session.fail(scrubSecrets(errorMessage(err, String(err)))));
 
     return session;
   }