replicas-engine 0.1.338 → 0.1.339

package/dist/src/index.js

@@ -15,7 +15,7 @@ function isRecord(value) {
 }
 
 // ../shared/src/agent.ts
-var VALID_AGENT_PROVIDERS = ["claude", "codex", "cursor", "relay"];
+var VALID_AGENT_PROVIDERS = ["claude", "codex", "cursor", "opencode", "relay"];
 var VALID_CODING_AGENT_PROVIDERS = VALID_AGENT_PROVIDERS.filter(
   (provider) => provider !== "relay"
 );
@@ -295,7 +295,7 @@ var WORKSPACE_SIZES = ["small", "large"];
 var INVALID_WORKSPACE_SIZE_ERROR = `Invalid size: must be one of ${WORKSPACE_SIZES.join(", ")}`;
 
 // ../shared/src/e2b.ts
-var E2B_TEMPLATE_NAME = "replicas-sandbox-2026-06-22-v4";
+var E2B_TEMPLATE_NAME = "replicas-sandbox-2026-06-23-v1";
 
 // ../shared/src/runtime-env.ts
 function parsePosixEnvFile(content) {
@@ -496,16 +496,13 @@ scrot /tmp/state.png
 replicas computer info
 
 # 2) Launch a browser on the workspace display.
-replicas computer launch chrome
+replicas computer launch chrome https://news.ycombinator.com
 
 # 3) Take a screenshot so you can see what's there.
 replicas computer screenshot /tmp/state.png
 # (Read the PNG yourself before deciding where to click.)
 
 # 4) Drive the UI.
-replicas computer key ctrl+l                       # focus address bar
-replicas computer type "https://news.ycombinator.com"
-replicas computer key Return
 replicas computer click 521 700                    # click coordinates from the screenshot
 replicas computer scroll down --amount 5
 
@@ -558,6 +555,7 @@ Spawns an app on the workspace display. Built-in aliases:
 - \`notepad\` / \`editor\` - mousepad (lightweight GTK text editor)
 - \`files\` / \`filemanager\` - thunar (file manager)
 Anything else gets \`exec\`'d verbatim, so \`replicas computer launch xeyes\` works if xeyes is installed.
+When opening a known page, prefer passing the URL directly: \`replicas computer launch chrome http://localhost:3000/\`.
 
 ### \`replicas computer record start <path> [--fps N]\`
 Starts an ffmpeg screen recorder. Output is a fragmented MP4 (still playable if the workspace dies mid-record). Default 60fps; drop to 30 if the workspace is CPU-constrained.
@@ -583,6 +581,8 @@ replicas computer screenshot /tmp/after-click.png
 
 ### Typing into an address bar
 \`\`\`bash
+replicas computer launch chrome
+sleep 2
 replicas computer key ctrl+l                    # focus address bar
 replicas computer type "https://example.com"
 replicas computer key Return
@@ -2177,12 +2177,14 @@ var DEFAULT_CHAT_TITLES = {
   claude: "Claude Code",
   codex: "Codex",
   cursor: "Cursor",
+  opencode: "Opencode",
   relay: "Relay"
 };
 var CLAUDE_OPUS_1M_MODEL = "opus[1m]";
 var LEGACY_CLAUDE_OPUS_1M_MODEL = "opus-1m";
 var DEFAULT_CODEX_MODEL = "gpt-5.5";
 var DEFAULT_CURSOR_MODEL = "composer-2";
+var DEFAULT_OPENCODE_MODEL = "z-ai/glm-5.2";
 function normalizeClaudeModel(model) {
   if (model === LEGACY_CLAUDE_OPUS_1M_MODEL) {
     return CLAUDE_OPUS_1M_MODEL;
@@ -2193,6 +2195,7 @@ var AGENT_MODELS = {
   claude: [CLAUDE_OPUS_1M_MODEL, "sonnet", "haiku"],
   codex: [DEFAULT_CODEX_MODEL, "gpt-5.4", "gpt-5.4-mini", "gpt-5.3-codex", "gpt-5.2"],
   cursor: [DEFAULT_CURSOR_MODEL, "composer-2.5"],
+  opencode: [DEFAULT_OPENCODE_MODEL, "minimax/minimax-m3", "xiaomi/mimo-v2.5-pro", "moonshotai/kimi-k2.6:free"],
   relay: [CLAUDE_OPUS_1M_MODEL, "sonnet"]
 };
 var MODEL_LABELS = {
@@ -2203,7 +2206,11 @@ var MODEL_LABELS = {
   haiku: "Haiku 4.5",
   [DEFAULT_CODEX_MODEL]: "GPT-5.5",
   [DEFAULT_CURSOR_MODEL]: "Composer 2",
+  [DEFAULT_OPENCODE_MODEL]: "GLM 5.2 via OpenRouter",
   "composer-2.5": "Composer 2.5",
+  "minimax/minimax-m3": "MiniMax M3 via OpenRouter",
+  "xiaomi/mimo-v2.5-pro": "MiMo V2.5 Pro via OpenRouter",
+  "moonshotai/kimi-k2.6:free": "Kimi K2.6 via OpenRouter",
   "gpt-5.4": "GPT-5.4",
   "gpt-5.4-mini": "GPT-5.4 Mini",
   "gpt-5.3-codex": "GPT-5.3 Codex",
@@ -2877,6 +2884,7 @@ function loadEngineEnv() {
     ANTHROPIC_API_KEY: readEnv("ANTHROPIC_API_KEY"),
     OPENAI_API_KEY: readEnv("OPENAI_API_KEY"),
     CURSOR_API_KEY: readEnv("CURSOR_API_KEY"),
+    OPENROUTER_API_KEY: readEnv("OPENROUTER_API_KEY"),
     CLAUDE_CODE_USE_BEDROCK: readEnv("CLAUDE_CODE_USE_BEDROCK"),
     AWS_ACCESS_KEY_ID: readEnv("AWS_ACCESS_KEY_ID"),
     AWS_SECRET_ACCESS_KEY: readEnv("AWS_SECRET_ACCESS_KEY"),
@@ -4335,6 +4343,7 @@ var REPLICAS_DIR = join7(homedir5(), ".replicas");
 var DETAILS_FILE = join7(REPLICAS_DIR, "environment-details.json");
 var CLAUDE_CREDENTIALS_PATH = join7(homedir5(), ".claude", ".credentials.json");
 var CODEX_AUTH_PATH = join7(homedir5(), ".codex", "auth.json");
+var OPENCODE_AUTH_PATH = join7(homedir5(), ".local", "share", "opencode", "auth.json");
 var GH_HOSTS_PATH = join7(homedir5(), ".config", "gh", "hosts.yml");
 function detectClaudeAuthMethod() {
   if (existsSync3(CLAUDE_CREDENTIALS_PATH)) {
@@ -4360,6 +4369,9 @@ function detectCodexAuthMethod() {
 function detectCursorAuthMethod() {
   return ENGINE_ENV.CURSOR_API_KEY ? "api_key" : "none";
 }
+function detectOpencodeAuthMethod() {
+  return existsSync3(OPENCODE_AUTH_PATH) || ENGINE_ENV.OPENROUTER_API_KEY ? "api_key" : "none";
+}
 async function detectGitIdentityConfigured() {
   try {
     const { stdout } = await execFileAsync("git", ["config", "--global", "user.name"]);
@@ -4400,6 +4412,7 @@ function createDefaultDetails() {
     claudeAuthMethod: "none",
     codexAuthMethod: "none",
     cursorAuthMethod: "none",
+    opencodeAuthMethod: "none",
     lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
@@ -4431,6 +4444,7 @@ var EnvironmentDetailsService = class {
     details.claudeAuthMethod = detectClaudeAuthMethod();
     details.codexAuthMethod = detectCodexAuthMethod();
     details.cursorAuthMethod = detectCursorAuthMethod();
+    details.opencodeAuthMethod = detectOpencodeAuthMethod();
     details.gitIdentityConfigured = gitIdentityConfigured;
     const ghConfigured = existsSync3(GH_HOSTS_PATH);
     details.githubAccessConfigured = ghConfigured;
@@ -5179,9 +5193,9 @@ async function registerDesktopPreview() {
 
 // src/services/chat/chat-service.ts
 import { existsSync as existsSync7 } from "fs";
-import { appendFile as appendFile3, copyFile, mkdir as mkdir12, readFile as readFile12, rename as rename2, rm } from "fs/promises";
+import { appendFile as appendFile3, copyFile, mkdir as mkdir13, readFile as readFile13, rename as rename2, rm } from "fs/promises";
 import { homedir as homedir14 } from "os";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 import { randomUUID as randomUUID5 } from "crypto";
 
 // src/managers/claude-manager.ts
@@ -5745,6 +5759,21 @@ var CodingAgentManager = class {
       payload
     });
   }
+  recordHistoryEvent(type, payload, historyFile) {
+    const eventPayload = {};
+    if (payload && typeof payload === "object") {
+      Object.assign(eventPayload, payload);
+    } else {
+      eventPayload.value = payload;
+    }
+    const event = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      type,
+      payload: eventPayload
+    };
+    this.onEvent(event);
+    historyFile.append(event);
+  }
   initializeManager(processMessage) {
     this.messageQueue = new MessageQueueService(processMessage);
     this.initialized = this.initialize();
@@ -7508,7 +7537,7 @@ var AspClient = class {
 // src/managers/codex-asp/app-server-process.ts
 var DEFAULT_CODEX_BINARY = "codex";
 var DEFAULT_CODEX_ARGS = ["app-server", "--listen", "stdio://"];
-var ENGINE_PACKAGE_VERSION = "0.1.338";
+var ENGINE_PACKAGE_VERSION = "0.1.339";
 var INITIALIZE_METHOD = "initialize";
 var INITIALIZED_NOTIFICATION = "initialized";
 var ACCOUNT_LOGIN_START_METHOD = "account/login/start";
@@ -9332,7 +9361,7 @@ var CursorManager = class extends CodingAgentManager {
       this.recordHistoryEvent("event_msg", {
         type: "user_message",
         message: request.message
-      });
+      }, this.historyFile);
       const run = await agent.send(message, {
         model: { id: request.model ?? DEFAULT_CURSOR_MODEL },
         mode: request.planMode ? "plan" : "agent"
@@ -9347,13 +9376,13 @@ var CursorManager = class extends CodingAgentManager {
           type: "error",
           message: result.result || "Cursor run failed",
           runId: result.id
-        });
+        }, this.historyFile);
       }
     } catch (error) {
       this.recordHistoryEvent("cursor-error", {
         type: "error",
         message: error instanceof Error ? error.message : String(error)
-      });
+      }, this.historyFile);
     } finally {
       this.activeRun = null;
       await this.historyFile.flush();
@@ -9374,22 +9403,431 @@ var CursorManager = class extends CodingAgentManager {
     };
   }
   recordCursorEvent(event) {
-    this.recordHistoryEvent(`cursor-${event.type}`, event);
+    this.recordHistoryEvent(`cursor-${event.type}`, event, this.historyFile);
   }
-  recordHistoryEvent(type, payload) {
-    const eventPayload = {};
-    if (payload && typeof payload === "object") {
-      Object.assign(eventPayload, payload);
-    } else {
-      eventPayload.value = payload;
+};
+
+// src/managers/opencode-manager.ts
+import { mkdir as mkdir12, readFile as readFile10 } from "fs/promises";
+import { delimiter, dirname as dirname6, join as join16 } from "path";
+import { randomBytes as randomBytes2 } from "crypto";
+import { fileURLToPath } from "url";
+import { Agent } from "undici";
+import {
+  createOpencodeClient,
+  createOpencodeServer
+} from "@opencode-ai/sdk/v2";
+var OPENCODE_SHIM_DIR = dirname6(fileURLToPath(new URL("../../scripts/opencode", import.meta.url)));
+var OPENCODE_CONFIG_PATH = join16(ENGINE_ENV.HOME_DIR, ".config", "opencode", "opencode.json");
+var OPENCODE_FETCH_DISPATCHER = new Agent({ headersTimeout: 0, bodyTimeout: 0 });
+var OPENCODE_WORKSPACE_PERMISSION = "allow";
+var OPENCODE_VARIANT_CANDIDATES_BY_THINKING_LEVEL = {
+  low: ["low"],
+  medium: ["medium"],
+  high: ["high"],
+  max: ["max", "xhigh", "high"]
+};
+async function opencodeConfig(model) {
+  const models = getConfiguredOpencodeModels(model);
+  const mcp = await readProvisionedOpencodeMcpConfig();
+  const config = {
+    enabled_providers: ["openrouter"],
+    model: `openrouter/${model}`,
+    provider: {
+      openrouter: {
+        models: Object.fromEntries(models.map((candidate) => [candidate, {}])),
+        options: {
+          apiKey: "{env:OPENROUTER_API_KEY}"
+        }
+      }
+    },
+    permission: OPENCODE_WORKSPACE_PERMISSION,
+    share: "disabled"
+  };
+  if (mcp && Object.keys(mcp).length > 0) {
+    config.mcp = mcp;
+  }
+  return config;
+}
+function getConfiguredOpencodeModels(model) {
+  return [.../* @__PURE__ */ new Set([model, ...AGENT_MODELS.opencode])];
+}
+function isOpencodePart(value) {
+  return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+}
+function isStringRecord(value) {
+  return isRecord4(value) && !Array.isArray(value) && Object.values(value).every((item) => typeof item === "string");
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function isOpencodeMcpEntry(value) {
+  if (!isRecord4(value) || Array.isArray(value)) return false;
+  if (typeof value.enabled === "boolean" && typeof value.type !== "string") return true;
+  if (value.type === "local") {
+    return isStringArray(value.command) && (value.environment === void 0 || isStringRecord(value.environment));
+  }
+  if (value.type === "remote") {
+    return typeof value.url === "string" && (value.headers === void 0 || isStringRecord(value.headers));
+  }
+  return false;
+}
+async function readProvisionedOpencodeMcpConfig() {
+  let raw;
+  try {
+    raw = await readFile10(OPENCODE_CONFIG_PATH, "utf8");
+  } catch (error) {
+    if (isRecord4(error) && error.code === "ENOENT") return void 0;
+    console.error("[OpencodeManager] Failed to read Opencode config:", error);
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!isRecord4(parsed) || !isRecord4(parsed.mcp) || Array.isArray(parsed.mcp)) return void 0;
+    const mcp = {};
+    for (const [name, entry] of Object.entries(parsed.mcp)) {
+      if (isOpencodeMcpEntry(entry)) mcp[name] = entry;
     }
-    const event = {
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      type,
-      payload: eventPayload
+    return mcp;
+  } catch (error) {
+    console.error("[OpencodeManager] Failed to parse Opencode config:", error);
+    return void 0;
+  }
+}
+function timestampMs(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string") {
+    const parsed = Date.parse(value);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return Date.now();
+}
+function isOpencodeRuntimeEvent(value) {
+  return isRecord4(value) && typeof value.type === "string";
+}
+function opencodeEventPayload(event) {
+  if ("properties" in event && isRecord4(event.properties)) return event.properties;
+  if ("data" in event && isRecord4(event.data)) return event.data;
+  return null;
+}
+function opencodeErrorMessage(error) {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "string") return error;
+  if (!isRecord4(error)) return void 0;
+  if (typeof error.message === "string") return error.message;
+  if (typeof error.name === "string") return error.name;
+  if ("error" in error) return opencodeErrorMessage(error.error);
+  if ("data" in error) return opencodeErrorMessage(error.data);
+  if ("body" in error) return opencodeErrorMessage(error.body);
+  return void 0;
+}
+function opencodeErrorPayload(error) {
+  const message = opencodeErrorMessage(error) ?? String(error);
+  const code = typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : void 0;
+  return {
+    message: code === "ENOENT" ? `Failed to start Opencode server binary (${message}).` : message,
+    ...code ? { code } : {}
+  };
+}
+function opencodeFetch(input, init) {
+  return fetch(input, { ...init, dispatcher: OPENCODE_FETCH_DISPATCHER });
+}
+var OpencodeManager = class extends CodingAgentManager {
+  client = null;
+  server = null;
+  sessionId = null;
+  historyFilePath;
+  historyFile;
+  activeAbortController = null;
+  configuredModels = /* @__PURE__ */ new Set();
+  eventAbortController = null;
+  eventSubscriptionReady = Promise.resolve();
+  resolveEventSubscriptionReady = null;
+  textParts = /* @__PURE__ */ new Map();
+  reasoningParts = /* @__PURE__ */ new Map();
+  nonAssistantMessageIds = /* @__PURE__ */ new Set();
+  modelVariants = /* @__PURE__ */ new Map();
+  constructor(options) {
+    super(options);
+    this.sessionId = options.initialSessionId;
+    this.historyFilePath = options.historyFilePath ?? join16(ENGINE_ENV.HOME_DIR, ".replicas", "opencode", "history.jsonl");
+    this.historyFile = new CodexHistoryFile(this.historyFilePath);
+    this.initializeManager(this.processMessageInternal.bind(this));
+  }
+  async initialize() {
+    await mkdir12(dirname6(this.historyFilePath), { recursive: true });
+  }
+  async interruptActiveTurn() {
+    this.activeAbortController?.abort();
+    if (this.client && this.sessionId) {
+      try {
+        await this.client.session.abort(
+          { sessionID: this.sessionId, directory: this.workingDirectory },
+          { throwOnError: true }
+        );
+      } catch (error) {
+        console.error("[OpencodeManager] Failed to abort Opencode session:", error);
+      }
+    }
+  }
+  async getHistory() {
+    await this.historyFile.flush();
+    const history = await this.historyFile.load();
+    return {
+      thread_id: this.sessionId ?? this.initialSessionId,
+      events: history.events,
+      goal: null
     };
-    this.onEvent(event);
-    this.historyFile.append(event);
+  }
+  async ensureClient(model) {
+    if (this.client && this.configuredModels.has(model)) return this.client;
+    if (!ENGINE_ENV.OPENROUTER_API_KEY) {
+      throw new Error("OpenRouter API key is not configured for Opencode in this workspace.");
+    }
+    this.eventAbortController?.abort();
+    this.server?.close();
+    const pathEntries = (process.env.PATH ?? "").split(delimiter).filter(Boolean);
+    if (!pathEntries.includes(OPENCODE_SHIM_DIR)) {
+      process.env.PATH = [OPENCODE_SHIM_DIR, ...pathEntries].join(delimiter);
+    }
+    const password = process.env.OPENCODE_SERVER_PASSWORD || randomBytes2(24).toString("base64url");
+    process.env.OPENCODE_SERVER_PASSWORD = password;
+    const server = await createOpencodeServer({
+      port: 0,
+      config: await opencodeConfig(model)
+    });
+    const client = createOpencodeClient({
+      baseUrl: server.url,
+      fetch: opencodeFetch,
+      headers: {
+        Authorization: `Basic ${Buffer.from(`opencode:${password}`).toString("base64")}`
+      }
+    });
+    this.client = client;
+    this.server = server;
+    this.configuredModels = new Set(getConfiguredOpencodeModels(model));
+    const eventController = new AbortController();
+    this.eventAbortController = eventController;
+    this.eventSubscriptionReady = new Promise((resolve4) => {
+      this.resolveEventSubscriptionReady = resolve4;
+    });
+    this.subscribeToEvents(client, eventController).catch((error) => {
+      this.resolveEventSubscriptionReady?.();
+      this.resolveEventSubscriptionReady = null;
+      console.error("[OpencodeManager] Event subscription failed:", error);
+      this.recordHistoryEvent("opencode-error", opencodeErrorPayload(error), this.historyFile);
+    });
+    await Promise.race([
+      this.eventSubscriptionReady,
+      new Promise((resolve4) => setTimeout(resolve4, 2e3))
+    ]);
+    return client;
+  }
+  async ensureSession(client, model, agent, variant) {
+    if (this.sessionId) {
+      try {
+        await client.session.get(
+          { sessionID: this.sessionId, directory: this.workingDirectory },
+          { throwOnError: true }
+        );
+        return this.sessionId;
+      } catch {
+        this.sessionId = null;
+      }
+    }
+    const result = await client.session.create({
+      directory: this.workingDirectory,
+      agent,
+      model: { providerID: "openrouter", id: model, ...variant ? { variant } : {} }
+    }, { throwOnError: true });
+    const session = result.data;
+    this.sessionId = session.id;
+    await this.onSaveSessionId(session.id);
+    return session.id;
+  }
+  async getModelVariants(client, model) {
+    const cached = this.modelVariants.get(model);
+    if (cached) return cached;
+    try {
+      const result = await client.v2.model.list(
+        { location: { directory: this.workingDirectory } },
+        { throwOnError: true }
+      );
+      for (const candidate of result.data.data) {
+        if (candidate.providerID === "openrouter") {
+          this.modelVariants.set(candidate.id, new Set(candidate.variants.map((variant) => variant.id)));
+        }
+      }
+    } catch {
+      this.modelVariants.set(model, /* @__PURE__ */ new Set());
+    }
+    return this.modelVariants.get(model) ?? /* @__PURE__ */ new Set();
+  }
+  async getThinkingVariant(client, model, thinkingLevel) {
+    if (!thinkingLevel) return void 0;
+    const variants = await this.getModelVariants(client, model);
+    return OPENCODE_VARIANT_CANDIDATES_BY_THINKING_LEVEL[thinkingLevel].find((variant) => variants.has(variant));
+  }
+  async processMessageInternal(request) {
+    const model = request.model ?? DEFAULT_OPENCODE_MODEL;
+    const controller = new AbortController();
+    this.activeAbortController = controller;
+    try {
+      const client = await this.ensureClient(model);
+      const agent = request.planMode ? "plan" : "build";
+      const variant = await this.getThinkingVariant(client, model, request.thinkingLevel);
+      const sessionId = await this.ensureSession(client, model, agent, variant);
+      const system = this.buildCombinedInstructions(request.customInstructions);
+      this.recordHistoryEvent("event_msg", {
+        type: "user_message",
+        message: request.message
+      }, this.historyFile);
+      const result = await client.session.prompt({
+        sessionID: sessionId,
+        directory: this.workingDirectory,
+        agent,
+        model: { providerID: "openrouter", modelID: model },
+        ...variant ? { variant } : {},
+        ...system ? { system } : {},
+        parts: [{ type: "text", text: request.message }]
+      }, { signal: controller.signal, throwOnError: true });
+      this.recordHistoryEvent("opencode-message.updated", { info: result.data.info }, this.historyFile);
+      for (const part of result.data.parts) this.recordOpencodePart(part);
+      this.recordHistoryEvent("opencode-session.idle", { sessionID: sessionId }, this.historyFile);
+    } catch (error) {
+      if (controller.signal.aborted) {
+        this.recordHistoryEvent("opencode-session.idle", { sessionID: this.sessionId }, this.historyFile);
+      } else {
+        console.error("[OpencodeManager] Turn failed:", error);
+        this.recordHistoryEvent("opencode-error", opencodeErrorPayload(error), this.historyFile);
+      }
+    } finally {
+      this.activeAbortController = null;
+      await this.historyFile.flush();
+      await this.onTurnComplete();
+    }
+  }
+  async subscribeToEvents(client, controller) {
+    let streamError;
+    const result = await client.v2.event.subscribe(
+      { location: { directory: this.workingDirectory } },
+      {
+        signal: controller.signal,
+        sseMaxRetryAttempts: 1,
+        onSseError: (error) => {
+          streamError = error;
+        }
+      }
+    );
+    for await (const event of result.stream) {
+      this.resolveEventSubscriptionReady?.();
+      this.resolveEventSubscriptionReady = null;
+      if (isOpencodeRuntimeEvent(event)) {
+        this.recordOpencodeEvent(event);
+      }
+    }
+    this.resolveEventSubscriptionReady?.();
+    this.resolveEventSubscriptionReady = null;
+    if (!controller.signal.aborted && streamError) throw streamError;
+  }
+  recordOpencodeEvent(event) {
+    const payload = opencodeEventPayload(event);
+    if (!payload) return;
+    const sessionID = typeof payload.sessionID === "string" ? payload.sessionID : void 0;
+    const part = payload.part;
+    if (typeof sessionID === "string" && this.sessionId && sessionID !== this.sessionId) return;
+    const partSessionID = isRecord4(part) ? part.sessionID : void 0;
+    if (typeof partSessionID === "string" && this.sessionId && partSessionID !== this.sessionId) return;
+    if (event.type === "message.part.updated" && isOpencodePart(part)) {
+      if (this.shouldRecordOpencodePart(part)) this.recordOpencodePart(part);
+      return;
+    }
+    if (event.type === "message.updated") this.recordOpencodeMessageRole(payload);
+    if (this.recordOpencodeNextPart(event.type, payload)) return;
+    this.recordHistoryEvent(`opencode-${event.type}`, payload, this.historyFile);
+  }
+  recordOpencodeMessageRole(payload) {
+    const info = isRecord4(payload.info) ? payload.info : null;
+    const id = typeof info?.id === "string" ? info.id : void 0;
+    const role = typeof info?.role === "string" ? info.role : void 0;
+    if (!id || !role) return;
+    if (role !== "assistant") this.nonAssistantMessageIds.add(id);
+  }
+  shouldRecordOpencodePart(part) {
+    return !this.nonAssistantMessageIds.has(part.messageID);
+  }
+  recordOpencodeNextPart(type, payload) {
+    const sessionID = typeof payload.sessionID === "string" ? payload.sessionID : void 0;
+    const messageID = typeof payload.assistantMessageID === "string" ? payload.assistantMessageID : void 0;
+    if (!sessionID || !messageID) return false;
+    if (type === "session.next.text.started") {
+      const id = typeof payload.textID === "string" ? payload.textID : void 0;
+      if (!id) return false;
+      this.textParts.set(id, {
+        id,
+        sessionID,
+        messageID,
+        type: "text",
+        text: "",
+        time: { start: timestampMs(payload.timestamp) }
+      });
+      return true;
+    }
+    if (type === "session.next.text.delta" || type === "session.next.text.ended") {
+      const id = typeof payload.textID === "string" ? payload.textID : void 0;
+      if (!id) return false;
+      const part = this.textParts.get(id) ?? {
+        id,
+        sessionID,
+        messageID,
+        type: "text",
+        text: "",
+        time: { start: timestampMs(payload.timestamp) }
+      };
+      part.text = type === "session.next.text.ended" && typeof payload.text === "string" ? payload.text : `${part.text}${typeof payload.delta === "string" ? payload.delta : ""}`;
+      if (type === "session.next.text.ended") {
+        part.time = { start: part.time?.start ?? timestampMs(payload.timestamp), end: timestampMs(payload.timestamp) };
+      }
+      this.textParts.set(id, part);
+      this.recordOpencodePart(part);
+      return true;
+    }
+    if (type === "session.next.reasoning.started") {
+      const id = typeof payload.reasoningID === "string" ? payload.reasoningID : void 0;
+      if (!id) return false;
+      this.reasoningParts.set(id, {
+        id,
+        sessionID,
+        messageID,
+        type: "reasoning",
+        text: "",
+        time: { start: timestampMs(payload.timestamp) }
+      });
+      return true;
+    }
+    if (type === "session.next.reasoning.delta" || type === "session.next.reasoning.ended") {
+      const id = typeof payload.reasoningID === "string" ? payload.reasoningID : void 0;
+      if (!id) return false;
+      const part = this.reasoningParts.get(id) ?? {
+        id,
+        sessionID,
+        messageID,
+        type: "reasoning",
+        text: "",
+        time: { start: timestampMs(payload.timestamp) }
+      };
+      part.text = type === "session.next.reasoning.ended" && typeof payload.text === "string" ? payload.text : `${part.text}${typeof payload.delta === "string" ? payload.delta : ""}`;
+      if (type === "session.next.reasoning.ended") {
+        part.time = { start: part.time.start, end: timestampMs(payload.timestamp) };
+      }
+      this.reasoningParts.set(id, part);
+      this.recordOpencodePart(part);
+      return true;
+    }
+    return false;
+  }
+  recordOpencodePart(part) {
+    this.recordHistoryEvent(`opencode-part-${part.type}`, { part }, this.historyFile);
   }
 };
 
@@ -9401,14 +9839,16 @@ import { z } from "zod";
 function getAvailableRelayProviders(availability) {
   const codexAvailable = availability.codexAvailable ?? false;
   const cursorAvailable = availability.cursorAvailable ?? false;
+  const opencodeAvailable = availability.opencodeAvailable ?? false;
   const providers = ["claude"];
   if (codexAvailable) providers.push("codex");
   if (cursorAvailable) providers.push("cursor");
+  if (opencodeAvailable) providers.push("opencode");
   providers.push("relay");
   return providers;
 }
 function getAvailableCodeProviders(availability) {
-  return getAvailableRelayProviders(availability).filter((provider) => provider === "codex" || provider === "cursor");
+  return getAvailableRelayProviders(availability).filter((provider) => provider === "codex" || provider === "cursor" || provider === "opencode");
 }
 
 // src/managers/relay-tools.ts
@@ -9484,6 +9924,12 @@ async function getChatFinalResponse(chatId) {
         return text;
       }
     }
+    if (event.type === "opencode-part-text") {
+      const part = payload.part;
+      if (part && typeof part.text === "string" && part.text) {
+        return part.text;
+      }
+    }
     if (event.type === "cursor-assistant") {
       const message = payload.message;
       const text = extractTextBlocks(message?.content, "text", "");
@@ -9495,6 +9941,7 @@ async function getChatFinalResponse(chatId) {
 function buildSpawnAgentTool(parentChatId, availability = {}) {
   const codexAvailable = availability.codexAvailable ?? false;
   const cursorAvailable = availability.cursorAvailable ?? false;
+  const opencodeAvailable = availability.opencodeAvailable ?? false;
   const availableProviders = getAvailableRelayProviders(availability);
   const providerEnum = z.enum(availableProviders);
   const codeProviders = getAvailableCodeProviders(availability);
@@ -9519,10 +9966,11 @@ You will also receive the chatId so you can send follow-up messages or clean up
       model: z.string().optional().describe([
         `Model override. Claude: ${AGENT_MODELS.claude.join(", ")} (opus[1m] is the default, 1M context, use for very large codebases or huge context tasks).`,
         codexAvailable ? "Codex: gpt-5.5, gpt-5.4, gpt-5.3-codex, etc." : null,
-        cursorAvailable ? `Cursor: ${AGENT_MODELS.cursor.join(", ")}.` : null
+        cursorAvailable ? `Cursor: ${AGENT_MODELS.cursor.join(", ")}.` : null,
+        opencodeAvailable ? `Opencode: ${AGENT_MODELS.opencode.join(", ")}.` : null
       ].filter(Boolean).join(" ")),
       thinking_level: z.enum(["low", "medium", "high", "max"]).optional().describe(
-        "Controls how much thinking/reasoning the subagent applies. low = light thinking, medium = moderate, high = deep reasoning, max = maximum effort. Defaults: Claude = high, Codex = medium, Cursor = medium."
+        "Controls how much thinking/reasoning the subagent applies. low = light thinking, medium = moderate, high = deep reasoning, max = maximum effort. Defaults: Claude = high, Codex = medium, Cursor = medium, Opencode = medium."
       ),
       title: z.string().optional().describe("Optional title for the subagent chat (for identification)."),
       timeout_minutes: z.number().positive().optional().describe("Timeout in minutes for the subagent to complete (default: 10). Set higher for large tasks to avoid losing work.")
@@ -9590,7 +10038,7 @@ The tool blocks until the subagent completes and returns its response.`,
     message: z.string().describe("The follow-up message to send."),
     model: z.string().optional().describe("Optional model override for this message."),
     thinking_level: z.enum(["low", "medium", "high", "max"]).optional().describe(
-      "Controls how much thinking/reasoning the subagent applies. low = light thinking, medium = moderate, high = deep reasoning, max = maximum effort. Defaults: Claude = high, Codex = medium, Cursor = medium."
+      "Controls how much thinking/reasoning the subagent applies. low = light thinking, medium = moderate, high = deep reasoning, max = maximum effort. Defaults: Claude = high, Codex = medium, Cursor = medium, Opencode = medium."
     ),
     timeout_minutes: z.number().positive().optional().describe("Timeout in minutes for the subagent to complete (default: 10). Set higher for large tasks to avoid losing work.")
   },
@@ -9754,12 +10202,13 @@ function getUsingToolsSection() {
   ];
   return [`# Using your tools`, ...prependBullets(items)].join("\n");
 }
-function getDelegationSection(codexAvailable, cursorAvailable) {
-  const providerList = getAvailableRelayProviders({ codexAvailable, cursorAvailable }).join(", ");
+function getDelegationSection(codexAvailable, cursorAvailable, opencodeAvailable) {
+  const providerList = getAvailableRelayProviders({ codexAvailable, cursorAvailable, opencodeAvailable }).join(", ");
   const spawnDesc = `Create a new subagent with a specific provider (${providerList}), send it a prompt, and wait for its response. Returns the chatId and the agent's final response. You can set a custom timeout via the timeout_minutes parameter (default: 10 minutes).`;
   const claudeModelList = AGENT_MODELS.claude.join(", ");
   const extraAgentLines = [
     codexAvailable ? `Use provider 'codex' for heavy code writing, implementation, and large refactors. Suggested models: gpt-5.5 (default), gpt-5.4, gpt-5.3-codex.` : null,
+    opencodeAvailable ? `Use provider 'opencode' for cheaper routine implementation tasks through OpenRouter-backed open source models. Suggested models: ${AGENT_MODELS.opencode.join(", ")}.` : null,
     cursorAvailable ? `Use provider 'cursor' for fast iteration on code changes. Suggested models: ${AGENT_MODELS.cursor.join(", ")}.` : null
   ].filter(Boolean);
   const agentSelectionLines = extraAgentLines.length > 0 ? `${extraAgentLines.join("\n\n")}
@@ -9882,14 +10331,14 @@ function getEnvironmentSection() {
   ].join("\n");
 }
 function buildRelaySystemPrompt(options) {
-  const { customInstructions, codexAvailable, cursorAvailable } = options ?? {};
+  const { customInstructions, codexAvailable, cursorAvailable, opencodeAvailable } = options ?? {};
   const sections = [
     getIntroSection(),
     getSystemSection(),
     getDoingTasksSection(),
     getActionsSection(),
     getUsingToolsSection(),
-    getDelegationSection(codexAvailable ?? false, cursorAvailable ?? false),
+    getDelegationSection(codexAvailable ?? false, cursorAvailable ?? false, opencodeAvailable ?? false),
     getToneAndStyleSection(),
     getOutputEfficiencySection(),
     getEnvironmentSection(),
@@ -9921,12 +10370,13 @@ var RelayManager = class {
   constructor(options) {
     const codexAvailable = options.codexAvailable ?? false;
     const cursorAvailable = options.cursorAvailable ?? false;
+    const opencodeAvailable = options.opencodeAvailable ?? false;
     this.inner = new ClaudeManager({
       ...options,
-      systemPromptOverride: (customInstructions) => buildRelaySystemPrompt({ customInstructions, codexAvailable, cursorAvailable }),
+      systemPromptOverride: (customInstructions) => buildRelaySystemPrompt({ customInstructions, codexAvailable, cursorAvailable, opencodeAvailable }),
       tools: RELAY_TOOLS,
       mcpServers: {
-        "relay-subagent-tools": createRelayMcpServer(options.chatId, { codexAvailable, cursorAvailable })
+        "relay-subagent-tools": createRelayMcpServer(options.chatId, { codexAvailable, cursorAvailable, opencodeAvailable })
       },
       envOverrides: {
         CLAUDE_CODE_STREAM_CLOSE_TIMEOUT: "900000"
@@ -10002,12 +10452,12 @@ var KeepAliveService = class _KeepAliveService {
 var keepAliveService = new KeepAliveService();
 
 // src/services/canvas-service.ts
-import { readdir as readdir4, readFile as readFile10, stat as stat3 } from "fs/promises";
+import { readdir as readdir4, readFile as readFile11, stat as stat3 } from "fs/promises";
 import { homedir as homedir12 } from "os";
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 var CANVAS_DIRECTORIES = [
-  join16(homedir12(), ".claude", "plans"),
-  join16(homedir12(), ".replicas", "canvas")
+  join17(homedir12(), ".claude", "plans"),
+  join17(homedir12(), ".replicas", "canvas")
 ];
 var CanvasService = class {
   async listItems() {
@@ -10026,7 +10476,7 @@ var CanvasService = class {
         const { kind } = classifyCanvasFilename(entry.name);
         let sizeBytes = 0;
         try {
-          const s = await stat3(join16(directory, entry.name));
+          const s = await stat3(join17(directory, entry.name));
           sizeBytes = s.size;
         } catch {
           continue;
@@ -10041,7 +10491,7 @@ var CanvasService = class {
     if (!safe) return null;
     const { kind, mimeType } = classifyCanvasFilename(safe);
     for (const directory of CANVAS_DIRECTORIES) {
-      const filePath = join16(directory, safe);
+      const filePath = join17(directory, safe);
       let sizeBytes = 0;
       let updatedAt = "";
       try {
@@ -10062,7 +10512,7 @@ var CanvasService = class {
         };
       }
       try {
-        const bytes = await readFile10(filePath);
+        const bytes = await readFile11(filePath);
         return { filename: safe, kind, sizeBytes, mimeType, updatedAt, bytes };
       } catch {
         continue;
@@ -10177,14 +10627,14 @@ async function reconcileCanvasItems(filenames) {
 }
 
 // src/services/upload-chat-transcripts.ts
-import { readdir as readdir5, readFile as readFile11 } from "fs/promises";
-import { basename, join as join17 } from "path";
+import { readdir as readdir5, readFile as readFile12 } from "fs/promises";
+import { basename, join as join18 } from "path";
 import { homedir as homedir13 } from "os";
-var ENGINE_DIR2 = join17(homedir13(), ".replicas", "engine");
+var ENGINE_DIR2 = join18(homedir13(), ".replicas", "engine");
 var HISTORY_DIRS = [
-  join17(ENGINE_DIR2, "claude-histories"),
-  join17(ENGINE_DIR2, "relay-histories"),
-  join17(ENGINE_DIR2, "codex-histories")
+  join18(ENGINE_DIR2, "claude-histories"),
+  join18(ENGINE_DIR2, "relay-histories"),
+  join18(ENGINE_DIR2, "codex-histories")
 ];
 async function flushAllChatTranscripts(chatsById = /* @__PURE__ */ new Map()) {
   let flushed = 0;
@@ -10201,7 +10651,7 @@ async function flushAllChatTranscripts(chatsById = /* @__PURE__ */ new Map()) {
       if (!entry.endsWith(".jsonl")) continue;
       const chatId = basename(entry, ".jsonl");
       tasks.push(
-        uploadChatTranscript(chatId, join17(dir, entry), chatsById.get(chatId)).then(() => {
+        uploadChatTranscript(chatId, join18(dir, entry), chatsById.get(chatId)).then(() => {
           flushed++;
         }).catch((err) => {
           failed++;
@@ -10214,7 +10664,7 @@ async function flushAllChatTranscripts(chatsById = /* @__PURE__ */ new Map()) {
   return { flushed, failed };
 }
 async function uploadChatTranscript(chatId, filePath, chat) {
-  const bytes = await readFile11(filePath);
+  const bytes = await readFile12(filePath);
   if (bytes.byteLength === 0) return;
   const form = new FormData();
   form.append("chat_id", chatId);
@@ -10271,20 +10721,23 @@ var DuplicateDefaultChatError = class extends Error {
 };
 
 // src/services/chat/chat-service.ts
-var ENGINE_DIR3 = join18(homedir14(), ".replicas", "engine");
-var CHATS_FILE = join18(ENGINE_DIR3, "chats.json");
-var CLAUDE_HISTORY_DIR = join18(ENGINE_DIR3, "claude-histories");
-var RELAY_HISTORY_DIR = join18(ENGINE_DIR3, "relay-histories");
-var CODEX_HISTORY_DIR = join18(ENGINE_DIR3, "codex-histories");
-var CURSOR_HISTORY_DIR = join18(ENGINE_DIR3, "cursor-histories");
+var ENGINE_DIR3 = join19(homedir14(), ".replicas", "engine");
+var CHATS_FILE = join19(ENGINE_DIR3, "chats.json");
+var CLAUDE_HISTORY_DIR = join19(ENGINE_DIR3, "claude-histories");
+var RELAY_HISTORY_DIR = join19(ENGINE_DIR3, "relay-histories");
+var CODEX_HISTORY_DIR = join19(ENGINE_DIR3, "codex-histories");
+var CURSOR_HISTORY_DIR = join19(ENGINE_DIR3, "cursor-histories");
+var OPENCODE_HISTORY_DIR = join19(ENGINE_DIR3, "opencode-histories");
 var HISTORY_DIR_BY_PROVIDER = {
   claude: CLAUDE_HISTORY_DIR,
   relay: RELAY_HISTORY_DIR,
   codex: CODEX_HISTORY_DIR,
-  cursor: CURSOR_HISTORY_DIR
+  cursor: CURSOR_HISTORY_DIR,
+  opencode: OPENCODE_HISTORY_DIR
 };
-var CHAT_SENDERS_DIR = join18(ENGINE_DIR3, "chat-senders");
-var CODEX_AUTH_PATH2 = join18(homedir14(), ".codex", "auth.json");
+var CHAT_SENDERS_DIR = join19(ENGINE_DIR3, "chat-senders");
+var CODEX_AUTH_PATH2 = join19(homedir14(), ".codex", "auth.json");
+var OPENCODE_AUTH_PATH2 = join19(homedir14(), ".local", "share", "opencode", "auth.json");
 var CHATS_BACKUP_FILE = `${CHATS_FILE}.bak`;
 function isChatMessageSender(value) {
   if (!isRecord4(value)) return false;
@@ -10293,6 +10746,9 @@ function isChatMessageSender(value) {
 function isCodexAvailable() {
   return existsSync7(CODEX_AUTH_PATH2) || Boolean(ENGINE_ENV.OPENAI_API_KEY);
 }
+function isOpencodeAvailable() {
+  return existsSync7(OPENCODE_AUTH_PATH2) || Boolean(ENGINE_ENV.OPENROUTER_API_KEY);
+}
 function isCursorAvailable() {
   return Boolean(ENGINE_ENV.CURSOR_API_KEY);
 }
@@ -10337,7 +10793,7 @@ function isPersistedChat(value) {
     return false;
   }
   const candidate = value;
-  return typeof candidate.id === "string" && (candidate.provider === "claude" || candidate.provider === "codex" || candidate.provider === "cursor" || candidate.provider === "relay") && typeof candidate.title === "string" && typeof candidate.createdAt === "string" && typeof candidate.updatedAt === "string" && (candidate.providerSessionId === null || typeof candidate.providerSessionId === "string") && (candidate.parentChatId === void 0 || candidate.parentChatId === null || typeof candidate.parentChatId === "string");
+  return typeof candidate.id === "string" && (candidate.provider === "claude" || candidate.provider === "codex" || candidate.provider === "cursor" || candidate.provider === "opencode" || candidate.provider === "relay") && typeof candidate.title === "string" && typeof candidate.createdAt === "string" && typeof candidate.updatedAt === "string" && (candidate.providerSessionId === null || typeof candidate.providerSessionId === "string") && (candidate.parentChatId === void 0 || candidate.parentChatId === null || typeof candidate.parentChatId === "string");
 }
 function normalizePersistedChat(chat) {
   const isLegacyCodexSdkChat = chat.provider === "codex" && (chat.codexBackend === "sdk" || chat.codexBackend === void 0 && chat.providerSessionId !== null);
@@ -10385,12 +10841,13 @@ var ChatService = class {
   persistInFlight = false;
   persistQueued = false;
   async initialize() {
-    await mkdir12(ENGINE_DIR3, { recursive: true });
-    await mkdir12(CLAUDE_HISTORY_DIR, { recursive: true });
-    await mkdir12(RELAY_HISTORY_DIR, { recursive: true });
-    await mkdir12(CODEX_HISTORY_DIR, { recursive: true });
-    await mkdir12(CURSOR_HISTORY_DIR, { recursive: true });
-    await mkdir12(CHAT_SENDERS_DIR, { recursive: true });
+    await mkdir13(ENGINE_DIR3, { recursive: true });
+    await mkdir13(CLAUDE_HISTORY_DIR, { recursive: true });
+    await mkdir13(RELAY_HISTORY_DIR, { recursive: true });
+    await mkdir13(CODEX_HISTORY_DIR, { recursive: true });
+    await mkdir13(CURSOR_HISTORY_DIR, { recursive: true });
+    await mkdir13(OPENCODE_HISTORY_DIR, { recursive: true });
+    await mkdir13(CHAT_SENDERS_DIR, { recursive: true });
     const persisted = await this.loadChats();
     for (const chat of persisted) {
       const runtime = this.createRuntimeChat(chat);
@@ -10405,6 +10862,9 @@ var ChatService = class {
     const hasCursorDefault = [...this.chats.values()].some(
       (c) => c.persisted.provider === "cursor" && c.persisted.title === "Cursor"
     );
+    const hasOpencodeDefault = [...this.chats.values()].some(
+      (c) => c.persisted.provider === "opencode" && c.persisted.title === "Opencode"
+    );
     if (!hasClaudeDefault) {
       await this.createChat({ provider: "claude", title: "Claude Code" });
     }
@@ -10414,6 +10874,9 @@ var ChatService = class {
     if (!hasCursorDefault) {
       await this.createChat({ provider: "cursor", title: "Cursor" });
     }
+    if (!hasOpencodeDefault) {
+      await this.createChat({ provider: "opencode", title: "Opencode" });
+    }
     const hasRelayDefault = [...this.chats.values()].some(
       (c) => c.persisted.provider === "relay" && c.persisted.title === "Relay"
     );
@@ -10495,7 +10958,7 @@ var ChatService = class {
     };
   }
   senderFilePath(chatId) {
-    return join18(CHAT_SENDERS_DIR, `${chatId}.jsonl`);
+    return join19(CHAT_SENDERS_DIR, `${chatId}.jsonl`);
   }
   async appendSender(chatId, sender) {
     try {
@@ -10506,7 +10969,7 @@ var ChatService = class {
   }
   async readSenders(chatId) {
     try {
-      const content = await readFile12(this.senderFilePath(chatId), "utf-8");
+      const content = await readFile13(this.senderFilePath(chatId), "utf-8");
       const lines = content.split("\n").filter((line) => line.trim().length > 0);
       const senders = [];
       for (const line of lines) {
@@ -10651,7 +11114,7 @@ var ChatService = class {
     return descendants;
   }
   async deleteHistoryFile(persisted) {
-    await rm(join18(HISTORY_DIR_BY_PROVIDER[persisted.provider], `${persisted.id}.jsonl`), { force: true });
+    await rm(join19(HISTORY_DIR_BY_PROVIDER[persisted.provider], `${persisted.id}.jsonl`), { force: true });
     await rm(this.senderFilePath(persisted.id), { force: true });
   }
   async getChatHistory(chatId) {
@@ -10722,7 +11185,7 @@ var ChatService = class {
     if (persisted.provider === "claude") {
       provider = new ClaudeManager({
         workingDirectory: this.workingDirectory,
-        historyFilePath: join18(CLAUDE_HISTORY_DIR, `${persisted.id}.jsonl`),
+        historyFilePath: join19(CLAUDE_HISTORY_DIR, `${persisted.id}.jsonl`),
         initialSessionId: persisted.providerSessionId,
         onSaveSessionId: saveSession,
         onTurnComplete: onProviderTurnComplete,
@@ -10731,19 +11194,29 @@ var ChatService = class {
     } else if (persisted.provider === "relay") {
       provider = new RelayManager({
         workingDirectory: this.workingDirectory,
-        historyFilePath: join18(RELAY_HISTORY_DIR, `${persisted.id}.jsonl`),
+        historyFilePath: join19(RELAY_HISTORY_DIR, `${persisted.id}.jsonl`),
         initialSessionId: persisted.providerSessionId,
         onSaveSessionId: saveSession,
         onTurnComplete: onProviderTurnComplete,
         onEvent: onProviderEvent,
         chatId: persisted.id,
         codexAvailable: isCodexAvailable(),
+        opencodeAvailable: isOpencodeAvailable(),
         cursorAvailable: isCursorAvailable()
       });
     } else if (persisted.provider === "cursor") {
       provider = new CursorManager({
         workingDirectory: this.workingDirectory,
-        historyFilePath: join18(CURSOR_HISTORY_DIR, `${persisted.id}.jsonl`),
+        historyFilePath: join19(CURSOR_HISTORY_DIR, `${persisted.id}.jsonl`),
+        initialSessionId: persisted.providerSessionId,
+        onSaveSessionId: saveSession,
+        onTurnComplete: onProviderTurnComplete,
+        onEvent: onProviderEvent
+      });
+    } else if (persisted.provider === "opencode") {
+      provider = new OpencodeManager({
+        workingDirectory: this.workingDirectory,
+        historyFilePath: join19(OPENCODE_HISTORY_DIR, `${persisted.id}.jsonl`),
         initialSessionId: persisted.providerSessionId,
         onSaveSessionId: saveSession,
         onTurnComplete: onProviderTurnComplete,
@@ -10752,7 +11225,7 @@ var ChatService = class {
     } else {
       provider = new CodexAspManager({
         workingDirectory: this.workingDirectory,
-        historyFilePath: join18(CODEX_HISTORY_DIR, `${persisted.id}.jsonl`),
+        historyFilePath: join19(CODEX_HISTORY_DIR, `${persisted.id}.jsonl`),
         initialSessionId: persisted.providerSessionId,
         onSaveSessionId: saveSession,
         onTurnComplete: onProviderTurnComplete,
@@ -10891,7 +11364,7 @@ var ChatService = class {
     });
     uploadChatTranscript(
       chatId,
-      join18(HISTORY_DIR_BY_PROVIDER[chat.persisted.provider], `${chatId}.jsonl`),
+      join19(HISTORY_DIR_BY_PROVIDER[chat.persisted.provider], `${chatId}.jsonl`),
       this.toSummary(chat)
     ).catch((err) => {
       console.error("[ChatService] Failed to upload chat transcript:", { chatId, err });
@@ -10906,7 +11379,7 @@ var ChatService = class {
   }
   async loadChats() {
     try {
-      const content = await readFile12(CHATS_FILE, "utf-8");
+      const content = await readFile13(CHATS_FILE, "utf-8");
       return parsePersistedChatsContent(content);
     } catch (error) {
       if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
@@ -10921,7 +11394,7 @@ var ChatService = class {
         console.error("[ChatService] Failed to quarantine corrupt chats file:", renameError);
       }
       try {
-        const backupContent = await readFile12(CHATS_BACKUP_FILE, "utf-8");
+        const backupContent = await readFile13(CHATS_BACKUP_FILE, "utf-8");
         return parsePersistedChatsContent(backupContent);
       } catch (backupError) {
         if (backupError && typeof backupError === "object" && "code" in backupError && backupError.code === "ENOENT") {
@@ -11008,8 +11481,8 @@ var ChatService = class {
 
 // src/services/repo-file-service.ts
 import { execFile as execFile2 } from "child_process";
-import { readFile as readFile13, realpath, stat as stat4 } from "fs/promises";
-import { join as join19, resolve as resolve2, extname } from "path";
+import { readFile as readFile14, realpath, stat as stat4 } from "fs/promises";
+import { join as join20, resolve as resolve2, extname } from "path";
 var CACHE_TTL_MS = 3e4;
 var SEARCH_TIMEOUT_MS = 15e3;
 var MAX_CONTENT_BYTES = 256 * 1024;
@@ -11169,7 +11642,7 @@ var RepoFileService = class {
     const repo = repos.find((r) => r.name === repoName);
     if (!repo) return null;
     try {
-      const fullPath = await realpath(resolve2(join19(repo.path, filePath)));
+      const fullPath = await realpath(resolve2(join20(repo.path, filePath)));
       const repoRoot = await realpath(repo.path);
       const repoPrefix = repoRoot.endsWith("/") ? repoRoot : repoRoot + "/";
       if (!fullPath.startsWith(repoPrefix) && fullPath !== repoRoot) return null;
@@ -11198,7 +11671,7 @@ var RepoFileService = class {
           tooLarge: true
         };
       }
-      const content = await readFile13(fullPath, "utf-8");
+      const content = await readFile14(fullPath, "utf-8");
       return {
         repoName,
         path: filePath,
@@ -11276,21 +11749,21 @@ var RepoFileService = class {
 // src/v1-routes.ts
 import { Hono } from "hono";
 import { z as z2 } from "zod";
-import { readdir as readdir7, stat as stat5, readFile as readFile16 } from "fs/promises";
-import { join as join22, resolve as resolve3 } from "path";
+import { readdir as readdir7, stat as stat5, readFile as readFile17 } from "fs/promises";
+import { join as join23, resolve as resolve3 } from "path";
 
 // src/services/warm-hooks-service.ts
 import { spawn as spawn4 } from "child_process";
-import { readFile as readFile15 } from "fs/promises";
+import { readFile as readFile16 } from "fs/promises";
 import { existsSync as existsSync8 } from "fs";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 
 // src/services/warm-hook-logs-service.ts
-import { mkdir as mkdir13, readFile as readFile14, writeFile as writeFile6, readdir as readdir6, appendFile as appendFile4, unlink as unlink3 } from "fs/promises";
+import { mkdir as mkdir14, readFile as readFile15, writeFile as writeFile6, readdir as readdir6, appendFile as appendFile4, unlink as unlink3 } from "fs/promises";
 import { homedir as homedir15 } from "os";
-import { join as join20 } from "path";
-var LOGS_DIR2 = join20(homedir15(), ".replicas", "warm-hook-logs");
-var CURRENT_RUN_LOG = join20(LOGS_DIR2, "current-run.log");
+import { join as join21 } from "path";
+var LOGS_DIR2 = join21(homedir15(), ".replicas", "warm-hook-logs");
+var CURRENT_RUN_LOG = join21(LOGS_DIR2, "current-run.log");
 var GLOBAL_FILENAME = "global.json";
 function withPreview2(stored) {
   const preview = buildHookOutputPreview(stored.output);
@@ -11298,7 +11771,7 @@ function withPreview2(stored) {
 }
 var WarmHookLogsService = class {
   async ensureDir() {
-    await mkdir13(LOGS_DIR2, { recursive: true });
+    await mkdir14(LOGS_DIR2, { recursive: true });
   }
   async saveGlobalHookLog(entry) {
     await this.ensureDir();
@@ -11307,7 +11780,7 @@ var WarmHookLogsService = class {
       hookName: "organization",
       ...entry
     };
-    await writeFile6(join20(LOGS_DIR2, GLOBAL_FILENAME), `${JSON.stringify(log, null, 2)}
+    await writeFile6(join21(LOGS_DIR2, GLOBAL_FILENAME), `${JSON.stringify(log, null, 2)}
 `, "utf-8");
   }
   async saveEnvironmentHookLog(entry) {
@@ -11317,7 +11790,7 @@ var WarmHookLogsService = class {
       hookName: "environment",
       ...entry
     };
-    await writeFile6(join20(LOGS_DIR2, ENVIRONMENT_HOOK_LOG_FILENAME), `${JSON.stringify(log, null, 2)}
+    await writeFile6(join21(LOGS_DIR2, ENVIRONMENT_HOOK_LOG_FILENAME), `${JSON.stringify(log, null, 2)}
 `, "utf-8");
   }
   async saveRepoHookLog(repoName, entry) {
@@ -11327,7 +11800,7 @@ var WarmHookLogsService = class {
       hookName: repoName,
       ...entry
     };
-    await writeFile6(join20(LOGS_DIR2, repoHookLogFilename(repoName)), `${JSON.stringify(log, null, 2)}
+    await writeFile6(join21(LOGS_DIR2, repoHookLogFilename(repoName)), `${JSON.stringify(log, null, 2)}
 `, "utf-8");
   }
   async getAllLogs() {
@@ -11346,7 +11819,7 @@ var WarmHookLogsService = class {
         continue;
       }
       try {
-        const raw = await readFile14(join20(LOGS_DIR2, file), "utf-8");
+        const raw = await readFile15(join21(LOGS_DIR2, file), "utf-8");
         const stored = JSON.parse(raw);
         logs.push(withPreview2(stored));
       } catch {
@@ -11375,7 +11848,7 @@ var WarmHookLogsService = class {
   }
   async getCurrentRunLog() {
     try {
-      return await readFile14(CURRENT_RUN_LOG, "utf-8");
+      return await readFile15(CURRENT_RUN_LOG, "utf-8");
     } catch (err) {
       if (err.code === "ENOENT") return null;
       throw err;
@@ -11384,7 +11857,7 @@ var WarmHookLogsService = class {
   async getFullOutput(hookType, hookName) {
     const filename = hookType === "global" ? GLOBAL_FILENAME : hookType === "environment" ? ENVIRONMENT_HOOK_LOG_FILENAME : repoHookLogFilename(hookName);
     try {
-      const raw = await readFile14(join20(LOGS_DIR2, filename), "utf-8");
+      const raw = await readFile15(join21(LOGS_DIR2, filename), "utf-8");
       const stored = JSON.parse(raw);
       if (stored.hookType !== hookType || stored.hookName !== hookName) {
         return null;
@@ -11403,12 +11876,12 @@ var warmHookLogsService = new WarmHookLogsService();
 // src/services/warm-hooks-service.ts
 async function readRepoWarmHook(repoPath) {
   for (const filename of REPLICAS_CONFIG_FILENAMES) {
-    const configPath = join21(repoPath, filename);
+    const configPath = join22(repoPath, filename);
     if (!existsSync8(configPath)) {
       continue;
     }
     try {
-      const raw = await readFile15(configPath, "utf-8");
+      const raw = await readFile16(configPath, "utf-8");
       const config = parseReplicasConfigString(raw, filename);
       if (!config.warmHook) {
         return null;
@@ -11668,7 +12141,7 @@ var setWorkspaceNameSchema = z2.object({
   name: z2.string().min(1).max(48)
 });
 var createChatSchema = z2.object({
-  provider: z2.enum(["claude", "codex", "cursor", "relay"]),
+  provider: z2.enum(["claude", "codex", "cursor", "opencode", "relay"]),
   title: z2.string().min(1).optional(),
   parentChatId: z2.string().uuid().optional()
 });
@@ -12358,7 +12831,7 @@ function createV1Routes(deps) {
       const logFiles = files.filter((f) => f.endsWith(".log"));
       const sessions = await Promise.all(
         logFiles.map(async (filename) => {
-          const filePath = join22(LOG_DIR, filename);
+          const filePath = join23(LOG_DIR, filename);
           const fileStat = await stat5(filePath);
           const sessionId = filename.replace(/\.log$/, "");
           return {
@@ -12395,7 +12868,7 @@ function createV1Routes(deps) {
       const limit = Math.min(parseInt(c.req.query("limit") || "500", 10), 5e3);
       let content;
       try {
-        content = await readFile16(filePath, "utf-8");
+        content = await readFile17(filePath, "utf-8");
       } catch {
         return c.json(jsonError("Log session not found"), 404);
       }