@bivy/bivy 0.16.18-staging.13 → 0.16.18-staging.2

package/dist/agents/claude-code/runtime.js

@@ -12,7 +12,6 @@
 //     permission callback, which maps cleanly onto our generic `toolInterceptor`.
 //   * The SDK is loaded with a dynamic import so it stays an *optional*
 //     dependency: a Bivy install only needs it when this runtime is selected.
-import { withSessionCredentials, credentialEnvFallback } from "../../credentials/session.js";
 import { createRequire } from "node:module";
 import { randomUUID } from "node:crypto";
 import { EventEmitter } from "node:events";
@@ -783,7 +782,7 @@ class ClaudeSession {
     async interactiveTuiCommand() {
         if (!claudeCliAvailable())
             return null;
-        const env = await this.resolveCredentialEnv().catch(credentialEnvFallback);
+        const env = await this.resolveCredentialEnv().catch(() => ({}));
         return { command: "claude", args: ["--resume", this.sessionFile], env };
     }
     getMessages() {
@@ -957,7 +956,7 @@ class ClaudeSession {
         if (this.query)
             return this.refreshSupportedModels();
         try {
-            const env = { ...process.env, ...depCacheEnv(this.cwd), ...this.runtimeOptions.env, ...(await this.resolveCredentialEnv().catch(credentialEnvFallback)) };
+            const env = { ...process.env, ...depCacheEnv(this.cwd), ...this.runtimeOptions.env, ...(await this.resolveCredentialEnv().catch(() => ({}))) };
             if (anthropicCredentialPreflight(env))
                 return; // no credential — keep FALLBACK_MODELS
             await this.ensureStarted();
@@ -990,7 +989,7 @@ class ClaudeSession {
             // refresh it immediately even if its expiry claims it is still valid.
             // The resolver compares this under the vault lock, making concurrent
             // failures converge on one rotation.
-            const credEnv = await this.resolveCredentialEnv(rejectedToken).catch(credentialEnvFallback);
+            const credEnv = await this.resolveCredentialEnv(rejectedToken).catch(() => ({}));
             const nextToken = authTokenFromEnv(credEnv);
             if (!nextToken || nextToken === this.spawnedToken)
                 return false;
@@ -1040,8 +1039,8 @@ class ClaudeSession {
         try {
             cred = await store.getCredential(provider, { workspace: this.cwd, ...(rejectedToken ? { rejectedToken } : {}) });
         }
-        catch (error) {
-            return credentialEnvFallback(error);
+        catch {
+            return {};
         }
         if (!cred)
             return {};
@@ -1315,7 +1314,7 @@ class ClaudeSession {
         // reach the SDK, surface an actionable message instead of letting it spawn
         // and fail its first request with an opaque `401 Unauthorized`.
         if (!this.query) {
-            const env = { ...process.env, ...depCacheEnv(this.cwd), ...this.runtimeOptions.env, ...(await this.resolveCredentialEnv().catch(credentialEnvFallback)) };
+            const env = { ...process.env, ...depCacheEnv(this.cwd), ...this.runtimeOptions.env, ...(await this.resolveCredentialEnv().catch(() => ({}))) };
             const preflightError = anthropicCredentialPreflight(env);
             if (preflightError) {
                 this.messages.push({ role: "user", content: hasImages ? content : prompt, timestamp: Date.now() });
@@ -1508,12 +1507,12 @@ export class ClaudeCodeRuntime {
         return [{ id: "anthropic", name: "Anthropic", oauth: true, models: FALLBACK_MODELS }];
     }
     async createSession(options) {
-        const session = new ClaudeSession(await withSessionCredentials(this.options, options.credentialLabels), options.workspace, options.toolInterceptor, options.toolProvider);
+        const session = new ClaudeSession(this.options, options.workspace, options.toolInterceptor, options.toolProvider);
         this.sessions.push(session);
         return { session };
     }
     async openSession(options) {
-        const session = new ClaudeSession(await withSessionCredentials(this.options, options.credentialLabels), options.workspace, options.toolInterceptor, options.toolProvider, options.sessionFile);
+        const session = new ClaudeSession(this.options, options.workspace, options.toolInterceptor, options.toolProvider, options.sessionFile);
         this.sessions.push(session);
         return {
             session,

package/dist/agents/pi/runtime.js

@@ -188,8 +188,7 @@ class PiSession {
      */
     async interactiveTuiCommand() {
         const file = this.sessionFile;
-        // The shared native auth.json cannot represent a session-local assignment.
-        if (!file || Object.keys(this.tui.credentialLabels ?? {}).length)
+        if (!file)
             return null;
         // Pi's own TUI reads its plaintext auth.json store, so project the vault to
         // disk (refreshed) for the hand-off. Best-effort: an empty auth.json just
@@ -424,7 +423,7 @@ export class PiRuntime {
                 modelsPath: path.join(piDir, "models.json"),
                 allowModelNetwork,
             })
-            : await createPiModelRuntime({ credsDir, piDir, allowModelNetwork, workspace: sessionManager.getCwd() || options.workspace, credentialLabels: options.credentialLabels });
+            : await createPiModelRuntime({ credsDir, piDir, allowModelNetwork });
         const backgroundShells = new BackgroundShellTracker();
         const createRuntime = async ({ cwd, agentDir, sessionManager, sessionStartEvent }) => {
             const sessionId = sessionManager.getSessionId();
@@ -452,7 +451,6 @@ export class PiRuntime {
             sessionManager,
         });
         const tui = {
-            credentialLabels: options.credentialLabels,
             credsDir,
             piDir,
             sessionsDir: this.options.sessionsDir,

package/dist/credentials/resolver.js

@@ -10,13 +10,23 @@
 //
 // This keeps Bivy's hot credential path decoupled from Pi: Pi is just another
 // agent that reads the same store.
+import path from "node:path";
 import { createCredentialVault } from "./store.js";
-import { selectCredential } from "./selection.js";
-export { projectIdsFromWorkspace } from "./selection.js";
+import { resolveCredential } from "./records.js";
 import { loadPresets, defaultPresetsPath } from "./presets.js";
-import { credentialEnvFallback } from "./session.js";
 /** Refresh an OAuth token this many ms before it expires (clock-skew guard). */
 const OAUTH_REFRESH_SKEW_MS = 60_000;
+/** Stable project identifiers discoverable without importing repo/session code. */
+export function projectIdsFromWorkspace(workspace) {
+    const resolved = path.resolve(workspace);
+    const ids = new Set([resolved, path.basename(resolved)]);
+    for (const part of resolved.split(path.sep)) {
+        const split = part.indexOf("__");
+        if (split > 0 && split < part.length - 2)
+            ids.add(`${part.slice(0, split)}/${part.slice(split + 2)}`);
+    }
+    return [...ids];
+}
 /** Resolver over Bivy's credential store, with OAuth refresh-on-read via the bridge. */
 export class NodeCredentialResolver {
     credsDir;
@@ -49,7 +59,14 @@ export class NodeCredentialResolver {
         // than guessing.
         const records = await this.store.listRecords().catch(() => []);
         const presets = this.presets();
-        const selection = selectCredential(id, records, presets, context);
+        // Project assignments are ordinary preset mappings named `project:<id>`.
+        // Bivy-managed clones encode owner/repo as owner__repo in their workspace
+        // path; direct local workspaces also match their absolute path/basename.
+        const explicitProject = context?.project?.trim();
+        const workspace = context?.workspace?.trim();
+        const projectCandidates = [explicitProject, ...(workspace ? projectIdsFromWorkspace(workspace) : [])].filter((value) => Boolean(value));
+        const projectPreset = projectCandidates.map((value) => `project:${value}`).find((name) => presets.presets?.[name]?.[id]);
+        const selection = resolveCredential(id, records, presets, { ...(projectPreset ? { preset: projectPreset } : {}), ...(context?.preferLabel ? { preferLabel: context.preferLabel } : {}) });
         if (!selection)
             return undefined;
         const source = selection.record.source;
@@ -167,20 +184,11 @@ export async function buildAgentCredentialEnv(store, providers, activeProvider,
         try {
             cred = await store.getCredential(id, workspace ? { workspace } : undefined);
         }
-        catch (error) {
-            credentialEnvFallback(error);
+        catch {
             continue;
         }
         if (!cred)
             continue;
-        // Session-pinned Anthropic auth clears the competing ambient login even
-        // when the agent has not advertised its active model provider yet.
-        if (cred.provider === "anthropic" && cred.env) {
-            for (const key of ["ANTHROPIC_API_KEY", "CLAUDE_CODE_OAUTH_TOKEN"]) {
-                if (cred.env[key] === "")
-                    env[key] = "";
-            }
-        }
         const isActive = !!active && cred.provider === active;
         if (cred.kind === "oauth") {
             // OAuth *subscription* tokens are provider-specific and are not accepted

package/dist/runtime/agent-service.js

@@ -135,8 +135,8 @@ export class AgentService {
             const toolProvider = message.options.toolSpecs?.length ? this.makeToolProvider(svc, message.options.toolSpecs) : undefined;
             const workspace = message.options.workspace ?? process.cwd();
             const result = message.op === "open" && message.options.sessionFile
-                ? await runtime.openSession({ workspace, credentialLabels: message.options.credentialLabels, sessionFile: message.options.sessionFile, toolInterceptor, toolProvider })
-                : await runtime.createSession({ workspace, credentialLabels: message.options.credentialLabels, toolInterceptor, toolProvider });
+                ? await runtime.openSession({ workspace, sessionFile: message.options.sessionFile, toolInterceptor, toolProvider })
+                : await runtime.createSession({ workspace, toolInterceptor, toolProvider });
             svc.session = result.session;
             svc.id = result.session.id;
             svc.lastSent = this.mirror(result.session);

package/dist/runtime/oauth/model-oauth-providers.js

@@ -7,8 +7,8 @@
 // not guesses. Owning these lets Bivy run the OAuth login + token refresh itself,
 // so no credential operation depends on Pi.
 //
-// Covered (fully Bivy-owned): Anthropic (Claude Pro/Max), OpenAI Codex (ChatGPT;
-// device-code), xAI (Grok). GitHub Copilot (two-stage token + dynamic base URL entangled with
+// Covered (fully Bivy-owned): Anthropic (Claude Pro/Max), OpenAI Codex (ChatGPT),
+// xAI (Grok). GitHub Copilot (two-stage token + dynamic base URL entangled with
 // Pi's request layer) and Radius (self-describing gateway) are intentionally not
 // reimplemented here.
 /** Anthropic uses a JSON token body; OpenAI/xAI use form-encoded. */
@@ -17,16 +17,12 @@ export const MODEL_OAUTH_PROVIDERS = {
         id: "anthropic",
         displayName: "Anthropic (Claude Pro/Max)",
         clientId: "9d1c250a-e61b-44d9-88ed-5944d1962f5e",
-        // Claude Code's `setup-token` flow avoids localhost entirely: Anthropic hosts
-        // the callback page and shows a code the user can paste back into Bivy. The
-        // resulting long-lived token is inference-only, which is exactly what agent
-        // model requests need and works well from a remote PWA/headless node.
-        scopes: "user:inference",
+        scopes: "org:create_api_key user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload",
         flow: "auth_code",
         tokenEncoding: "json",
-        authorizeUrl: "https://claude.com/cai/oauth/authorize",
+        authorizeUrl: "https://claude.ai/oauth/authorize",
         tokenUrl: "https://platform.claude.com/v1/oauth/token",
-        redirectUri: "https://platform.claude.com/oauth/code/callback",
+        callback: { port: 53692, path: "/callback", redirectHost: "localhost" },
         authorizeParams: { code: "true" },
         stateIsVerifier: true,
         refreshSkewMs: 5 * 60 * 1000,
@@ -37,13 +33,11 @@ export const MODEL_OAUTH_PROVIDERS = {
         displayName: "OpenAI (ChatGPT Plus/Pro)",
         clientId: "app_EMoamEEZ73f0CkXaXp7hrann",
         scopes: "openid profile email offline_access",
-        flow: "openai_codex_device_code",
+        flow: "auth_code",
         tokenEncoding: "form",
         authorizeUrl: "https://auth.openai.com/oauth/authorize",
         tokenUrl: "https://auth.openai.com/oauth/token",
         callback: { port: 1455, path: "/auth/callback", redirectHost: "localhost" },
-        deviceAuthUrl: "https://auth.openai.com/api/accounts/deviceauth/usercode",
-        deviceTokenUrl: "https://auth.openai.com/api/accounts/deviceauth/token",
         authorizeParams: {
             id_token_add_organizations: "true",
             codex_cli_simplified_flow: "true",

package/dist/runtime/oauth/model-oauth.js

@@ -199,7 +199,7 @@ function startCallbackServer(host, port, pathName, expectedState, signal) {
 async function loginAuthCode(provider, interaction) {
     const { verifier, challenge } = createPkce();
     const state = provider.stateIsVerifier ? verifier : randomBytes(16).toString("hex");
-    const redirectUri = provider.redirectUri ?? `http://${provider.callback.redirectHost}:${provider.callback.port}${provider.callback.path}`;
+    const redirectUri = `http://${provider.callback.redirectHost}:${provider.callback.port}${provider.callback.path}`;
     const authorizeUrl = buildAuthorizeUrl(provider, { challenge, state, redirectUri });
     interaction.notify({
         type: "auth_url",
@@ -300,88 +300,6 @@ async function loginDeviceCode(provider, interaction) {
         return tokensFrom(provider, payload);
     }
 }
-async function postJsonObject(url, body, signal) {
-    const res = await fetch(url, {
-        method: "POST",
-        headers: { "content-type": "application/json", accept: "application/json" },
-        body: JSON.stringify(body),
-        signal,
-    });
-    const text = await res.text();
-    let payload = {};
-    try {
-        payload = JSON.parse(text);
-    }
-    catch { /* non-JSON error body */ }
-    return { status: res.status, ok: res.ok, payload, text };
-}
-function nestedOAuthErrorCode(payload) {
-    const error = payload.error;
-    if (typeof error === "string")
-        return error;
-    if (error && typeof error === "object") {
-        const code = error.code;
-        return typeof code === "string" ? code : "";
-    }
-    return "";
-}
-async function loginOpenAICodexDeviceCode(provider, interaction) {
-    const started = await postJsonObject(provider.deviceAuthUrl, { client_id: provider.clientId }, interaction.signal);
-    if (!started.ok)
-        throw new Error(`OpenAI Codex device authorization failed (${started.status}): ${started.text.slice(0, 200)}`);
-    const deviceAuthId = typeof started.payload.device_auth_id === "string" ? started.payload.device_auth_id : "";
-    const userCode = typeof started.payload.user_code === "string" ? started.payload.user_code : "";
-    const rawInterval = Number(started.payload.interval);
-    const interval = Number.isFinite(rawInterval) && rawInterval >= 0 ? rawInterval : 5;
-    if (!deviceAuthId || !userCode)
-        throw new Error(`Invalid OpenAI Codex device authorization response: ${JSON.stringify(started.payload)}`);
-    const expiresInSeconds = 15 * 60;
-    interaction.notify({
-        type: "device_code",
-        userCode,
-        verificationUri: "https://auth.openai.com/codex/device",
-        intervalSeconds: interval,
-        expiresInSeconds,
-    });
-    const deadline = Date.now() + expiresInSeconds * 1000;
-    let authorizationCode = "";
-    let codeVerifier = "";
-    let waitMs = interval * 1000;
-    await sleep(waitMs);
-    while (Date.now() <= deadline) {
-        if (interaction.signal?.aborted)
-            throw new Error("Login aborted");
-        const polled = await postJsonObject(provider.deviceTokenUrl, { device_auth_id: deviceAuthId, user_code: userCode }, interaction.signal);
-        if (polled.ok) {
-            authorizationCode = typeof polled.payload.authorization_code === "string" ? polled.payload.authorization_code : "";
-            codeVerifier = typeof polled.payload.code_verifier === "string" ? polled.payload.code_verifier : "";
-            if (!authorizationCode || !codeVerifier)
-                throw new Error(`Invalid OpenAI Codex device token response: ${JSON.stringify(polled.payload)}`);
-            break;
-        }
-        const errorCode = nestedOAuthErrorCode(polled.payload);
-        if (polled.status === 403 || polled.status === 404 || errorCode === "deviceauth_authorization_pending") {
-            await sleep(waitMs);
-            continue;
-        }
-        if (errorCode === "slow_down") {
-            waitMs += 5000;
-            await sleep(waitMs);
-            continue;
-        }
-        throw new Error(`OpenAI Codex device authorization failed (${polled.status}): ${polled.text.slice(0, 200)}`);
-    }
-    if (!authorizationCode || !codeVerifier)
-        throw new Error("OpenAI Codex device login timed out. Please try again.");
-    const payload = await postToken(provider.tokenUrl, provider.tokenEncoding, {
-        grant_type: "authorization_code",
-        client_id: provider.clientId,
-        code: authorizationCode,
-        code_verifier: codeVerifier,
-        redirect_uri: "https://auth.openai.com/deviceauth/callback",
-    });
-    return tokensFrom(provider, payload);
-}
 // --- Public API --------------------------------------------------------------
 /** Provider ids Bivy can natively drive a subscription login for. */
 export { isNativeOAuthProvider, nativeOAuthProviderIds } from "./model-oauth-providers.js";
@@ -394,9 +312,7 @@ export async function loginModelOAuth(credsDir, providerId, interaction, label =
     const provider = getModelOAuthProvider(providerId);
     if (!provider)
         throw new Error(`Provider "${providerId}" does not support subscription login`);
-    const tokens = provider.flow === "device_code" ? await loginDeviceCode(provider, interaction)
-        : provider.flow === "openai_codex_device_code" ? await loginOpenAICodexDeviceCode(provider, interaction)
-            : await loginAuthCode(provider, interaction);
+    const tokens = provider.flow === "device_code" ? await loginDeviceCode(provider, interaction) : await loginAuthCode(provider, interaction);
     const credential = { type: "oauth", access: tokens.access, refresh: tokens.refresh, expires: tokens.expires, refreshedAt: tokens.refreshedAt, ...(tokens.accountId ? { accountId: tokens.accountId } : {}) };
     await createCredentialVault(credsDir).modifyRecord(providerId, label, async () => credential);
 }

package/dist/runtime/pi-oauth.js

@@ -11,7 +11,6 @@
 import path from "node:path";
 import { createCredentialVault } from "./credential-store.js";
 import { isNativeOAuthProvider } from "./oauth/model-oauth-providers.js";
-import { selectedCredentialStore } from "../credentials/selected-store.js";
 /** Adapt Bivy's store to pi-ai's structurally-identical CredentialStore for injection. */
 export function piCredentialStore(store) {
     return store;
@@ -26,11 +25,8 @@ export function piCredentialStore(store) {
 export async function createPiModelRuntime(opts) {
     const store = opts.store ?? createCredentialVault(opts.credsDir);
     const { ModelRuntime } = await import("@earendil-works/pi-coding-agent");
-    const selected = selectedCredentialStore(store, opts.credsDir, { workspace: opts.workspace, credentialLabels: opts.credentialLabels });
-    for (const provider of Object.keys(opts.credentialLabels ?? {}))
-        await selected.read(provider);
     return ModelRuntime.create({
-        credentials: piCredentialStore(selected),
+        credentials: piCredentialStore(store),
         modelsPath: path.join(opts.piDir, "models.json"),
         allowModelNetwork: opts.allowModelNetwork ?? false,
     });

package/dist/runtime/process.js

@@ -5,7 +5,6 @@ import { randomUUID } from "node:crypto";
 import { EventEmitter } from "node:events";
 import { stripAnsi } from "./ansi.js";
 import { buildAgentCredentialEnv } from "./credentials.js";
-import { withSessionCredentials, credentialEnvFallback } from "../credentials/session.js";
 import { egressEnv, sessionEgressEnv } from "../harness/egress.js";
 import { depCacheEnv } from "../harness/dep-cache.js";
 import { bivySessionEnv } from "./session-env.js";
@@ -305,7 +304,7 @@ class ProcessSession {
         // added after this session started) reach the agent. The vault wins over any
         // ambient key so Bivy's shared sign-in is authoritative.
         const credentialEnv = this.runtimeOptions.credentials
-            ? await buildAgentCredentialEnv(this.runtimeOptions.credentials, undefined, this.currentModelProvider, this.cwd).catch(credentialEnvFallback)
+            ? await buildAgentCredentialEnv(this.runtimeOptions.credentials, undefined, this.currentModelProvider, this.cwd).catch(() => ({}))
             : {};
         // Optional prepare step (e.g. Codex materializes its auth.json from the vault
         // and pins CODEX_HOME). Runs after credentials, before preflight/spawn; its
@@ -531,7 +530,7 @@ export class ProcessRuntime {
         return [...byProvider.values()];
     }
     async createSession(options) {
-        const session = new ProcessSession(await withSessionCredentials(this.options, options.credentialLabels), options.workspace);
+        const session = new ProcessSession(this.options, options.workspace);
         this.sessions.push(session);
         return { session, warning: "Generic CLI runtime streams stdout/stderr only; approvals, model picker, and resume depend on the underlying agent protocol." };
     }
@@ -539,7 +538,7 @@ export class ProcessRuntime {
         // Resumable runtimes bind the agent's session id so each prompt continues it
         // (see resumeArgs); non-resumable ones ignore the ref and start fresh.
         if (this.options.resumable) {
-            const session = new ProcessSession(await withSessionCredentials(this.options, options.credentialLabels), options.workspace, options.sessionFile);
+            const session = new ProcessSession(this.options, options.workspace, options.sessionFile);
             this.sessions.push(session);
             return { session };
         }

package/dist/runtime/protocol.js

@@ -4,7 +4,6 @@ import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { EventEmitter } from "node:events";
 import { buildAgentCredentialEnv } from "./credentials.js";
-import { withSessionCredentials, credentialEnvFallback } from "../credentials/session.js";
 import { bivySessionEnv } from "./session-env.js";
 import { mergeAgentCommands } from "./slash-commands.js";
 import { withExactCapabilitySurface } from "./types.js";
@@ -319,7 +318,7 @@ class ProtocolSession {
         if (!hook)
             return null;
         const credentialEnv = this.runtimeOptions.credentials
-            ? await buildAgentCredentialEnv(this.runtimeOptions.credentials, undefined, this.currentModelProvider, this.cwd).catch(credentialEnvFallback)
+            ? await buildAgentCredentialEnv(this.runtimeOptions.credentials, undefined, this.currentModelProvider, this.cwd).catch(() => ({}))
             : {};
         let prepareEnv = this.prepareEnv;
         if (this.runtimeOptions.prepare) {
@@ -341,7 +340,7 @@ class ProtocolSession {
         if (this.child)
             return;
         const credentialEnv = this.runtimeOptions.credentials
-            ? await buildAgentCredentialEnv(this.runtimeOptions.credentials, undefined, this.currentModelProvider, this.cwd).catch(credentialEnvFallback)
+            ? await buildAgentCredentialEnv(this.runtimeOptions.credentials, undefined, this.currentModelProvider, this.cwd).catch(() => ({}))
             : {};
         // Optional prepare step, run before the child spawns because a shim reads its
         // credential at launch (e.g. Codex mints ~/.codex/auth.json from the vault and
@@ -441,7 +440,7 @@ class ProtocolSession {
         if (!this.runtimeOptions.prepare && !this.runtimeOptions.preflight)
             return undefined;
         const credentialEnv = this.runtimeOptions.credentials
-            ? await buildAgentCredentialEnv(this.runtimeOptions.credentials, undefined, this.currentModelProvider, this.cwd).catch(credentialEnvFallback)
+            ? await buildAgentCredentialEnv(this.runtimeOptions.credentials, undefined, this.currentModelProvider, this.cwd).catch(() => ({}))
             : {};
         if (this.runtimeOptions.prepare) {
             this.prepareEnv =
@@ -994,7 +993,7 @@ export class ProtocolRuntime {
         return this.options.catalog ?? [];
     }
     async createSession(options) {
-        const session = new ProtocolSession(await withSessionCredentials(this.options, options.credentialLabels), options.workspace, this.capabilities, options.toolInterceptor);
+        const session = new ProtocolSession(this.options, options.workspace, this.capabilities, options.toolInterceptor);
         try {
             await session.start();
             this.sessions.push(session);
@@ -1011,7 +1010,7 @@ export class ProtocolRuntime {
         // Adopt the caller's canonical id (a reopen of a known session) so the
         // resumed session keeps its original id instead of taking `sessionFile` (the
         // agent's own ref) as its id — see OpenSessionOptions.canonicalId.
-        const session = new ProtocolSession(await withSessionCredentials(this.options, options.credentialLabels), options.workspace, this.capabilities, options.toolInterceptor, options.sessionFile, options.canonicalId);
+        const session = new ProtocolSession(this.options, options.workspace, this.capabilities, options.toolInterceptor, options.sessionFile, options.canonicalId);
         try {
             await session.start();
             if (!this.options.resumable && !this.capabilities.resume) {

package/dist/runtime/remote.js

@@ -543,12 +543,12 @@ export class RemoteRuntime {
     async createSession(options) {
         const transport = await this.config.connect();
         const toolSpecs = options.toolProvider?.list();
-        return startRemoteSession(transport, { runtime: this.id, sandbox: this.config.sandbox, op: "create", options: { credentialLabels: options.credentialLabels, workspace: options.workspace, hasToolInterceptor: Boolean(options.toolInterceptor), ...(toolSpecs?.length ? { toolSpecs } : {}) } }, { toolInterceptor: options.toolInterceptor, toolProvider: options.toolProvider });
+        return startRemoteSession(transport, { runtime: this.id, sandbox: this.config.sandbox, op: "create", options: { workspace: options.workspace, hasToolInterceptor: Boolean(options.toolInterceptor), ...(toolSpecs?.length ? { toolSpecs } : {}) } }, { toolInterceptor: options.toolInterceptor, toolProvider: options.toolProvider });
     }
     async openSession(options) {
         const transport = await this.config.connect();
         const toolSpecs = options.toolProvider?.list();
-        return startRemoteSession(transport, { runtime: this.id, sandbox: this.config.sandbox, op: "open", options: { credentialLabels: options.credentialLabels, workspace: options.workspace, sessionFile: options.sessionFile, hasToolInterceptor: Boolean(options.toolInterceptor), ...(toolSpecs?.length ? { toolSpecs } : {}) } }, { toolInterceptor: options.toolInterceptor, toolProvider: options.toolProvider });
+        return startRemoteSession(transport, { runtime: this.id, sandbox: this.config.sandbox, op: "open", options: { workspace: options.workspace, sessionFile: options.sessionFile, hasToolInterceptor: Boolean(options.toolInterceptor), ...(toolSpecs?.length ? { toolSpecs } : {}) } }, { toolInterceptor: options.toolInterceptor, toolProvider: options.toolProvider });
     }
     /**
      * Re-attach to a session already live on the agent service (Stage 2 routing).

package/dist/server.js

@@ -36,7 +36,6 @@ import { InMemoryLocationRegistry } from "./runtime/location-registry.js";
 import { ControlPlaneSessionLocationRegistry, LayeredSessionLocationRegistry } from "./runtime/control-plane-location.js";
 import { attachAdoptedSessions, classifyAttachFailure } from "./runtime/adoption.js";
 import { createCredentialStore, testProviderCredential } from "./runtime/credentials.js";
-import { decodeAutomationTemplate } from "./automation-template.js";
 import { isModelAuthError, authProviderForSession, classifyModelAuthError } from "./runtime/auth-errors.js";
 import { createCredentialVault, migrateVaultDir } from "./runtime/credential-store.js";
 import { probeAnthropicAccess } from "./runtime/anthropic-preflight.js";
@@ -4137,7 +4136,6 @@ async function runIssueTaskInner(cfg, issue, source, overrides = {}) {
     // which now adopts the existing remote branch rather than colliding.
     const existing = findIssueSession(source);
     if (existing?.worktree && fs.existsSync(existing.worktree.path)) {
-        assertSessionAccounts(existing, overrides.credentialLabels);
         const currentSandbox = existing.sandbox ?? sandboxTier();
         const safety = projectSafety(existing.worktree.path, overrides.sandbox ?? currentSandbox, overrides.approvalMode);
         if (safety.sandbox !== currentSandbox) {
@@ -4210,7 +4208,6 @@ async function runIssueTaskInner(cfg, issue, source, overrides = {}) {
         runtimeId: directives.runtimeId,
         sandbox: safety.sandbox,
         approvalMode: safety.approval,
-        credentialLabels: overrides.credentialLabels,
     });
     record.githubIssueUrl = `https://github.com/${cfg.owner}/${cfg.repo}/issues/${issue.number}`;
     // Title the session from the issue up front so it never shows as "Untitled
@@ -4808,11 +4805,6 @@ function linearSessionSource(externalId) {
  * starting, and return false so the caller falls through. Returns true only when
  * it fully handled the item.
  */
-function assertSessionAccounts(record, labels) {
-    if (Object.entries(labels ?? {}).some(([provider, label]) => record.credentialLabels?.[provider] !== label)) {
-        throw new Error("This session uses different provider accounts; start a new session to use the automation's selections");
-    }
-}
 async function continueCorrelatedSession(item, prompt, report, opts) {
     if (item.targetKind !== "existing_session" || !item.targetSessionId)
         return false;
@@ -4839,7 +4831,6 @@ async function continueCorrelatedSession(item, prompt, report, opts) {
         }
         return false;
     }
-    assertSessionAccounts(record, opts?.credentialLabels);
     const branch = record.worktree?.branch;
     if (opts?.resumeOnMissing) {
         // Durable work targeting an existing Session waits for its current turn to
@@ -4917,16 +4908,13 @@ async function executeWorkItem(item, report, signal) {
     // assigned node can read. The envelope prefix is Bivy's own and never appears
     // on issue/Slack/Linear bodies, so decrypt whenever it's present regardless of
     // source.
-    let credentialLabels;
     if (item.body?.startsWith("bivy-room-v1:")) {
         const [, nodeId, ...payload] = item.body.split(":");
         if (nodeId !== identity.nodeId || payload.length === 0) {
             throw new Error("automation instructions were encrypted for a different node");
         }
         try {
-            const template = decodeAutomationTemplate(open(pairingStore.roomKey(), payload.join(":")));
-            credentialLabels = template.credentialLabels;
-            item = { ...item, body: template.instructions };
+            item = { ...item, body: open(pairingStore.roomKey(), payload.join(":")) };
         }
         catch {
             throw new Error("could not decrypt automation instructions on this node");
@@ -4995,7 +4983,6 @@ async function executeWorkItem(item, report, signal) {
         await runIssueTask(cfg, issue, {
             runtimeId: item.runtimeId,
             model: item.model,
-            credentialLabels,
             sandbox: normalizeSandboxTier(item.sandbox),
             approvalMode: approvalModeFrom(item.approvalMode),
             onEvidence: report,
@@ -5020,7 +5007,7 @@ async function executeWorkItem(item, report, signal) {
             throw new Error(`Linear work item has an invalid repo "${repoSlug}"`);
         // Case B: a re-dispatch the control plane correlated to an existing session
         // continues it as a normal chat instead of starting cold (mirrors GitHub).
-        if (await continueCorrelatedSession(item, buildLinearTaskPrompt(issue, item.body), report, { resumeOnMissing: item.targetKind === "existing_session", signal, credentialLabels }))
+        if (await continueCorrelatedSession(item, buildLinearTaskPrompt(issue, item.body), report, { resumeOnMissing: item.targetKind === "existing_session", signal }))
             return;
         const githubToken = await resolveGitHubToken();
         if (!githubToken)
@@ -5036,7 +5023,6 @@ async function executeWorkItem(item, report, signal) {
             makeActive: false,
             source: linearSessionSource(item.externalId),
             runtimeId: item.runtimeId || nodeConfiguredDefaultAgent(),
-            credentialLabels,
             sandbox: safety.sandbox,
             approvalMode: safety.approval,
         });
@@ -5082,7 +5068,7 @@ async function executeWorkItem(item, report, signal) {
     // Scheduled runs targeting an existing session are STRICT: the message must
     // land in that session (resumed from disk if needed), never silently in a new
     // one — so a session that can't be resumed fails the run instead.
-    if (await continueCorrelatedSession(item, request, report, { resumeOnMissing: item.source === "schedule" || item.targetKind === "existing_session", isMessage, signal, credentialLabels }))
+    if (await continueCorrelatedSession(item, request, report, { resumeOnMissing: item.source === "schedule" || item.targetKind === "existing_session", isMessage, signal }))
         return;
     const requestedSandbox = normalizeSandboxTier(item.sandbox);
     // Prepare an explicit repository before resolving its policy. Otherwise a
@@ -5098,7 +5084,6 @@ async function executeWorkItem(item, report, signal) {
     const sessionOpts = {
         makeActive: false,
         title: item.title,
-        credentialLabels,
         runtimeId: item.runtimeId,
         sandbox,
     };
@@ -6318,7 +6303,6 @@ function persistSessionMetadata(record, status = sessionStatus(record)) {
         delegationDepth: record.delegationDepth,
         runtimeId: record.runtimeId,
         sandbox: record.sandbox,
-        credentialLabels: record.credentialLabels,
         agentName: getRuntime(record.runtimeId).displayName,
         contract: record.contract,
         status,
@@ -7586,7 +7570,7 @@ async function refreshRecordAfterTui(record) {
         const workspace = record.worktree?.path || oldSession.cwd || record.workspace;
         // Refreshing an EXISTING record: its id is already known, so attach_to_chat
         // (see toolProvider's SessionIdRef doc) can be wired live, not deferred.
-        const runtimeSessionOptions = { credentialLabels: record.credentialLabels, workspace, toolProvider: integrations.toolProvider({ current: record.id }), ...(rt.capabilities.toolInterception ? { toolInterceptor: guardianInterceptor } : {}) };
+        const runtimeSessionOptions = { workspace, toolProvider: integrations.toolProvider({ current: record.id }), ...(rt.capabilities.toolInterception ? { toolInterceptor: guardianInterceptor } : {}) };
         const { session, warning } = await runtimeHost.openSession(rt, { ...runtimeSessionOptions, sessionFile: record.sessionFile });
         record.session = session;
         record.sessionFile = session.sessionFile ?? record.sessionFile;
@@ -7821,7 +7805,6 @@ async function recoverRecordAfterAbort(record) {
         const workspace = record.worktree?.path || oldSession.cwd || record.workspace;
         const runtimeSessionOptions = {
             workspace,
-            credentialLabels: record.credentialLabels,
             toolProvider: integrations.toolProvider({ current: record.id }),
             ...(rt.capabilities.toolInterception ? { toolInterceptor: guardianInterceptor } : {}),
         };
@@ -7921,7 +7904,6 @@ async function createSession(workspace = defaultWorkspace, sessionFile, opts = {
     const restoredWorktree = requestedSessionFile ? restoredWorktreeFromMetadata(storedMeta) : undefined;
     const existing = requestedSessionFile ? (openSessions.get(requestedSessionFile) ?? (storedMeta?.id ? openSessions.get(storedMeta.id) : undefined)) : undefined;
     if (existing) {
-        assertSessionAccounts(existing, opts.credentialLabels);
         // Reopening an already-open session must NOT bump its last-active time —
         // that only tracks real user/agent activity, not focus. (Was touchSession.)
         if (makeActive)
@@ -8011,8 +7993,7 @@ async function createSession(workspace = defaultWorkspace, sessionFile, opts = {
     // built now, up front — so hand it this box instead of a session id and fill
     // `.current` in the moment `sessionId` is (see toolProvider's SessionIdRef doc).
     const attachSessionIdRef = {};
-    const credentialLabels = opts.credentialLabels ?? storedMeta?.credentialLabels;
-    const runtimeSessionOptions = { credentialLabels, workspace: runtimeWorkspace, toolProvider: integrations.toolProvider(attachSessionIdRef), ...(rt.capabilities.toolInterception ? { toolInterceptor: guardianInterceptor } : {}) };
+    const runtimeSessionOptions = { workspace: runtimeWorkspace, toolProvider: integrations.toolProvider(attachSessionIdRef), ...(rt.capabilities.toolInterception ? { toolInterceptor: guardianInterceptor } : {}) };
     // Stage 2/3: prefer re-attaching to a still-live remote session — routed to its
     // OWN agent service — over re-opening a fresh copy from disk. Falls back to
     // open/create when nothing live is there.
@@ -8073,7 +8054,7 @@ async function createSession(workspace = defaultWorkspace, sessionFile, opts = {
     // Rehydrating (rather than leaving this undefined for a resumed session)
     // also avoids a persistSessionMetadata call later silently clobbering the
     // stored contract with undefined via its `{...prev, ...input}` merge.
-    const record = { id: sessionId, session, runtimeId: rt.id, credentialLabels, sandbox: sessionSandbox, approvalMode: sessionSafety.approval, automationRunId: storedMeta?.automationRunId, delegationDepth: storedMeta?.delegationDepth, workspace: sessionWorkspace, sessionFile: session.sessionFile, agentServiceAddress: attachedAddress ?? rt.agentServiceAddress, worktree, source, prUrl: storedMeta?.prUrl, prs: storedMeta?.prs, contract: storedMeta?.contract, lastTouchedAt: resumedLastActive ?? Date.now(), warning: modelFallbackMessage, ephemeral: opts.ephemeral, workspaceState: runGit(["status", "--porcelain", "--untracked-files=normal"], sessionWorkspace) ? "dirty" : "clean" };
+    const record = { id: sessionId, session, runtimeId: rt.id, sandbox: sessionSandbox, approvalMode: sessionSafety.approval, automationRunId: storedMeta?.automationRunId, delegationDepth: storedMeta?.delegationDepth, workspace: sessionWorkspace, sessionFile: session.sessionFile, agentServiceAddress: attachedAddress ?? rt.agentServiceAddress, worktree, source, prUrl: storedMeta?.prUrl, prs: storedMeta?.prs, contract: storedMeta?.contract, lastTouchedAt: resumedLastActive ?? Date.now(), warning: modelFallbackMessage, ephemeral: opts.ephemeral, workspaceState: runGit(["status", "--porcelain", "--untracked-files=normal"], sessionWorkspace) ? "dirty" : "clean" };
     // Migration: a session resumed/reopened from before this feature (or from a
     // node that predates it) has no stored contract. Stamp an honest one now
     // from currently-observed facts rather than leaving it blank forever or
@@ -8390,7 +8371,7 @@ async function createWorkspaceSession(workspace, opts = {}) {
         await fetchOrigin(workspace);
         return createGitWorkspaceSession(workspace, parsed, opts);
     }
-    const record = await createSession(workspace, undefined, { runtimeId: opts.runtimeId, credentialLabels: opts.credentialLabels, sandbox: opts.sandbox, makeActive: opts.makeActive });
+    const record = await createSession(workspace, undefined, { runtimeId: opts.runtimeId, sandbox: opts.sandbox, makeActive: opts.makeActive });
     applyInitialSessionName(record, opts);
     return record;
 }
@@ -8408,7 +8389,6 @@ async function createGitWorkspaceSession(repoDir, parsed, opts = {}) {
         worktree: { branch, base },
         source: `repo:${parsed.slug}`,
         runtimeId: opts.runtimeId,
-        credentialLabels: opts.credentialLabels,
         sandbox: opts.sandbox,
         makeActive: opts.makeActive,
     });

package/dist/session/run-terminal.js

@@ -345,14 +345,12 @@ export function createRunTerminals(deps) {
         const discover = SESSION_DISCOVERY_BY_AGENT[agent];
         if (!discover)
             return undefined;
-        const attempts = Math.max(1, Math.floor(deps.takeoverDiscoveryAttempts ?? TAKEOVER_DISCOVERY_ATTEMPTS));
-        const delayMs = Math.max(0, Math.floor(deps.takeoverDiscoveryDelayMs ?? TAKEOVER_DISCOVERY_DELAY_MS));
-        for (let attempt = 0; attempt < attempts; attempt++) {
+        for (let attempt = 0; attempt < TAKEOVER_DISCOVERY_ATTEMPTS; attempt++) {
             const ref = await discover(workspace, createdAt);
             if (ref)
                 return ref;
-            if (delayMs > 0 && attempt + 1 < attempts) {
-                await new Promise((resolve) => setTimeout(resolve, delayMs));
+            if (attempt + 1 < TAKEOVER_DISCOVERY_ATTEMPTS) {
+                await new Promise((resolve) => setTimeout(resolve, TAKEOVER_DISCOVERY_DELAY_MS));
             }
         }
         return undefined;

package/dist/terminal.js

@@ -196,8 +196,6 @@ export class TerminalManager {
             env,
         });
         const now = Date.now();
-        let resolveExit;
-        const exitPromise = new Promise((resolve) => { resolveExit = resolve; });
         const entry = {
             proc,
             workspace: options.workspace,
@@ -211,8 +209,6 @@ export class TerminalManager {
             flushTimer: null,
             closed: false,
             onData: options.onData,
-            exitPromise,
-            resolveExit,
         };
         // Register the opener as a sized client so a later, smaller client shrinks
         // the PTY to the min of the two rather than clobbering the opener's size.
@@ -273,12 +269,7 @@ export class TerminalManager {
             flush();
             entry.closed = true;
             this.terminals.delete(id);
-            try {
-                options.onExit(exitCode, signal, entry.buffer);
-            }
-            finally {
-                entry.resolveExit();
-            }
+            options.onExit(exitCode, signal, entry.buffer);
         });
         return id;
     }
@@ -356,19 +347,6 @@ export class TerminalManager {
         const entry = this.terminals.get(id);
         if (!entry)
             return false;
-        this.closeEntry(id, entry);
-        return true;
-    }
-    /** Close a terminal and wait for the underlying PTY process to report exit. */
-    async closeAndWait(id, timeoutMs = 2000) {
-        const entry = this.terminals.get(id);
-        if (!entry)
-            return false;
-        this.closeEntry(id, entry);
-        await waitForExit(entry.exitPromise, timeoutMs);
-        return true;
-    }
-    closeEntry(id, entry) {
         this.terminals.delete(id);
         // Drop any queued output — the client asked to close, so don't emit a
         // trailing batch (which would fire onData for a terminal it has torn down).
@@ -385,6 +363,7 @@ export class TerminalManager {
         catch {
             // already gone
         }
+        return true;
     }
     has(id) {
         return this.terminals.has(id);
@@ -442,28 +421,6 @@ export class TerminalManager {
         for (const id of [...this.terminals.keys()])
             this.close(id);
     }
-    /** Kill every terminal and wait for node-pty to release its child handles. */
-    async disposeAllAndWait(timeoutMs = 2000) {
-        const exits = [];
-        for (const [id, entry] of [...this.terminals]) {
-            this.closeEntry(id, entry);
-            exits.push(waitForExit(entry.exitPromise, timeoutMs));
-        }
-        await Promise.all(exits);
-    }
-}
-async function waitForExit(exitPromise, timeoutMs) {
-    let timer;
-    try {
-        await Promise.race([
-            exitPromise,
-            new Promise((resolve) => { timer = setTimeout(resolve, timeoutMs); }),
-        ]);
-    }
-    finally {
-        if (timer)
-            clearTimeout(timer);
-    }
 }
 function clampDim(value, fallback) {
     const n = Math.floor(Number(value));

package/package.json

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

package/dist/automation-template.js

@@ -1,21 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-only
-// Wire format mirrored in src/automation-template.ts (node has no core dependency).
-const PREFIX = "bivy-automation-v1\n";
-/** Account labels, never credentials, travel inside the encrypted template. */
-export function encodeAutomationTemplate(instructions, credentialLabels) {
-    return Object.keys(credentialLabels).length || instructions.startsWith(PREFIX)
-        ? PREFIX + JSON.stringify({ instructions, credentialLabels })
-        : instructions;
-}
-/** Legacy plaintext templates remain valid. Malformed structured templates fail closed. */
-export function decodeAutomationTemplate(value) {
-    if (!value.startsWith(PREFIX))
-        return { instructions: value, credentialLabels: {} };
-    const data = JSON.parse(value.slice(PREFIX.length));
-    if (!data || typeof data.instructions !== "string" || !data.credentialLabels ||
-        typeof data.credentialLabels !== "object" || Array.isArray(data.credentialLabels) ||
-        Object.entries(data.credentialLabels).some(([provider, label]) => !provider.trim() || provider !== provider.trim().toLowerCase() || typeof label !== "string" || !label.trim())) {
-        throw new Error("Invalid automation account selections");
-    }
-    return { instructions: data.instructions, credentialLabels: data.credentialLabels };
-}

package/dist/credentials/selected-store.js

@@ -1,44 +0,0 @@
-import { defaultPresetsPath, loadPresets } from "./presets.js";
-import { selectCredential } from "./selection.js";
-import { CredentialSelectionError } from "./session.js";
-/** A provider-addressed view of the vault for consumers without labeled accounts.
- * Resolve on every operation; never copy a work credential into the default slot.
- * Refresh writes stay attached to the selected record's label and metadata.
- */
-export function selectedCredentialStore(store, credsDir, context) {
-    const selectRecord = (provider, records, presets) => {
-        const record = selectCredential(provider, records, presets, context)?.record;
-        const label = context?.credentialLabels?.[provider];
-        if (label && (!record || record.source.kind !== "stored")) {
-            throw new CredentialSelectionError(`Selected account “${label}” for ${provider} is unavailable on this machine`);
-        }
-        return record;
-    };
-    const select = async (provider) => selectRecord(provider, await store.listRecords(), loadPresets(defaultPresetsPath(credsDir)));
-    return {
-        async read(provider) {
-            const record = await select(provider);
-            if (record?.source.kind !== "stored")
-                return undefined;
-            const { updatedAt: _updatedAt, ...credential } = record.source.cred;
-            return credential;
-        },
-        async list() {
-            const records = await store.listRecords();
-            const presets = loadPresets(defaultPresetsPath(credsDir));
-            return [...new Set([...records.map((r) => r.provider), ...Object.keys(context?.credentialLabels ?? {})])].flatMap((providerId) => {
-                const record = selectRecord(providerId, records, presets);
-                if (record?.source.kind !== "stored")
-                    return [];
-                const credential = record.source.cred;
-                return [{ providerId, type: credential.type, ...(credential.type === "oauth" ? { expiresAt: credential.expires } : {}) }];
-            });
-        },
-        async modify(provider, fn) {
-            const record = await select(provider);
-            if (!record)
-                throw new Error(`No account selected for ${provider}`);
-            return store.modifyRecord(provider, record.label, fn);
-        },
-    };
-}

package/dist/credentials/selection.js

@@ -1,25 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-only
-import path from "node:path";
-import { resolveCredential } from "./records.js";
-/** Stable project identifiers discoverable without importing repo/session code. */
-export function projectIdsFromWorkspace(workspace) {
-    const resolved = path.resolve(workspace);
-    const ids = new Set([resolved, path.basename(resolved)]);
-    for (const part of resolved.split(path.sep)) {
-        const split = part.indexOf("__");
-        if (split > 0 && split < part.length - 2)
-            ids.add(`${part.slice(0, split)}/${part.slice(split + 2)}`);
-    }
-    return [...ids];
-}
-export function selectCredential(provider, records, presets, context) {
-    const id = provider.trim().toLowerCase();
-    const workspace = context?.workspace?.trim();
-    const projects = [context?.project?.trim(), ...(workspace ? projectIdsFromWorkspace(workspace) : [])].filter(Boolean);
-    const projectPreset = projects.map((value) => `project:${value}`).find((name) => presets.presets?.[name]?.[id]);
-    const preferLabel = context?.credentialLabels?.[id] ?? context?.preferLabel;
-    return resolveCredential(id, records, presets, {
-        ...(projectPreset ? { preset: projectPreset } : {}),
-        ...(preferLabel ? { preferLabel } : {}),
-    });
-}

package/dist/credentials/session.js

@@ -1,48 +0,0 @@
-export class CredentialSelectionError extends Error {
-}
-/** Preserve historical best-effort auth only when no explicit account failed. */
-export function credentialEnvFallback(error) {
-    if (error instanceof CredentialSelectionError)
-        throw error;
-    return {};
-}
-/** Bind a private provider→label map, without changing shared vault assignments. */
-export async function withSessionCredentials(options, labels) {
-    if (!labels || !Object.keys(labels).length)
-        return options;
-    const store = options.credentials;
-    if (!store)
-        throw new CredentialSelectionError("This agent manages its own login and cannot use automation account overrides");
-    const selected = { ...labels };
-    const credentials = {
-        listConfigured: async () => [...new Set([...(await store.listConfigured?.().catch(() => []) ?? []), ...Object.keys(selected)])],
-        async getCredential(provider, context) {
-            const label = selected[provider.trim().toLowerCase()];
-            let credential;
-            try {
-                credential = await store.getCredential(provider, { ...context, ...(label ? { preferLabel: label } : {}) });
-            }
-            catch (error) {
-                if (label)
-                    throw new CredentialSelectionError(`Could not read selected account “${label}” for ${provider}`);
-                throw error;
-            }
-            if (label && !credential)
-                throw new CredentialSelectionError(`Selected account “${label}” for ${provider} is unavailable on this machine`);
-            if (label && credential?.kind === "oauth" && credential.provider !== "anthropic") {
-                throw new CredentialSelectionError(`This agent cannot use a ${provider} subscription override; use an API key or a Bivy-managed model agent`);
-            }
-            // Do not let an inherited alternative Anthropic login outrank the pin.
-            if (label && credential?.provider === "anthropic")
-                return {
-                    ...credential,
-                    env: { ...credential.env, [credential.kind === "oauth" ? "ANTHROPIC_API_KEY" : "CLAUDE_CODE_OAUTH_TOKEN"]: "" },
-                };
-            return credential;
-        },
-    };
-    // Fail before starting a subprocess, including overrides for a second provider.
-    for (const provider of Object.keys(selected))
-        await credentials.getCredential(provider);
-    return { ...options, credentials };
-}