@bivy/bivy 0.16.10-staging.1 → 0.16.10-staging.3

package/bin/bivy.mjs

@@ -1791,13 +1791,30 @@ async function cmdExec(args = []) {
   let token;
   try { token = await localDeviceToken(config); }
   catch (error) { console.error(c.red(error?.message || String(error))); process.exit(1); return; }
-  const code = await run(nodeBin, [...nodeScriptArgs(execEntry), "--url", url(config), "--token", token, ...args], {
+  // Translate the friendly bridge names to their governed runtime ids (the same
+  // mapping `bivy run <agent> --chat` uses), so `bivy exec --agent codex` opens
+  // the governed Codex app-server session instead of the plain exec fallback.
+  // Other aliases (claude, gemini-cli, …) resolve server-side via the registry.
+  const execArgs = translateExecAgent(args);
+  const code = await run(nodeBin, [...nodeScriptArgs(execEntry), "--url", url(config), "--token", token, ...execArgs], {
     cwd: repoRoot,
     env: startEnv(config),
   });
   process.exit(code);
 }
 
+// Rewrite a `bivy exec` arg list's --agent/-a value through governedChatAgentId,
+// leaving everything else (the free-text prompt, --session, flags) untouched.
+function translateExecAgent(args = []) {
+  const out = [...args];
+  for (let i = 0; i < out.length; i++) {
+    const a = out[i];
+    if ((a === "--agent" || a === "-a") && out[i + 1]) { out[i + 1] = governedChatAgentId(out[i + 1]); i++; }
+    else if (typeof a === "string" && a.startsWith("--agent=")) out[i] = `--agent=${governedChatAgentId(a.slice("--agent=".length))}`;
+  }
+  return out;
+}
+
 // `bivy completions <bash|zsh|fish>` — print a shell completion script to eval or
 // install. Covers the top-level commands and known integration ids.
 function cmdCompletions(args = []) {

package/dist/control-plane-tasks.js

@@ -16,6 +16,7 @@
  * issues (and Slack) across many repos/nodes. Pure HTTP + claim/loop logic lives
  * here; the actual run is injected so the daemon keeps the agent wiring.
  */
+import { RemoteSessionAdmissionError } from "./session/remote-session-admission.js";
 /** True when every required tag is among this node's declared capabilities.
  * A node that fails this must never attempt to claim the item — the hard
  * block happens locally, before any claim race, so an ineligible node never
@@ -351,6 +352,19 @@ export class ControlPlaneTaskPoller {
                 // A cancelled/lost Run has no node-side terminal transition or retry.
                 if (run.state !== "active")
                     return;
+                // Deployment admission is not an agent failure. Never reroute/retry it
+                // through a provider policy or mark the work successfully completed.
+                if (error instanceof RemoteSessionAdmissionError) {
+                    const now = new Date().toISOString();
+                    await report({
+                        events: [{ at: now, kind: "policy_denial", summary: error.message, reasonCode: error.code, status: "denied", attempt }],
+                        attention: { severity: "warning", reason: error.message, since: now },
+                    });
+                    if (run.state !== "active")
+                        return;
+                    await needsAttentionWork(this.cfg, item.id);
+                    return;
+                }
                 const policy = typeof this.policy === "function" ? this.policy(current) : this.policy;
                 const decision = policy?.decide({
                     routing: { runtimeId: current.runtimeId, model: current.model },

package/dist/runtime/host.js

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 // Copyright (c) 2026 Petter André Sjulstad
-import { listRuntimes, makeRuntime } from "./index.js";
+import { canonicalAgentId, listRuntimes, makeRuntime } from "./index.js";
 import { RemoteRuntime, connectSocketTransport } from "./remote.js";
 import { withExactCapabilitySurface } from "./types.js";
 function remoteRuntimeSelection() {
@@ -50,12 +50,24 @@ export class RuntimeHost {
     }
     resolveRuntimeId(requested, fallback) {
         const wantId = (requested || fallback).toLowerCase();
-        const info = this.list().find((candidate) => candidate.id === wantId);
+        // Resolve declared aliases and historical ids through the one authoritative
+        // registry (e.g. `claude` → claude-code-sdk, `gemini-cli` → gemini,
+        // `open-code` → opencode) so the session/exec API accepts the same friendly
+        // names the picker and `bivy run` use — not only exact canonical ids. This
+        // honors the aliases integrations already declare as data, instead of making
+        // every caller know each canonical id (previously only the CLI's `--chat`
+        // path translated a couple by hand, so `bivy exec --agent claude` failed).
+        // Unknown names fall through to wantId and still raise "Unknown agent" below.
+        const canonical = canonicalAgentId(wantId) ?? wantId;
+        // Pass the resolved id as the "current" runtime so a hidden-but-runnable
+        // contribution is still resolvable to back a session (the profiles' "hidden
+        // from the picker, still runnable" contract; parity with makeRuntime).
+        const info = this.list(canonical).find((candidate) => candidate.id === canonical);
         if (!info)
             throw new Error(`Unknown agent: ${wantId}`);
         if (info.status !== "available")
             throw new Error(`${info.displayName} is not available on this node yet.`);
-        return wantId;
+        return canonical;
     }
     get(requested, fallback, sandbox) {
         // Remote path (opt-in, reversible): return a RemoteRuntime that drives the
@@ -63,7 +75,10 @@ export class RuntimeHost {
         // runtime the daemon can't run locally (e.g. the Claude SDK isn't installed
         // here) is still offloadable — remote availability is the service's business.
         const remote = remoteRuntimeSelection();
-        const wantId = (requested || fallback).toLowerCase();
+        const requestedId = (requested || fallback).toLowerCase();
+        // Canonicalize before the remote check too, so an alias (e.g. `claude`) is
+        // matched against BIVY_REMOTE_RUNTIME and drives the correct remote facade.
+        const wantId = canonicalAgentId(requestedId) ?? requestedId;
         if (remote && remote.enabled(wantId))
             return this.getRemote(wantId, remote.addr, sandbox);
         const id = this.resolveRuntimeId(requested, fallback);

package/dist/server.js

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 // Copyright (c) 2026 Petter André Sjulstad
 import fs from "node:fs";
+import { createRemoteSessionAdmission, RemoteSessionAdmissionError } from "./session/remote-session-admission.js";
 import path from "node:path";
 import os from "node:os";
 import { spawn, spawnSync } from "node:child_process";
@@ -2911,17 +2912,6 @@ const RELAY_COMMANDS = {
             });
             return;
         }
-        const remoteSessionRequestId = requestId ?? randomUUID();
-        const sessionAdmission = await admitRelaySessionCreate(remoteSessionRequestId);
-        if (!sessionAdmission.allowed) {
-            relay?.sendEvent({
-                type: "session.error",
-                code: sessionAdmission.code || "remote_session_limit",
-                error: sessionAdmission.error,
-                requestId,
-            });
-            return;
-        }
         let record;
         try {
             // Deduped by requestId so a client's post-reconnect retry adopts the
@@ -2948,7 +2938,7 @@ const RELAY_COMMANDS = {
             });
         }
         catch (error) {
-            relay?.sendEvent({ type: "session.error", error: error instanceof Error ? error.message : String(error) });
+            relay?.sendEvent({ type: "session.error", requestId, code: error instanceof RemoteSessionAdmissionError ? error.code : undefined, error: error instanceof Error ? error.message : String(error) });
             return;
         }
         // Resolve once from the session's actual, now-known launch facts (final
@@ -2977,7 +2967,8 @@ const relayCtx = { reply: (event) => relay?.sendEvent(event), broadcast };
 const RELAY_CLIENT_ID = "relay";
 async function handleRelayMessage(msg) {
     try {
-        const dispatched = await clientCommands.dispatch(msg.kind, msg, relayCtx);
+        const requestId = typeof msg.requestId === "string" && msg.requestId.trim() ? msg.requestId : randomUUID();
+        const dispatched = await remoteSessionAdmission.run(JSON.stringify(["relay", identity.nodeId, msg.kind, requestId]), () => clientCommands.dispatch(msg.kind, msg, relayCtx));
         if (dispatched.handled)
             return;
         // Fallthrough for kinds not in RELAY_COMMANDS: terminal.* frames go to the
@@ -3188,24 +3179,25 @@ async function modelAuthFetch(pathname, init = {}) {
         headers.set("content-type", "application/json");
     return fetch(`${sessionAdvertiseTarget.controlPlaneUrl.replace(/\/$/, "")}${pathname}`, { ...init, headers });
 }
-async function admitRelaySessionCreate(idempotencyKey) {
-    // Self-hosted/direct deployments without an account extension stay unrestricted:
-    // the control plane answers allowed when no deployment extension is configured.
+const remoteSessionAdmission = createRemoteSessionAdmission(async (idempotencyKey) => {
+    // Only remote scopes reach this callback. Self-hosted control planes answer
+    // allowed without an extension; losing enrollment mid-launch must fail closed.
     const res = await modelAuthFetch("/node/policy/check", {
         method: "POST",
         body: JSON.stringify({ operation: "session.create", idempotencyKey }),
+        signal: AbortSignal.timeout(10_000),
     });
     if (!res)
-        return { allowed: true };
+        return { allowed: false, code: "extension_unavailable", reason: "Reconnect this machine before starting a new remote session." };
     const decision = await res.json().catch(() => ({}));
-    if (res.ok && decision.allowed !== false)
+    if (res.ok && decision.allowed === true)
         return { allowed: true };
     return {
         allowed: false,
         code: decision.code,
-        error: decision.reason || decision.error || "This account has reached its remote session allowance.",
+        reason: decision.reason || decision.error || "This account has reached its remote session allowance.",
     };
-}
+});
 // Debounced model-auth sync trigger. A relay wake (`work.available`) fires this
 // so peers answer a new node's vault-key request promptly (event-driven) instead
 // of on the steady 30s poll. Coalesces a burst of wakes into one sync.
@@ -4926,6 +4918,11 @@ function lastUserMessageText(record) {
     return "";
 }
 async function runWorkItem(item, report, signal) {
+    // Stable across delivery/lease retries and node changes. Follow-ups that resume
+    // a session do not consume a slot; any fallback that creates one does.
+    return remoteSessionAdmission.run(JSON.stringify(["automation", item.id]), () => executeWorkItem(item, report, signal));
+}
+async function executeWorkItem(item, report, signal) {
     if (signal.aborted)
         throw signal.reason ?? new Error("Run cancelled");
     // Scheduled, manual, and webhook-triggered automations carry the operator's
@@ -7953,6 +7950,7 @@ async function createSession(workspace = defaultWorkspace, sessionFile, opts = {
     if (allowedAgents?.length && !allowedAgents.includes(rt.id)) {
         throw new Error(`Repository policy does not allow agent ${rt.id}`);
     }
+    await remoteSessionAdmission.admit({ resume: Boolean(requestedSessionFile) && !opts.newSession, internal: opts.ephemeral });
     // Optional git-worktree isolation (fresh sessions only). The agent then runs in
     // the worktree, and the A1 boundary confines writes there.
     let worktree = restoredWorktree;

package/dist/session/fork-standup.js

@@ -215,8 +215,8 @@ export function createForkStandUp(deps) {
         const targetModel = opts.model ?? (targetRuntimeId === bundle.record.runtimeId ? bundle.record.modelRef : undefined);
         const plan = await deps.materializeFork({ bundle, targetRuntime, ctx: { workspace, cwd, model: targetModel }, seed: { transcriptUrl: opts.transcriptUrl } });
         const record = plan.kind === "resume"
-            ? await deps.createSession(cwd, plan.sessionFile, { runtimeId: targetRuntimeId, source: bundle.record.source, sandbox: forkSandbox, makeActive: false })
-            : await deps.createSession(cwd, undefined, { runtimeId: targetRuntimeId, source: bundle.record.source, sandbox: forkSandbox, makeActive: false });
+            ? await deps.createSession(cwd, plan.sessionFile, { runtimeId: targetRuntimeId, source: bundle.record.source, sandbox: forkSandbox, makeActive: false, newSession: true })
+            : await deps.createSession(cwd, undefined, { runtimeId: targetRuntimeId, source: bundle.record.source, sandbox: forkSandbox, makeActive: false, newSession: true });
         // Mark the new session as a fork of its source, so the run card can show
         // "Forked from …" and the lineage survives a reload (persisted below).
         record.forkedFrom = bundle.record.sourceSessionId;

package/dist/session/remote-session-admission.js

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 Petter André Sjulstad
+import { AsyncLocalStorage } from "node:async_hooks";
+export class RemoteSessionAdmissionError extends Error {
+    code;
+    constructor(message, code = "deployment_policy") {
+        super(message);
+        this.code = code;
+        this.name = "RemoteSessionAdmissionError";
+    }
+}
+/** Scope admission to remote commands and hosted work, not local sessions or
+ * history publication. The scope follows async creation helpers (including
+ * GitHub/Linear), so a new path cannot forget to forward a billing option.
+ * Each creation gets its own slot; retrying the same request reuses those keys.
+ * No plan names or allowances belong in Core.
+ */
+export function createRemoteSessionAdmission(authorize) {
+    const context = new AsyncLocalStorage();
+    return {
+        run(key, work) {
+            return context.run({ key, next: 0 }, work);
+        },
+        async admit(options = {}) {
+            const scope = context.getStore();
+            if (!scope || options.resume || options.internal)
+                return;
+            const key = JSON.stringify([scope.key, scope.next++]);
+            let decision;
+            try {
+                decision = await authorize(key);
+            }
+            catch {
+                throw new RemoteSessionAdmissionError("Remote session admission is temporarily unavailable. Try again shortly.", "extension_unavailable");
+            }
+            if (decision.allowed !== true) {
+                throw new RemoteSessionAdmissionError(decision.reason || "New remote sessions are unavailable for this account.", decision.code);
+            }
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bivy/bivy",
-  "version": "0.16.10-staging.1",
+  "version": "0.16.10-staging.3",
   "type": "module",
   "license": "AGPL-3.0-only",
   "description": "Run coding agents on machines you own. Open-source, self-hostable agent workspace.",