@bivy/bivy 0.16.10-staging.2 → 0.16.10-staging.4

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/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.2",
+  "version": "0.16.10-staging.4",
   "type": "module",
   "license": "AGPL-3.0-only",
   "description": "Run coding agents on machines you own. Open-source, self-hostable agent workspace.",