@bivy/bivy 0.7.0 → 0.8.0

package/dist/policy/session-reroute.js

@@ -21,6 +21,17 @@
 // whether to suppress the turn's error toast before kicking off the async swap +
 // retry (`applyReroute`). Reroute happens only at the turn boundary, so there is
 // no partial-work hazard.
+//
+// It also plans the OTHER in-place recovery a live session can do: waiting out a
+// provider usage/rate limit and re-sending the same prompt when the window
+// resets (`planResume`). Unlike a reroute (which the controller applies itself),
+// a resume can be hours away and must survive a daemon restart, so scheduling +
+// persistence live in the caller (src/server.ts) — the controller only decides
+// whether a resume is warranted and by when.
+/** Below this, a "retry" is ordinary backoff (seconds) — not worth deferring an
+ *  interactive turn for; let it surface. A real usage/rate window reset is
+ *  minutes-to-days out and always clears this bar. */
+const MIN_RESUME_DELAY_MS = 60_000;
 const defaultSleep = (ms) => new Promise((r) => setTimeout(r, ms));
 export class SessionRerouteController {
     deps;
@@ -50,6 +61,61 @@ export class SessionRerouteController {
             attempt: this.attempt,
             rerouteCount: this.rerouteCount,
         });
+        if (decision.action !== "reroute")
+            return null;
+        return this.rerouteFrom(decision, currentModel);
+    }
+    /**
+     * Decide whether this turn error should be recovered by WAITING for a provider
+     * usage/rate limit to reset and re-sending the same prompt. Returns a plan the
+     * caller should persist + schedule, or null (surface the error as usual).
+     *
+     * `resetsAtHint` is the authoritative reset time when the caller has one (the
+     * provider's structured usage snapshot) — essential for a multi-day "weekly"
+     * window, whose error text only states a time-of-day. `now` is injectable for
+     * deterministic tests. Pure w.r.t. the controller's counters.
+     */
+    planResume(rawError, currentModel, opts = {}) {
+        if (this.applying)
+            return null;
+        const now = opts.now ?? Date.now();
+        const decision = this.deps.policy.decide({
+            routing: { model: currentModel },
+            error: rawError,
+            attempt: this.attempt,
+            rerouteCount: this.rerouteCount,
+            resetsAtHint: opts.resetsAtHint,
+        });
+        if (decision.action !== "retry")
+            return null;
+        // Only defer for a concrete recovery window — a provider reset, or a delay
+        // long enough that it's clearly a limit rather than routine backoff.
+        if (decision.resetsAt === undefined && decision.delayMs < MIN_RESUME_DELAY_MS)
+            return null;
+        // Resolve the due time (provider reset when known, else backoff) and floor it
+        // to at least MIN_RESUME_DELAY_MS in the FUTURE. A reset time can be in the
+        // past or ~now — a stale/elapsed reset, clock skew, or (most often) a window
+        // that already lapsed while the daemon was down — and using it verbatim yields
+        // a 0ms delay. The caller arms a timer at that delay, so a 0ms resume re-sends
+        // instantly, re-hits the still-standing limit, and re-schedules 0ms again: a
+        // tight loop that pins a CPU core and never settles. Flooring turns a
+        // not-yet-cleared limit into a slow retry the attempt budget can still park.
+        const rawDueMs = decision.resetsAt ? Date.parse(decision.resetsAt) : now + decision.delayMs;
+        const dueMs = Math.max(Number.isFinite(rawDueMs) ? rawDueMs : now, now + MIN_RESUME_DELAY_MS);
+        return {
+            condition: decision.condition,
+            summary: decision.summary,
+            delayMs: dueMs - now,
+            resumeAt: new Date(dueMs).toISOString(),
+        };
+    }
+    /** Advance the attempt budget once the caller has committed to a resume, so a
+     *  limit that re-fires after the reset counts toward `maxAttempts` and can
+     *  eventually exhaust (→ park) instead of looping forever. */
+    noteResumeApplied() {
+        this.attempt += 1;
+    }
+    rerouteFrom(decision, currentModel) {
         if (decision.action !== "reroute")
             return null;
         const model = decision.routing.model;

package/dist/repo-workspace.js

@@ -100,6 +100,25 @@ export async function resolveGitHubToken(env = process.env) {
         return undefined;
     }
 }
+/**
+ * Whether the GitHub CLI (`gh`) is installed on this machine — used only to
+ * shade the "no GitHub token" message: when `gh` is present but `gh auth token`
+ * gave us nothing, the user is one `gh auth login` away, so the picker can say
+ * so. It never means `gh` is REQUIRED — `bivy github:connect` is the primary
+ * path and needs no CLI (see resolveGitHubToken). Mirrors the `command -v`
+ * probe in secrets.ts.
+ */
+export async function ghCliInstalled() {
+    const which = process.platform === "win32" ? "where" : "command";
+    const args = process.platform === "win32" ? ["gh"] : ["-v", "gh"];
+    try {
+        await exec(which, args, process.platform === "win32" ? {} : { shell: true });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Refresh the remote-tracking refs so a session branches off the CURRENT state
  * of `origin`, not whatever the local checkout last saw. Best-effort: an offline

package/dist/runtime/index.js

@@ -116,14 +116,27 @@ function claudeCodeInfo() {
         },
     };
 }
+// Memoized CLI probes. `commandAvailable`/`resolveCommandPath`/`probeHelpText`
+// each shell out with a BLOCKING spawnSync, and the runtime catalog that calls
+// them (cliAgentInfo → prefersAcp/acpSupportedByBinary) is rebuilt often — on
+// every advertise and every runtimes.list send. Re-probing per build stalled the
+// event loop for seconds at a time (a synchronous spawn storm). A CLI's presence
+// is effectively constant for the daemon's run, so cache per command for the
+// process lifetime and clear on install (invalidateCliProbeCache).
+const COMMAND_AVAILABLE_CACHE = new Map();
 function commandAvailable(command) {
     if (!command.trim())
         return false;
+    const cached = COMMAND_AVAILABLE_CACHE.get(command);
+    if (cached !== undefined)
+        return cached;
     const result = spawnSync(process.platform === "win32" ? "where" : "command", process.platform === "win32" ? [command] : ["-v", command], {
         shell: process.platform !== "win32",
         stdio: "ignore",
     });
-    return result.status === 0;
+    const available = result.status === 0;
+    COMMAND_AVAILABLE_CACHE.set(command, available);
+    return available;
 }
 function genericCliInfo() {
     const options = processRuntimeFromEnv();
@@ -179,7 +192,11 @@ const CLI_AGENT_SPECS = {
         // reply to stdout (the TUI needs a real TTY and would hang over a pipe).
         args: ["run"],
         promptMode: "argv",
-        supportTier: "beta",
+        // Supported tier: OpenCode runs on the governed ACP path by default (per-tool
+        // Approve/Deny + session/load resume + a real model picker), the same bar Pi,
+        // Claude Code, and Codex clear. See `acp` below for the version fallback.
+        supportTier: "supported",
+        testedVersion: "1.18.13",
         blurb: "The most widely used open-source coding harness (OpenCode CLI).",
         // `opencode run -s <id> "<prompt>"` continues a prior session by its own id
         // (`-s, --session  session id to continue`, per `opencode run --help`).
@@ -195,11 +212,14 @@ const CLI_AGENT_SPECS = {
                 { id: "google/gemini-2.5-pro", name: "Gemini 2.5 Pro", provider: "google" },
             ],
         },
-        // OpenCode ships a native ACP server (`opencode acp`, per opencode.ai/docs/acp),
-        // so it can be driven through the governed ProtocolRuntime instead of the pipe —
-        // per-tool approvals + streaming + resume. Opt in with BIVY_OPENCODE_ACP=1 (or
-        // global BIVY_PREFER_ACP=1); off by default until validated for your version.
-        acp: { args: ["acp"] },
+        // `opencode acp` ("start ACP (Agent Client Protocol) server") drives OpenCode
+        // through the governed ProtocolRuntime instead of the one-shot pipe: per-tool
+        // Approve/Deny, streaming, `session/load` resume, and `session/set_model`.
+        // Validated against opencode 1.18.13, so it is ON by default (`preferred`) —
+        // gated on the binary actually listing the `acp` subcommand, so an older
+        // OpenCode falls back to the pipe path rather than opening a dead session.
+        // Force the pipe path back with BIVY_OPENCODE_ACP=0.
+        acp: { args: ["acp"], helpToken: "acp", preferred: true },
         install: { kind: "npm", pkg: "opencode-ai" },
     },
     aider: {
@@ -857,10 +877,34 @@ function cliThinkingConfig(id) {
 // installed binary doesn't actually mention. It never UPGRADES — adding a
 // capability needs the exact arg template, which help text can't safely supply — so
 // probing can only make the catalog MORE honest, never invent a no-op control.
+/**
+ * Absolute path of a command on the current PATH, or null when it isn't there.
+ * Used to key the help-probe cache: caching by the bare NAME would keep serving a
+ * stale answer after the binary behind that name changed (a CLI upgraded or
+ * installed while the daemon is running, or a different PATH entry winning).
+ * Memoized per command (see COMMAND_AVAILABLE_CACHE) — it spawnSyncs, and is hit
+ * on every catalog build.
+ */
+const COMMAND_PATH_CACHE = new Map();
+function resolveCommandPath(command) {
+    if (!command.trim())
+        return null;
+    const cached = COMMAND_PATH_CACHE.get(command);
+    if (cached !== undefined)
+        return cached;
+    const res = spawnSync(process.platform === "win32" ? "where" : "command", process.platform === "win32" ? [command] : ["-v", command], {
+        shell: process.platform !== "win32",
+        encoding: "utf8",
+    });
+    const resolved = res.status !== 0 ? null : ((res.stdout ?? "").split(/\r?\n/)[0]?.trim() || null);
+    COMMAND_PATH_CACHE.set(command, resolved);
+    return resolved;
+}
 const HELP_PROBE_CACHE = new Map();
 function probeHelpText(command) {
-    if (HELP_PROBE_CACHE.has(command))
-        return HELP_PROBE_CACHE.get(command) ?? null;
+    const key = resolveCommandPath(command) ?? command;
+    if (HELP_PROBE_CACHE.has(key))
+        return HELP_PROBE_CACHE.get(key) ?? null;
     let text = null;
     try {
         const res = spawnSync(command, ["--help"], { encoding: "utf8", timeout: 4000 });
@@ -870,9 +914,22 @@ function probeHelpText(command) {
     catch {
         text = null;
     }
-    HELP_PROBE_CACHE.set(command, text);
+    HELP_PROBE_CACHE.set(key, text);
     return text;
 }
+/**
+ * Drop every memoized CLI probe (availability, resolved path, --help text). These
+ * probes shell out with a blocking spawnSync and are cached for the process
+ * lifetime to keep the frequently-rebuilt runtime catalog off the event loop, so a
+ * CLI installed/updated mid-run wouldn't otherwise be noticed until a restart.
+ * Call this right after Bivy installs a runtime so the next catalog build re-probes
+ * and reflects the new binary immediately.
+ */
+export function invalidateCliProbeCache() {
+    COMMAND_AVAILABLE_CACHE.clear();
+    COMMAND_PATH_CACHE.clear();
+    HELP_PROBE_CACHE.clear();
+}
 // A resume template mixes launch flags (`-p`, `--force`) with the resume-specific
 // token(s) (`--resume`, `threads continue`, `-s`, `--restore`, …). Only the latter
 // evidence resume support, so we match on those — otherwise a shared launch flag
@@ -963,9 +1020,14 @@ function cliAgentInfo(id) {
         // src/harness/mcp-inject.ts + governMcpCall in src/server.ts.
         capabilities: { toolInterception: acpActive, mcpToolApprovals: acpActive || Boolean(process.env.BIVY_MCP_PROXY), modelSelection, resume, packages: false, fork: false, usageReporting, sessionDiscovery: id === "codex" },
         supportTier: spec.supportTier ?? (id === "codex" ? "supported" : "experimental"),
+        testedVersion: spec.testedVersion,
         authOwner: spec.authOwner ?? "agent",
         notes: installed
-            ? `Available on PATH. This process adapter ${spec.parserId && !spec.parserUnverified ? "parses its native JSON stream into a structured transcript" : spec.parserId ? "streams stdout/stderr (a structured JSON parser is available; opt in with BIVY_AGENT_STRUCTURED=1 once validated for your version)" : "streams stdout/stderr"}; Bivy governs its filesystem/exec/MCP effects at the sandbox tier rather than intercepting each tool call. Override its launch flags with BIVY_${id.toUpperCase()}_ARGS if your CLI version differs.`
+            ? acpActive
+                // Promoted to ACP: the description must match the governed path actually in
+                // use, not the pipe path this agent would otherwise take.
+                ? `Available on PATH, driven through its Agent Client Protocol server (\`${spec.command} ${spec.acp?.args.join(" ")}\`): each tool call is gated by Bivy's Approve/Deny before it runs, and sessions resume natively. Force the plain stdout pipe with BIVY_${id.toUpperCase()}_ACP=0.`
+                : `Available on PATH. This process adapter ${spec.parserId && !spec.parserUnverified ? "parses its native JSON stream into a structured transcript" : spec.parserId ? "streams stdout/stderr (a structured JSON parser is available; opt in with BIVY_AGENT_STRUCTURED=1 once validated for your version)" : "streams stdout/stderr"}; Bivy governs its filesystem/exec/MCP effects at the sandbox tier rather than intercepting each tool call. Override its launch flags with BIVY_${id.toUpperCase()}_ARGS if your CLI version differs.`
             : `${spec.command} was not found on PATH. Install it on this node, then select this agent again.`,
         install: installed || !installCommand ? undefined : {
             label: `Install ${spec.displayName}`,
@@ -980,6 +1042,13 @@ function cliAgentInfo(id) {
 // Approve/Deny card via guardianInterceptor, AND it resumes a prior thread by its
 // rollout id (thread/resume). Governed + resumable in one runtime supersedes the
 // exec path, which stays runnable via `BIVY_RUNTIME=codex` for a no-approval flow.
+/**
+ * The Codex CLI release this adapter was last certified against. Unlike Pi and the
+ * Claude Agent SDK, Codex is an external binary rather than a pinned npm dependency,
+ * so there is no lockfile entry to derive this from — it is bumped deliberately when
+ * the app-server shim is re-validated against a new Codex release.
+ */
+const CODEX_TESTED_VERSION = "0.145.0";
 function codexApprovalsInfo() {
     const installed = commandAvailable("codex");
     return {
@@ -1009,7 +1078,12 @@ function codexApprovalsInfo() {
             nativeSessionDiscovery: true,
             nativeSessionAdoption: true,
         },
-        supportTier: "beta",
+        // Supported tier: the app-server shim already clears the same bar as Pi and
+        // Claude Code — per-tool Approve/Deny, model selection, thread resume, usage
+        // reporting, and native session discovery/adoption — all over a bidirectional
+        // protocol rather than a one-shot pipe.
+        supportTier: "supported",
+        testedVersion: CODEX_TESTED_VERSION,
         authOwner: "agent",
         notes: installed
             ? "Drives Codex's experimental app-server so tool calls surface as in-chat approval cards, and resumes a prior thread by its rollout id (thread/resume). Governance AND resume in one runtime."
@@ -1202,15 +1276,50 @@ function acpRuntimeFromEnv(credsDir) {
     return acpRuntimeOptions({ id: "acp", displayName: process.env.BIVY_ACP_NAME?.trim() || "ACP Agent", command, agentArgs, credsDir });
 }
 /**
- * Whether a CLI agent should be driven through ACP rather than the one-shot pipe:
- * it declares an `acp` mode AND ACP is preferred for it (per-agent `BIVY_<ID>_ACP=1`
- * or global `BIVY_PREFER_ACP=1`). This is the data-driven "promote an agent to the
- * high-capability path" switch — no per-agent code, just a spec field + a flag.
+ * Does the INSTALLED binary actually evidence the agent's ACP mode? A default-on
+ * promotion must never be taken on faith: ACP is a hard switch (the pipe path is
+ * unreachable once a session opens), so a CLI too old to have the subcommand would
+ * otherwise hang and die instead of degrading. We reuse the same cached `--help`
+ * probe the opt-in capability refinement uses, and fail CLOSED — a missing binary
+ * or unreadable help keeps the agent on the honest pipe path.
+ */
+function acpSupportedByBinary(id) {
+    const spec = CLI_AGENT_SPECS[id];
+    if (!spec.acp)
+        return false;
+    if (!commandAvailable(spec.command))
+        return false;
+    const help = probeHelpText(spec.command);
+    if (!help)
+        return false;
+    const token = (spec.acp.helpToken ?? spec.acp.args[0] ?? "acp").toLowerCase();
+    return help.includes(token);
+}
+/**
+ * Whether a CLI agent should be driven through ACP rather than the one-shot pipe.
+ * Three ways in, in precedence order:
+ *   - `BIVY_<ID>_ACP=0` — operator forces the pipe path back (escape hatch).
+ *   - `BIVY_<ID>_ACP=1` / `BIVY_PREFER_ACP=1` — operator forces ACP, no probe (they
+ *     know their binary; an explicit request shouldn't be second-guessed).
+ *   - `spec.acp.preferred` — validated agents are promoted by DEFAULT, but only
+ *     when the installed binary evidences the ACP mode (see acpSupportedByBinary).
+ * Still no per-agent code: a spec field plus a flag.
+ *
+ * Both the catalog (cliAgentInfo) and the launch path (makeCliRuntime) call this,
+ * so what the picker advertises and what actually starts cannot disagree.
  */
 function prefersAcp(id) {
-    if (!CLI_AGENT_SPECS[id].acp)
+    const spec = CLI_AGENT_SPECS[id];
+    if (!spec.acp)
+        return false;
+    const override = process.env[`BIVY_${id.toUpperCase()}_ACP`];
+    if (override === "0")
+        return false;
+    if (override === "1" || process.env.BIVY_PREFER_ACP === "1")
+        return true;
+    if (!spec.acp.preferred)
         return false;
-    return process.env.BIVY_PREFER_ACP === "1" || process.env[`BIVY_${id.toUpperCase()}_ACP`] === "1";
+    return acpSupportedByBinary(id);
 }
 /**
  * Resolve the communication mode for a CLI agent. This is deliberately pure so

package/dist/runtime/protocol.js

@@ -410,6 +410,21 @@ class ProtocolSession {
                 this.runtimeSessionRef = msg.runtimeSessionRef;
             return;
         }
+        // Late-arriving model registry. A shim that knows its models up front puts them
+        // in `hello`; one whose list is only knowable per session — an ACP agent's
+        // models depend on which providers the user has authenticated, and arrive with
+        // session/new — publishes them here instead. Same contract as the hello path: a
+        // picker backed by a real `model.set` the shim answers, never a claimed one.
+        if (type === "runtime.models") {
+            const models = parseModels(msg.models);
+            if (models.length) {
+                this.models = models;
+                this.capabilitiesRef.modelSelection = true;
+                if (typeof msg.currentModel === "string")
+                    this.currentModelId = msg.currentModel;
+            }
+            return;
+        }
         if (type === "message.delta") {
             const text = String(msg.text ?? "");
             if (!this.assistantText)

package/dist/secrets.js

@@ -183,8 +183,12 @@ export class SecretVault {
         if (fs.existsSync(this.keyFile))
             checks.push({ name: "local key file permissions", ok: modeIsPrivate(this.keyFile), detail: this.keyFile });
         checks.push({ name: "1Password CLI", ok: await commandExists("op"), detail: "required for op:// references" });
-        checks.push({ name: "GitHub CLI", ok: await commandExists("gh"), detail: "fallback for GitHub tokens when no Bivy secret is configured" });
-        return { ok: checks.every((c) => c.ok || c.name === "1Password CLI" || c.name === "GitHub CLI"), checks };
+        checks.push({ name: "GitHub CLI (optional)", ok: await commandExists("gh"), detail: "optional token shortcut; Bivy connects GitHub itself via `bivy github:connect`" });
+        // 1Password and the GitHub CLI are optional shortcuts — a missing one must
+        // not fail the vault's health (Bivy connects GitHub itself; op is only for
+        // op:// refs). Match on a stable prefix so renaming the label can't silently
+        // turn either back into a hard failure.
+        return { ok: checks.every((c) => c.ok || c.name.startsWith("1Password CLI") || c.name.startsWith("GitHub CLI")), checks };
     }
     key() {
         try {