@bivy/bivy 0.7.0 → 0.8.0

package/bin/acp-shim.mjs

@@ -57,45 +57,112 @@ function bivy(obj) {
 // --- ACP agent (child JSON-RPC over its stdio) ------------------------------
 const agent = spawn(agentCmd, agentArgs, { stdio: ["pipe", "pipe", "pipe"] });
 agent.stderr.on("data", (d) => process.stderr.write(`[acp-agent] ${d}`));
-agent.on("error", (e) => bivy({ type: "session.error", error: `acp agent spawn failed: ${e.message}` }));
-agent.on("exit", (code) => {
-  if (code && code !== 0) bivy({ type: "session.error", error: `acp agent exited (${code})` });
-});
-
 let nextId = 1;
 const pending = new Map(); // jsonrpc id -> {resolve, reject}
-function agentRequest(method, params) {
+let agentDead = null; // set to an Error once the child is gone
+
+/**
+ * The child is gone (spawn failure or exit). Every in-flight request must be
+ * rejected: without this, a CLI whose ACP mode doesn't exist leaves `initialize`
+ * pending forever and the daemon waits out its whole session.create timeout instead
+ * of surfacing the real reason. Fail fast, with the reason.
+ */
+function killPending(reason) {
+  if (agentDead) return;
+  agentDead = reason instanceof Error ? reason : new Error(String(reason));
+  bivy({ type: "session.error", error: agentDead.message });
+  for (const [id, p] of [...pending]) { pending.delete(id); p.reject(agentDead); }
+}
+agent.on("error", (e) => killPending(`acp agent spawn failed: ${e.message}`));
+agent.on("exit", (code, signal) => {
+  if (code || signal) killPending(`acp agent exited (${code ?? signal})`);
+});
+// Writing to a dead child's stdin raises EPIPE; with no listener that's an uncaught
+// exception that takes the shim down mid-turn instead of reporting the cause.
+agent.stdin.on("error", (e) => killPending(`acp agent stdin closed: ${e.message}`));
+
+function agentWrite(payload) {
+  if (agentDead) throw agentDead;
+  agent.stdin.write(`${JSON.stringify(payload)}\n`);
+}
+function agentRequest(method, params, { timeoutMs } = {}) {
   const id = nextId++;
-  agent.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}\n`);
-  return new Promise((resolve, reject) => pending.set(id, { resolve, reject }));
+  return new Promise((resolve, reject) => {
+    let timer;
+    pending.set(id, {
+      resolve: (v) => { clearTimeout(timer); resolve(v); },
+      reject: (e) => { clearTimeout(timer); reject(e); },
+    });
+    if (timeoutMs) {
+      timer = setTimeout(() => {
+        if (pending.delete(id)) reject(new Error(`acp ${method} timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+    }
+    try { agentWrite({ jsonrpc: "2.0", id, method, params }); }
+    catch (e) { clearTimeout(timer); pending.delete(id); reject(e); }
+  });
 }
 function agentReply(id, result) {
-  agent.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, result })}\n`);
+  try { agentWrite({ jsonrpc: "2.0", id, result }); } catch { /* child gone; killPending already reported it */ }
 }
 function agentReplyError(id, code, message) {
-  agent.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, error: { code, message } })}\n`);
+  try { agentWrite({ jsonrpc: "2.0", id, error: { code, message } }); } catch { /* child gone */ }
 }
 function agentNotify(method, params) {
-  agent.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method, params })}\n`);
+  try { agentWrite({ jsonrpc: "2.0", method, params }); } catch { /* child gone */ }
 }
 
 // --- session state ----------------------------------------------------------
 let sessionId = null;
 let cwd = process.cwd();
 let initialized = false;
+// The ACP config-option id that selects the model (usually "model"), learned from
+// session/new; used for the session/set_config_option fallback.
+let modelConfigId = "model";
+// A model chosen before the ACP session existed, applied once it does.
+let pendingModel = null;
 // toolCallId -> { requestId, options } so a later bivy tool.decision answers the
 // right ACP permission request with a concrete optionId.
 const permissionRequests = new Map();
 
 async function ensureInitialized() {
   if (initialized) return;
+  // Bounded: a binary that accepts the launch args but never speaks ACP would
+  // otherwise hang here until the daemon's own session timeout, hiding the cause.
   await agentRequest("initialize", {
     protocolVersion: 1,
     clientCapabilities: { fs: { readTextFile: true, writeTextFile: true } },
-  });
+  }, { timeoutMs: 20_000 });
   initialized = true;
 }
 
+/**
+ * ACP exposes a session's selectable models as a `select` config option on the
+ * session/new|load result (opencode: `configOptions: [{id:"model", currentValue,
+ * options:[{value,name}]}]`). Models are per-NODE — they depend on which providers
+ * the user has authenticated in the agent — so a hardcoded list would offer models
+ * the agent rejects. Publish what the agent actually reports, as a post-hello
+ * `runtime.models` event ProtocolRuntime folds into its picker.
+ */
+function publishModels(result) {
+  const options = Array.isArray(result?.configOptions) ? result.configOptions : [];
+  const modelOption = options.find((o) => String(o?.id ?? "") === "model" || String(o?.category ?? "") === "model");
+  const choices = Array.isArray(modelOption?.options) ? modelOption.options : [];
+  const models = choices
+    .map((o) => ({ id: String(o?.value ?? ""), name: String(o?.name ?? o?.value ?? "") }))
+    .filter((m) => m.id)
+    // ACP model ids are `provider/model`; split the provider so Bivy can group and
+    // scope provider-specific settings the same way it does for other runtimes.
+    .map((m) => ({ ...m, provider: m.id.includes("/") ? m.id.split("/")[0] : "agent" }));
+  if (!models.length) return;
+  modelConfigId = String(modelOption?.id ?? "model");
+  bivy({
+    type: "runtime.models",
+    models,
+    ...(modelOption?.currentValue ? { currentModel: String(modelOption.currentValue) } : {}),
+  });
+}
+
 // --- ACP → bivy: streamed session/update notifications ----------------------
 function onSessionUpdate(params) {
   const u = params?.update;
@@ -211,6 +278,33 @@ createInterface({ input: agent.stdout }).on("line", (line) => {
   if (msg.method === "session/update") onSessionUpdate(msg.params);
 });
 
+/**
+ * Select a model on the live ACP session. `session/set_model` is the direct form;
+ * agents that only expose the generic config-option surface take the same choice as
+ * `session/set_config_option`. A rejection propagates: ProtocolRuntime only commits
+ * the selection once we ack, so a model the agent won't accept must not look applied.
+ */
+async function setAgentModel(model) {
+  try {
+    await agentRequest("session/set_model", { sessionId, modelId: model }, { timeoutMs: 15_000 });
+  } catch (primary) {
+    try {
+      await agentRequest("session/set_config_option", { sessionId, configId: modelConfigId, value: model }, { timeoutMs: 15_000 });
+    } catch {
+      throw primary;
+    }
+  }
+}
+
+async function applyPendingModel() {
+  if (!pendingModel || !sessionId) return;
+  const model = pendingModel;
+  pendingModel = null;
+  // Best-effort: a stale pick shouldn't block the session from opening.
+  try { await setAgentModel(model); }
+  catch (e) { bivy({ type: "runtime.debug", message: `acp set_model failed: ${e instanceof Error ? e.message : String(e)}` }); }
+}
+
 // --- bivy commands in (daemon → us) -----------------------------------------
 async function onBivyCommand(msg) {
   const type = String(msg.type || "");
@@ -224,6 +318,8 @@ async function onBivyCommand(msg) {
         cwd = String(msg.cwd || msg.workspace || cwd);
         const res = await agentRequest("session/new", { cwd, mcpServers: [] });
         sessionId = res?.sessionId ?? res?.session?.id ?? null;
+        publishModels(res);
+        await applyPendingModel();
         bivy({ replyTo: id, ok: true, runtimeSessionRef: sessionId });
         return;
       }
@@ -235,11 +331,14 @@ async function onBivyCommand(msg) {
         try {
           const res = await agentRequest("session/load", { sessionId: ref, cwd, mcpServers: [] });
           sessionId = res?.sessionId ?? ref;
+          publishModels(res);
         } catch {
           // Agent doesn't support session/load — start fresh so the chat still opens.
           const res = await agentRequest("session/new", { cwd, mcpServers: [] });
           sessionId = res?.sessionId ?? null;
+          publishModels(res);
         }
+        await applyPendingModel();
         bivy({ replyTo: id, ok: true, runtimeSessionRef: sessionId });
         return;
       }
@@ -270,6 +369,19 @@ async function onBivyCommand(msg) {
         }
         return;
       }
+      case "model.set": {
+        const model = String(msg.model ?? "").trim();
+        if (!model) { bivy({ replyTo: id, ok: true }); return; }
+        if (!sessionId) {
+          // Chosen before the session exists — remember and apply at session/new.
+          pendingModel = model;
+          bivy({ replyTo: id, ok: true });
+          return;
+        }
+        await setAgentModel(model);
+        bivy({ replyTo: id, ok: true });
+        return;
+      }
       case "session.abort": {
         if (sessionId) agentNotify("session/cancel", { sessionId });
         if (id !== undefined) bivy({ replyTo: id, ok: true });
@@ -286,8 +398,10 @@ async function onBivyCommand(msg) {
 }
 
 // Announce capabilities: ACP agents are governed (per-tool permission) and
-// resumable (session/load). Models aren't part of the core ACP surface, so we
-// don't advertise a picker we can't drive.
+// resumable (session/load). modelSelection starts FALSE and is upgraded later by a
+// `runtime.models` event if the session reports selectable models — the list is
+// per-node (it depends on the providers the user has authenticated in the agent)
+// and only arrives with session/new, so claiming a picker here would be a guess.
 bivy({ type: "hello", runtime: { capabilities: { toolInterception: true, modelSelection: false, resume: true } } });
 
 createInterface({ input: process.stdin }).on("line", (line) => {

package/bin/agent-manifest.json

@@ -20,8 +20,9 @@
       "label": "OpenCode",
       "command": "opencode",
       "hidden": false,
-      "supportTier": "beta",
-      "certification": "adapter-tested",
+      "supportTier": "supported",
+      "certification": "release-tested",
+      "testedVersion": "1.18.13",
       "headlessFlags": [
         "run",
         "-s"

package/bin/bivy.mjs

@@ -3343,9 +3343,11 @@ async function cmdSetup(args = []) {
   console.log(`  ${agentReady ? c.green("✓") : c.yellow("!")} runtime ${agentReady ? `${setupAgent?.label || "Pi"} available` : "not installed — run 'bivy agents:install'"}`);
   console.log(`  ${modelReady ? (setupAgent?.needsBivyModel ? c.green("✓") : c.dim("○")) : c.yellow("!")} model ${modelReady ? (setupAgent?.needsBivyModel ? "credential configured" : "agent-managed — verified by the first task") : "not configured — run 'bivy login'"}`);
   console.log(`  ${c.dim("○")} repository chosen from the directory where you start Bivy`);
+  const ghReady = githubConnected(finalConfig);
+  console.log(`  ${ghReady ? c.green("✓") : c.dim("○")} GitHub ${ghReady ? "connected — your repos will list in the app" : c.dim("not connected — 'bivy github:connect' to list repos (optional)")}`);
   console.log(`  ${agentReady && modelReady ? c.green("✓") : c.yellow("!")} first task ${agentReady && modelReady ? "ready to try" : "blocked by the stage above"}`);
   console.log(`  ${fs.existsSync(relayConfigPath) ? c.green("✓") : c.yellow("!")} remote ${fs.existsSync(relayConfigPath) ? "configured" : "not configured — run 'bivy relay:setup'"}\n`);
-  printFirstRunSteps(modelReady);
+  printFirstRunSteps(modelReady, finalConfig);
   await finishSetupRemote(finalConfig, setupSession);
 }
 
@@ -3433,10 +3435,29 @@ async function openRemoteApp(config, { setupSession = null, open = true } = {})
   return { relay, remoteBase, accountUrl, pairedUrl, openUrl };
 }
 
-function printFirstRunSteps(modelReady = false) {
+// Whether GitHub is connected for repo listing/cloning. Bivy's own connect flow
+// (`bivy github:connect`, or the app's Connect button) writes BIVY_GITHUB_TOKEN
+// — usually a `secret://` vault reference — into cli.json's env; an explicit env
+// token counts too. A `gh auth login` session also works at runtime (the node
+// falls back to `gh auth token`), but that can't be known without shelling out,
+// so it's treated as "not connected here" — the hint is optional either way.
+function githubConnected(config = null) {
+  const token = String(
+    config?.env?.BIVY_GITHUB_TOKEN || process.env.BIVY_GITHUB_TOKEN || process.env.GITHUB_TOKEN || "",
+  ).trim();
+  return Boolean(token);
+}
+
+function printFirstRunSteps(modelReady = false, config = null) {
   console.log("  Run your first task:");
-  if (!modelReady) console.log(`    1. Model access:   ${c.cyan("bivy login")}  ${c.dim("(for Pi; other agents use their own login)")}`);
-  console.log(`    ${modelReady ? "1" : "2"}. Start chatting: ${c.cyan("bivy")}`);
+  let n = 0;
+  if (!modelReady) console.log(`    ${++n}. Model access:   ${c.cyan("bivy login")}  ${c.dim("(for Pi; other agents use their own login)")}`);
+  // GitHub is optional — "No repo" sessions work without it — so this only shows
+  // when nothing is connected yet, and never blocks the flow.
+  if (!githubConnected(config)) {
+    console.log(`    ${++n}. GitHub ${c.dim("(optional)")}: ${c.cyan("bivy github:connect")}  ${c.dim("— lets the app list your repos; required for private ones")}`);
+  }
+  console.log(`    ${++n}. Start chatting: ${c.cyan("bivy")}`);
   console.log(`       Starter task:  ${c.cyan('bivy exec "explain this repository and identify one low-risk improvement"')}\n`);
 }
 
@@ -3614,6 +3635,17 @@ async function cmdDoctor(args = []) {
   console.log(c.bold("\n  Bivy doctor\n"));
   console.log(`  ${mark(hasSupportedNode())} Node ${process.version}${hasSupportedNode() ? "" : c.dim("  (needs >= 22.19.0)")}`);
   console.log(`  ${mark(commandExists("git"), true)} git${commandExists("git") ? "" : c.dim("  (recommended for repo-backed sessions)")}`);
+  // GitHub is optional (a "No repo" session needs none), so this only ever warns.
+  // `gh` is NOT required — it's a token fallback; the primary path is Bivy's own
+  // 'bivy github:connect' (or the app's Connect button). We surface gh only as an
+  // available shortcut when it's installed but nothing is connected yet.
+  const ghConnected = githubConnected(config);
+  const ghHint = ghConnected
+    ? c.green("connected")
+    : commandExists("gh")
+      ? c.dim("not connected — 'bivy github:connect' (or 'gh auth login')")
+      : c.dim("not connected — 'bivy github:connect' to list/clone private repos");
+  console.log(`  ${mark(ghConnected, true)} GitHub ${ghHint}`);
   console.log(`  ${mark(reachable)} node ${reachable ? c.green("reachable") : c.dim("not reachable — 'bivy start'")} at ${url(config)}`);
   console.log(`  ${mark(/running/.test(serviceStatusLine()), true)} ${serviceStatusLine()}`);
   const defaultAgent = String(config.env?.BIVY_RUNTIME || runtimes?.current?.id || "pi");

package/dist/github-device-auth.js

@@ -67,6 +67,22 @@ export function interpretTokenResponse(data) {
     }
 }
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/**
+ * A SINGLE access-token poll (no internal waiting) — for a caller that drives
+ * its own cadence. The web-driven connect flow uses this: the node holds the
+ * device code and the browser polls it on GitHub's interval, so the node never
+ * blocks a request thread in a poll loop. `pollForAccessToken` is the CLI's
+ * self-driving loop built on the same interpretation.
+ */
+export async function pollAccessTokenOnce(clientId, deviceCode) {
+    const res = await fetch(ACCESS_TOKEN_URL, {
+        method: "POST",
+        headers: { accept: "application/json", "content-type": "application/json" },
+        body: JSON.stringify({ client_id: clientId, device_code: deviceCode, grant_type: "urn:ietf:params:oauth:grant-type:device_code" }),
+    });
+    const data = (await res.json().catch(() => ({})));
+    return interpretTokenResponse(data);
+}
 /** Step 2: poll until the user authorizes (or the code expires). */
 export async function pollForAccessToken(clientId, device, signal) {
     let intervalMs = device.intervalSec * 1000;

package/dist/harness/mcp-config.js

@@ -3,12 +3,13 @@
 // Universal Agent Harness — MCP config rewriting.
 //
 // The one piece of MCP governance that is unavoidably per-agent is *where* the
-// config lives — but the shape is near-universal. Claude Code, Codex, Cursor,
-// Windsurf, and most MCP hosts use the same `{ mcpServers: { name: { command,
-// args, env } } }` object (stdio servers) plus optional remote (url) servers.
-// This module rewrites that object so every stdio server launches through the
-// Bivy MCP proxy instead of directly — turning each agent's own MCP config into
-// the injection point, with no agent-specific code beyond the file location.
+// config lives — and, for a couple of hosts, the shape. Claude Code, Cursor,
+// Windsurf, and most MCP hosts use `{ mcpServers: { name: { command, args, env
+// } } }` (stdio) plus optional remote (url) servers. OpenCode is the JSON
+// outlier: `{ mcp: { name: { type: "local", command: [bin, ...args],
+// environment } } }` (see opencode.ai/config.json). This module rewrites both
+// shapes so every stdio server launches through the Bivy MCP proxy instead of
+// directly — turning each agent's own MCP config into the injection point.
 //
 // Pure functions, no I/O — unit-tested in test/harness-mcp-config.test.ts. The
 // file-location table for each agent is data (see agentMcpConfigTargets) that
@@ -109,6 +110,88 @@ export function withBivyToolsServer(config, spec, name = "bivy") {
         return { config, added: false };
     return { config: { ...config, mcpServers: { ...servers, [name]: spec } }, added: true };
 }
+/** Convert a universal stdio server spec into OpenCode's local-server shape. */
+export function toOpenCodeLocalServer(spec) {
+    const command = [spec.command ?? "", ...(spec.args ?? [])].filter((s, i) => i === 0 || s !== undefined);
+    // Drop a leading empty command if somehow absent — callers always pass one.
+    const argv = command[0] ? command : command.slice(1);
+    const out = { type: "local", command: argv };
+    if (spec.env && Object.keys(spec.env).length)
+        out.environment = { ...spec.env };
+    return out;
+}
+/** True when an OpenCode local server already launches through the Bivy proxy. */
+export function isOpenCodeProxied(spec, launcher) {
+    if (!Array.isArray(spec.command) || spec.command.length === 0)
+        return false;
+    if (spec.command[0] !== launcher.command)
+        return false;
+    return spec.command.includes(PROXY_MARKER);
+}
+/**
+ * Rewrite every local stdio server in `config.mcp` to launch through the proxy:
+ *
+ *   original:  { type: "local", command: ["mcp-fs", "--root", "/w"], environment: {...} }
+ *   rewritten: { type: "local",
+ *                command: ["bivy", "mcp-proxy", "--bivy-mcp", "--server", "<name>", "--",
+ *                          "mcp-fs", "--root", "/w"],
+ *                environment: {...} }
+ *
+ * Remote servers and already-proxied locals are left untouched (reported in
+ * `skipped`). Idempotent. Does not mutate the input.
+ */
+export function routeOpenCodeThroughProxy(config, launcher) {
+    const rewritten = [];
+    const skipped = [];
+    const servers = config.mcp ?? {};
+    const nextServers = {};
+    for (const [name, spec] of Object.entries(servers)) {
+        if (!spec || typeof spec !== "object") {
+            nextServers[name] = spec;
+            skipped.push(name);
+            continue;
+        }
+        if (!Array.isArray(spec.command) || spec.command.length === 0 || typeof spec.command[0] !== "string" || !spec.command[0]) {
+            // Remote/url server, enabled-only stub, or malformed — can't wrap via stdio proxy.
+            nextServers[name] = spec;
+            skipped.push(name);
+            continue;
+        }
+        if (isOpenCodeProxied(spec, launcher)) {
+            nextServers[name] = spec;
+            skipped.push(name);
+            continue;
+        }
+        const prefix = launcher.argsPrefix ?? [];
+        const orig = spec.command;
+        nextServers[name] = {
+            ...spec,
+            type: "local",
+            command: [launcher.command, ...prefix, PROXY_MARKER, "--server", name, "--", ...orig],
+        };
+        rewritten.push(name);
+    }
+    return {
+        config: { ...config, mcp: nextServers },
+        rewritten,
+        skipped,
+    };
+}
+/**
+ * Insert the Bivy tools server under OpenCode's `mcp.<name>` (default "bivy").
+ * Idempotent: an existing entry of that name is left untouched.
+ */
+export function withOpenCodeBivyToolsServer(config, spec, name = "bivy") {
+    const servers = config.mcp ?? {};
+    if (servers[name])
+        return { config, added: false };
+    return { config: { ...config, mcp: { ...servers, [name]: spec } }, added: true };
+}
+/** Basename check for OpenCode project config files we inject into. */
+export function isOpenCodeConfigFile(filePath) {
+    const base = nodePath.basename(filePath).toLowerCase();
+    return base === "opencode.json" || base === ".opencode.json" || base === "opencode.jsonc" || base === ".opencode.jsonc";
+}
 /** JSON MCP-config file candidates for an agent, most-specific (safest) first. */
 export function agentMcpConfigTargets(agentId, ctx) {
     const ws = (...parts) => nodePath.join(ctx.workspace, ...parts);

package/dist/harness/mcp-inject.js

@@ -9,12 +9,13 @@
 // session-scoped (workspace-local files preferred) so a failure or a concurrent
 // session can't corrupt config: we snapshot the exact bytes and restore them.
 //
-// Only JSON configs are handled (Claude, Gemini, OpenCode, generic .mcp.json).
-// TOML/YAML-config agents are skipped — they still run and are governed by the
-// FS + network channels. Unit-tested in test/harness-mcp-inject.test.ts.
+// JSON configs (Claude, Gemini, generic .mcp.json) use the universal
+// `mcpServers` shape; OpenCode's project `opencode.json` uses its own `mcp`
+// shape (see routeOpenCodeThroughProxy). TOML/YAML (Codex, Goose) go through
+// the format-specific writers. Unit-tested in test/harness-mcp-inject.test.ts.
 import fs from "node:fs";
 import path from "node:path";
-import { agentMcpConfigTargets, bivyToolsServerSpec, routeThroughProxy, withBivyToolsServer, } from "./mcp-config.js";
+import { agentMcpConfigTargets, bivyToolsServerSpec, isOpenCodeConfigFile, routeOpenCodeThroughProxy, routeThroughProxy, toOpenCodeLocalServer, withBivyToolsServer, withOpenCodeBivyToolsServer, } from "./mcp-config.js";
 import { injectTomlMcp, injectYamlMcp, insertTomlServer } from "./mcp-config-formats.js";
 /** The proxy launcher Bivy injects — `bivy mcp-proxy …`. */
 export function bivyProxyLauncher(bivyCommand = "bivy") {
@@ -23,7 +24,9 @@ export function bivyProxyLauncher(bivyCommand = "bivy") {
 /**
  * Inject the proxy into a single JSON config file. Returns a restore thunk
  * (a no-op if the file was absent, unreadable, non-JSON, or had no stdio
- * servers to route). Never throws.
+ * servers to route). OpenCode project configs (`opencode.json`) use the
+ * OpenCode `mcp` shape; everything else uses the universal `mcpServers` shape.
+ * Never throws.
  */
 export function injectJsonMcpConfig(filePath, launcher) {
     let original;
@@ -40,7 +43,9 @@ export function injectJsonMcpConfig(filePath, launcher) {
     catch {
         return { injected: false, restore: () => { } };
     }
-    const result = routeThroughProxy(parsed, launcher);
+    const result = isOpenCodeConfigFile(filePath)
+        ? routeOpenCodeThroughProxy(parsed, launcher)
+        : routeThroughProxy(parsed, launcher);
     if (result.rewritten.length === 0)
         return { injected: false, restore: () => { } };
     // Preserve the file's indentation feel by re-serializing with 2 spaces; the
@@ -116,7 +121,9 @@ export function injectMcpConfigFile(filePath, launcher) {
  * servers a file already has), this CREATES the config when absent so an agent
  * that ships no MCP config still gets the tool. Handles the most-specific JSON
  * config (session-local for claude/gemini/opencode/generic) and Codex's TOML
- * (`~/.codex/config.toml` — Codex has no project-local option). restore() deletes
+ * (`~/.codex/config.toml` — Codex has no project-local option). OpenCode gets
+ * its native `{ mcp: { bivy: { type: "local", command: [...] } } }` shape — the
+ * universal `mcpServers` key is rejected by OpenCode's schema. restore() deletes
  * a file it created and rewrites the exact original bytes of one it modified.
  * Idempotent (a `bivy` server already present is a no-op, so concurrent sessions
  * sharing a global config don't double up). Best-effort; never throws. Goose YAML
@@ -131,6 +138,7 @@ export function injectBivyToolsForSession(agentId, ctx, bivyCommand = "bivy") {
         return { injected: [], restore: () => { } };
     const spec = bivyToolsServerSpec({ sessionId: ctx.sessionId, endpoint: ctx.endpoint, bivyCommand });
     const ext = path.extname(target).toLowerCase();
+    const openCode = agentId === "opencode" || isOpenCodeConfigFile(target);
     const existed = fs.existsSync(target);
     let original;
     if (existed) {
@@ -142,7 +150,22 @@ export function injectBivyToolsForSession(agentId, ctx, bivyCommand = "bivy") {
         }
     }
     let nextContent;
-    if (ext === ".json") {
+    if (ext === ".json" && openCode) {
+        let parsed = {};
+        if (original !== undefined) {
+            try {
+                parsed = JSON.parse(original);
+            }
+            catch {
+                return { injected: [], restore: () => { } };
+            }
+        }
+        const { config, added } = withOpenCodeBivyToolsServer(parsed, toOpenCodeLocalServer(spec));
+        if (!added)
+            return { injected: [], restore: () => { } };
+        nextContent = `${JSON.stringify(config, null, 2)}\n`;
+    }
+    else if (ext === ".json") {
         let parsed = {};
         if (original !== undefined) {
             try {

package/dist/metadata.js

@@ -169,6 +169,38 @@ export class MetadataStore {
         this.data.sessions[id] = { ...prev, resumePending: pending, updatedAt: nowIso() };
         this.save();
     }
+    /** Set/clear the durable auto-resume time (rate/usage-limit recovery). Pass
+     *  null to clear. No-op when the row is missing or already in the requested
+     *  state, so it never churns the file on the hot turn path. */
+    setResumeAt(id, resumeAt) {
+        const prev = this.data.sessions[id];
+        if (!prev)
+            return;
+        const next = resumeAt ?? undefined;
+        if ((prev.resumeAt ?? undefined) === next)
+            return;
+        this.data.sessions[id] = { ...prev, resumeAt: next, updatedAt: nowIso() };
+        this.save();
+    }
+    /** Set the durable consecutive auto-resume counter (the restart-safe backstop
+     *  for the in-memory reroute budget). Pass 0 to clear. No-op when the row is
+     *  missing or already in the requested state, so a normal turn (counter already
+     *  0) never churns the file. */
+    setResumeAttempts(id, attempts) {
+        const prev = this.data.sessions[id];
+        if (!prev)
+            return;
+        const next = attempts > 0 ? attempts : undefined;
+        if ((prev.resumeAttempts ?? undefined) === next)
+            return;
+        this.data.sessions[id] = { ...prev, resumeAttempts: next, updatedAt: nowIso() };
+        this.save();
+    }
+    /** Sessions with a durable auto-resume time set — the resume sweep re-arms
+     *  these after a restart. */
+    sessionsWithResumeAt() {
+        return Object.values(this.data.sessions).filter((s) => typeof s.resumeAt === "string" && s.resumeAt);
+    }
     /** Look up a session's durable metadata by id, or by session-file path. */
     getSession(idOrPath) {
         if (!idOrPath)

package/dist/policy/conditions.js

@@ -50,6 +50,48 @@ export function parseResetsAt(raw) {
     const iso = /(20\d\d-\d\d-\d\dT[\d:.]+(?:Z|[+-]\d\d:?\d\d))/.exec(raw);
     return iso?.[1];
 }
+/**
+ * Parse a bare wall-clock reset time — the shape Claude's subscription limits
+ * surface, e.g. `resets 12am (UTC)`, `resets at 3pm UTC`, `resets 09:00 UTC` —
+ * into the ISO timestamp of its NEXT occurrence (interpreted as UTC, which is
+ * what these messages state). Returns undefined when there's no clear clock
+ * time, so a relative phrase ("resets in 2 hours", handled by
+ * parseRetryAfterMs) or an unrelated number never masquerades as a reset.
+ *
+ * NB: a bare time-of-day can't say WHICH day, so for a multi-day window (a
+ * "weekly limit") this resolves to the nearest matching midnight, which may be
+ * earlier than the real reset. Prefer a structured resetsAtHint when available.
+ */
+export function parseResetClock(raw, nowMs) {
+    const m = /reset[a-z]*\s+(?:at\s+)?(\d{1,2})(?::(\d{2}))?\s*(am|pm)?/i.exec(raw);
+    if (!m)
+        return undefined;
+    const meridiem = m[3]?.toLowerCase();
+    // Require a real clock signal — a meridiem, an explicit minutes field, or a
+    // trailing UTC/GMT marker — so a bare "resets 5 nodes" can't parse as 05:00.
+    const tzFollows = /\b(?:utc|gmt)\b/i.test(raw.slice(m.index));
+    if (!meridiem && m[2] === undefined && !tzFollows)
+        return undefined;
+    let hour = Number(m[1]);
+    const minute = m[2] ? Number(m[2]) : 0;
+    if (hour > 23 || minute > 59)
+        return undefined;
+    if (meridiem === "am") {
+        if (hour === 12)
+            hour = 0;
+    }
+    else if (meridiem === "pm") {
+        if (hour !== 12)
+            hour += 12;
+    }
+    if (hour > 23)
+        return undefined;
+    const now = new Date(nowMs);
+    let target = Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate(), hour, minute, 0, 0);
+    if (target <= nowMs)
+        target += 86_400_000; // already past today → next day's occurrence
+    return new Date(target).toISOString();
+}
 // Ordered classifiers: the FIRST match wins, so more-specific/actionable
 // conditions are tested before broader ones (auth 401 before generic HTTP
 // noise; explicit billing/quota before a bare rate-limit; context-window before
@@ -58,7 +100,12 @@ const CLASSIFIERS = [
     { condition: "auth_failed", test: (r) => isAnthropicAuthError(r) },
     {
         condition: "credits_exhausted",
-        test: (r) => /\b402\b|payment required|insufficient\s+(?:credit|quota|balance|funds)|credit balance (?:is )?too low|quota (?:exceeded|exhausted)|billing|(?:usage|session) limit (?:reached|hit)|(?:you(?:'ve| have)\s+)?hit your limit|out of credits|plan (?:limit|allowance)/i.test(r),
+        // Includes subscription usage caps — a Claude "5-hour" or "weekly" window
+        // hit reads "you've hit your weekly limit · resets 12am (UTC)". The window
+        // qualifier (weekly/daily/5-hour/7-day) is optional and may sit between
+        // "your" and "limit", so it must not break the match (it did before — the
+        // word "weekly" left these limits classified "unknown" and never resumed).
+        test: (r) => /\b402\b|payment required|insufficient\s+(?:credit|quota|balance|funds)|credit balance (?:is )?too low|quota (?:exceeded|exhausted)|billing|(?:usage|session|weekly|daily|monthly|5[\s-]?hour|7[\s-]?day)[\s-]?limit(?:\s+(?:reached|hit))?|(?:you(?:'ve| have)\s+)?hit your (?:(?:weekly|daily|monthly|session|usage|5[\s-]?hour|7[\s-]?day)\s+)?limit|out of credits|plan (?:limit|allowance)/i.test(r),
     },
     {
         condition: "rate_limited",
@@ -86,7 +133,7 @@ const CLASSIFIERS = [
  * recovery metadata. Unmatched failures are `"unknown"` — deliberately left for
  * a human rather than blindly retried.
  */
-export function classifyFailure(error) {
+export function classifyFailure(error, opts = {}) {
     const raw = rawText(error).slice(0, 2000);
     const condition = CLASSIFIERS.find((c) => c.test(raw))?.condition ?? "unknown";
     const out = { condition, raw };
@@ -95,7 +142,11 @@ export function classifyFailure(error) {
         const retryAfterMs = parseRetryAfterMs(raw);
         if (retryAfterMs !== undefined)
             out.retryAfterMs = retryAfterMs;
-        const resetsAt = parseResetsAt(raw);
+        // Reset time, most-authoritative first: a structured hint the caller
+        // supplied (the provider's own usage snapshot), then an ISO stamp in the
+        // text, then a bare wall-clock ("resets 12am (UTC)") resolved to its next
+        // occurrence.
+        const resetsAt = opts.resetsAtHint ?? parseResetsAt(raw) ?? parseResetClock(raw, opts.now ?? Date.now());
         if (resetsAt !== undefined)
             out.resetsAt = resetsAt;
     }

package/dist/policy/run-policy.js

@@ -34,7 +34,7 @@ export function createRunPolicy(deps = {}) {
     const now = deps.now ?? Date.now;
     return {
         decide(ctx) {
-            const classified = classifyFailure(ctx.error);
+            const classified = classifyFailure(ctx.error, { now: now(), resetsAtHint: ctx.resetsAtHint });
             const { condition } = classified;
             const rule = findRule(ruleset, condition, context);
             if (!rule)
@@ -73,6 +73,7 @@ export function createRunPolicy(deps = {}) {
                     delayMs,
                     condition,
                     summary: `${condition}: transient — retrying (attempt ${nextAttempt}/${rule.maxAttempts})${timing}.`,
+                    ...(resetDelayMs !== undefined && classified.resetsAt ? { resetsAt: classified.resetsAt } : {}),
                 };
             }
             // action === "reroute": walk the chain from the current cursor, skipping