agent-relay 4.0.35 → 4.0.37

package/packages/sdk/dist/workflows/runner.js

@@ -16,10 +16,12 @@ import { stripAnsi as stripAnsiFn } from '../pty.js';
 import { resolveSpawnPolicy } from '../spawn-from-env.js';
 import { getCliDefinition } from '../cli-registry.js';
 import { resolveCliSync } from '../cli-resolver.js';
+import { buildNormalizedProxyEnv, getStrippedApiKeyVars, resolveProxyEnv, resolveProxyTokenFromEnv, resolveProxyUrlFromEnv, } from './proxy-env.js';
 import { loadCustomSteps, resolveAllCustomSteps, validateCustomStepsUsage, CustomStepsParseError, CustomStepResolutionError, } from './custom-steps.js';
 import { provisionWorkflowAgents, resolveAgentPermissions } from '../provisioner/index.js';
 import { collectCliSession } from './cli-session-collector.js';
 import { executeApiStep } from './api-executor.js';
+import { BudgetExceededError, BudgetTracker } from './budget-tracker.js';
 import { ChannelMessenger } from './channel-messenger.js';
 import { InMemoryWorkflowDb } from './memory-db.js';
 import { buildCommand as buildProcessCommand, spawnProcess } from './process-spawner.js';
@@ -52,6 +54,10 @@ const ENV_ALLOWLIST = new Set([
     'RUST_BACKTRACE',
     'RELAY_API_KEY',
     'RELAYCAST_BASE_URL',
+    'RELAY_LLM_PROXY',
+    'RELAY_LLM_PROXY_URL',
+    'CREDENTIAL_PROXY_TOKEN',
+    'RELAY_LLM_PROXY_TOKEN',
     'AGENT_RELAY_DASHBOARD_PORT',
     'AGENT_RELAY_RUN_ID_FILE',
     'EDITOR',
@@ -149,12 +155,16 @@ export class WorkflowRunner {
     activeAgentHandles = new Map();
     /** Per-agent workflow tokens for relay/relayfile auth across spawn modes. */
     agentTokens = new Map();
+    /** Per-agent credential proxy tokens keyed by logical agent definition name. */
+    proxyTokens = new Map();
     /** Per-agent relayfile mounts keyed by logical agent definition name. */
     agentMounts = new Map();
     // PTY-based output capture: accumulate terminal output per-agent
     ptyOutputBuffers = new Map();
     /** Snapshot of PTY output from the most recent failed attempt, keyed by step name. */
     lastFailedStepOutput = new Map();
+    /** Most recent custom verification failure details, keyed by step name. */
+    lastCustomVerificationFailure = new Map();
     ptyListeners = new Map();
     ptyLogStreams = new Map();
     /** Path to workers.json so `agents:kill` can find workflow-spawned agents */
@@ -185,6 +195,8 @@ export class WorkflowRunner {
     activeReviewers = new Map();
     /** Structured CLI session reports captured during the current run, keyed by step name. */
     agentReports = new Map();
+    /** Optional per-run token budget tracker; only created when budgets are configured. */
+    budgetTracker;
     static PTY_TASK_ARG_SIZE_LIMIT = 2 * 1024 * 1024; // 2 MB
     processBackend;
     constructor(options = {}) {
@@ -245,6 +257,51 @@ export class WorkflowRunner {
         }
         return { resolved, errors, warnings };
     }
+    initializeBudgetTracker(config, workflow) {
+        const agentMap = new Map(config.agents.map((agent) => [agent.name, WorkflowRunner.resolveAgentDef(agent)]));
+        const stepConfigs = workflow.steps.flatMap((step) => {
+            if (step.type === 'deterministic' ||
+                step.type === 'worktree' ||
+                step.type === 'integration' ||
+                !step.agent) {
+                return [];
+            }
+            const agentDef = agentMap.get(step.agent);
+            return [
+                {
+                    stepName: step.name,
+                    agentName: step.agent,
+                    maxTokens: agentDef?.constraints?.maxTokens,
+                },
+            ];
+        });
+        const hasWorkflowBudget = config.swarm.tokenBudget !== undefined;
+        const hasAgentBudgets = stepConfigs.some((step) => step.maxTokens !== undefined);
+        this.budgetTracker =
+            hasWorkflowBudget || hasAgentBudgets
+                ? new BudgetTracker({
+                    workflowBudget: config.swarm.tokenBudget,
+                    steps: stepConfigs,
+                })
+                : undefined;
+    }
+    ensureBudgetAllowsSpawn(stepName, agentName) {
+        if (!this.budgetTracker)
+            return;
+        const budgetCheck = this.budgetTracker.checkCanSpawn(stepName);
+        if (budgetCheck.allowed)
+            return;
+        const workflowBudget = this.budgetTracker.getRunSummaryBudgetData()?.workflow;
+        const used = workflowBudget?.used.toLocaleString('en-US') ?? '0';
+        const limit = workflowBudget?.limit?.toLocaleString('en-US') ?? '--';
+        this.log(`[budget] Skipping step ${stepName} — workflow budget exhausted (used ${used} of ${limit})`);
+        throw new BudgetExceededError(stepName, 'workflow', workflowBudget?.limit ?? 0, workflowBudget?.used ?? 0);
+    }
+    getTotalReportTokens(report) {
+        if (!report.tokens)
+            return undefined;
+        return report.tokens.input + report.tokens.output + report.tokens.cacheRead;
+    }
     validatePermissions(agents, permissionProfiles, source = '<config>') {
         const errors = [];
         const warnings = [];
@@ -1091,16 +1148,169 @@ export class WorkflowRunner {
             // Dashboard not running — silently ignore.
         });
     }
-    getRelayEnv() {
-        if (!this.relayApiKey && !this.relayOptions.env) {
+    async loadCredentialProxyModule() {
+        try {
+            const dynamicImport = new Function('specifier', 'return import(specifier)');
+            const module = (await dynamicImport('@agent-relay/credential-proxy'));
+            return typeof module.mintProxyToken === 'function' ? module : null;
+        }
+        catch (error) {
+            if (error?.code === 'ERR_MODULE_NOT_FOUND') {
+                return null;
+            }
+            throw error;
+        }
+    }
+    resolveCredentialProxyProvider(agentDef, config) {
+        const configuredProviders = Object.keys(config.swarm.credentialProxy?.providers ?? {});
+        const explicitProvider = agentDef.credentials?.provider?.trim().toLowerCase();
+        if (explicitProvider === 'openai' ||
+            explicitProvider === 'anthropic' ||
+            explicitProvider === 'openrouter') {
+            return explicitProvider;
+        }
+        const model = agentDef.constraints?.model?.trim().toLowerCase() ?? '';
+        if (model.includes('openrouter')) {
+            return 'openrouter';
+        }
+        if (model.includes('claude') || model.includes('anthropic')) {
+            return 'anthropic';
+        }
+        if (model.includes('openai') ||
+            model.includes('chatgpt') ||
+            model.includes('gpt') ||
+            /\bo[134](?:\b|-)/.test(model)) {
+            return 'openai';
+        }
+        if (configuredProviders.length === 1) {
+            const [onlyProvider] = configuredProviders;
+            if (onlyProvider === 'openai' || onlyProvider === 'anthropic' || onlyProvider === 'openrouter') {
+                return onlyProvider;
+            }
+        }
+        switch (agentDef.cli) {
+            case 'claude':
+                return 'anthropic';
+            case 'codex':
+            case 'aider':
+            case 'goose':
+            case 'opencode':
+            case 'cursor':
+            case 'cursor-agent':
+                return 'openai';
+            default:
+                throw new Error(`Unable to resolve credential proxy provider for agent "${agentDef.name}". Set credentials.provider or constraints.model.`);
+        }
+    }
+    resolveCredentialProxySecret(config) {
+        const configuredSecret = config.swarm.credentialProxy?.jwtSecret;
+        if (configuredSecret?.startsWith('$')) {
+            const envSecret = process.env[configuredSecret.slice(1)];
+            if (envSecret) {
+                return envSecret;
+            }
+        }
+        else if (configuredSecret) {
+            return configuredSecret;
+        }
+        const defaultSecret = process.env.RELAY_PROXY_JWT_SECRET;
+        if (defaultSecret) {
+            return defaultSecret;
+        }
+        throw new Error('Credential proxy JWT secret is missing. Set swarm.credentialProxy.jwtSecret or RELAY_PROXY_JWT_SECRET.');
+    }
+    async mintAgentProxyToken(agentDef, config) {
+        const proxyConfig = config.swarm?.credentialProxy;
+        if (!proxyConfig?.proxyUrl || !agentDef.credentials?.proxy) {
+            return undefined;
+        }
+        const provider = this.resolveCredentialProxyProvider(agentDef, config);
+        const providerConfig = proxyConfig.providers?.[provider];
+        const credentialId = providerConfig?.credentialId;
+        if (!credentialId) {
+            throw new Error(`Credential proxy provider "${provider}" is not configured for agent "${agentDef.name}".`);
+        }
+        const budget = agentDef.constraints?.maxTokens ?? proxyConfig.defaultBudget;
+        const cacheKey = `${agentDef.name}:${provider}:${credentialId}:${budget ?? 'default'}`;
+        const cachedToken = this.proxyTokens.get(cacheKey);
+        if (cachedToken) {
+            return cachedToken;
+        }
+        const credentialProxy = await this.loadCredentialProxyModule();
+        if (!credentialProxy) {
+            throw new Error('Credential proxy mode requires the optional peer dependency "@agent-relay/credential-proxy".');
+        }
+        const nowSeconds = Math.floor(Date.now() / 1000);
+        const token = await credentialProxy.mintProxyToken({
+            sub: this.workspaceId,
+            aud: 'relay-llm-proxy',
+            provider,
+            credentialId,
+            budget,
+            exp: nowSeconds + 15 * 60,
+        }, this.resolveCredentialProxySecret(config));
+        this.proxyTokens.set(cacheKey, token);
+        return token;
+    }
+    async resolveAgentProxyMode(agentDef, config) {
+        if (!agentDef.credentials?.proxy) {
+            return undefined;
+        }
+        const env = this.getMergedRelayEnvSource();
+        const configuredProxyUrl = config?.swarm?.credentialProxy?.proxyUrl;
+        const proxyUrl = configuredProxyUrl ?? resolveProxyUrlFromEnv(env);
+        if (!proxyUrl) {
             return undefined;
         }
+        if (!configuredProxyUrl) {
+            const injectedToken = resolveProxyTokenFromEnv(env);
+            if (!injectedToken) {
+                return undefined;
+            }
+            return {
+                url: proxyUrl,
+                token: injectedToken,
+            };
+        }
+        const token = await this.mintAgentProxyToken(agentDef, config);
+        if (!token) {
+            return undefined;
+        }
+        return {
+            url: proxyUrl,
+            token,
+        };
+    }
+    getMergedRelayEnvSource() {
         return {
             ...process.env,
             ...(this.relayOptions.env ?? {}),
             ...(this.relayApiKey ? { RELAY_API_KEY: this.relayApiKey } : {}),
         };
     }
+    getRelayEnv(proxyMode) {
+        const env = this.getMergedRelayEnvSource();
+        const inheritedProxyUrl = resolveProxyUrlFromEnv(env);
+        const inheritedProxyToken = resolveProxyTokenFromEnv(env);
+        if (!this.relayApiKey &&
+            !this.relayOptions.env &&
+            !proxyMode &&
+            !(inheritedProxyUrl && inheritedProxyToken)) {
+            return undefined;
+        }
+        const normalizedProxy = proxyMode?.url && proxyMode.token
+            ? proxyMode
+            : inheritedProxyUrl && inheritedProxyToken
+                ? { url: inheritedProxyUrl, token: inheritedProxyToken }
+                : undefined;
+        if (normalizedProxy) {
+            Object.assign(env, buildNormalizedProxyEnv(normalizedProxy.url, normalizedProxy.token));
+            for (const key of getStrippedApiKeyVars()) {
+                delete env[key];
+            }
+        }
+        return env;
+    }
     async provisionAgents(config) {
         // Cloud launcher already compiled and seeded relayfile ACLs before the
         // sandbox started.  Skip in-sandbox provisioning — the relayfile API has
@@ -1109,6 +1319,7 @@ export class WorkflowRunner {
             return;
         }
         this.agentTokens.clear();
+        this.proxyTokens.clear();
         await this.stopProvisionedMounts();
         const agentsToProvision = {};
         for (const agent of config.agents) {
@@ -2042,6 +2253,7 @@ export class WorkflowRunner {
         this.runtimeStepAgents.clear();
         this.stepCompletionEvidence.clear();
         this.agentReports.clear();
+        this.initializeBudgetTracker(config, workflow);
         this.log(`Starting workflow "${workflow.name}" (${workflow.steps.length} steps)`);
         // Initialize trajectory recording
         this.trajectory = new WorkflowTrajectory(config.trajectories, runId, this.cwd);
@@ -2371,6 +2583,7 @@ export class WorkflowRunner {
         }
         finally {
             this.lastFailedStepOutput.clear();
+            this.lastCustomVerificationFailure.clear();
             for (const stream of this.ptyLogStreams.values())
                 stream.end();
             this.ptyLogStreams.clear();
@@ -2973,6 +3186,7 @@ export class WorkflowRunner {
         const specialistDef = WorkflowRunner.resolveAgentDef(rawAgentDef);
         // API-mode agents: execute via direct API call instead of spawning a PTY/subprocess.
         if (specialistDef.cli === 'api') {
+            this.ensureBudgetAllowsSpawn(step.name, agentName);
             const stepOutputContext = this.buildStepOutputContext(stepStates, runId);
             const resolvedTask = this.interpolateStepTask(step.task ?? '', stepOutputContext);
             state.row.status = 'running';
@@ -3050,6 +3264,8 @@ export class WorkflowRunner {
         let lastAttemptStartedAt;
         let lastEffectiveAgentDef;
         let lastEffectiveCwd;
+        let lastAttemptReportCaptured = false;
+        let lastDiagnosticResult = null;
         // OWNER_DECISION: INCOMPLETE_RETRY is enforced here at the attempt-loop level so every
         // interactive execution path shares the same contract:
         // - retries remaining => throw back into the loop and retry
@@ -3060,6 +3276,11 @@ export class WorkflowRunner {
             // Reset per-attempt exit info so stale values don't leak across retries
             lastExitCode = undefined;
             lastExitSignal = undefined;
+            lastAttemptStartedAt = undefined;
+            lastEffectiveAgentDef = undefined;
+            lastEffectiveCwd = undefined;
+            lastAttemptReportCaptured = false;
+            let stepOutputForDiagnostic = '';
             if (attempt > 0) {
                 this.emit({ type: 'step:retrying', runId, stepName: step.name, attempt });
                 this.postToChannel(`**[${step.name}]** Retrying (attempt ${attempt + 1}/${maxRetries + 1})`);
@@ -3077,6 +3298,7 @@ export class WorkflowRunner {
                 await this.delay(retryDelay);
             }
             try {
+                this.ensureBudgetAllowsSpawn(step.name, agentName);
                 lastAttemptStartedAt = Date.now();
                 // Mark step as running
                 state.row.status = 'running';
@@ -3114,12 +3336,29 @@ export class WorkflowRunner {
                 let resolvedTask = this.interpolateStepTask(step.task ?? '', stepOutputContext);
                 // On retry attempts, prepend failure context so the agent knows what went wrong
                 if (attempt > 0 && lastError) {
-                    const priorOutput = (this.lastFailedStepOutput.get(step.name) ?? '').slice(-2000);
-                    resolvedTask =
-                        `[RETRY — Attempt ${attempt + 1}/${maxRetries + 1}]\n` +
-                            `Previous attempt failed: ${lastError}\n` +
-                            (priorOutput ? `Previous output (last 2000 chars):\n${priorOutput}\n` : '') +
-                            `---\n${resolvedTask}`;
+                    if (lastDiagnosticResult) {
+                        resolvedTask =
+                            `[RETRY — Attempt ${attempt + 1}/${maxRetries + 1}] Verification failed.\n` +
+                                `Diagnostic analysis:\n${lastDiagnosticResult.analysis}\n\n` +
+                                `Original error: ${lastError}\n---\n${resolvedTask}`;
+                    }
+                    else {
+                        const priorOutput = (this.lastFailedStepOutput.get(step.name) ?? '').slice(-2000);
+                        const customVerificationFailure = this.lastCustomVerificationFailure.get(step.name);
+                        const verificationFailurePrompt = customVerificationFailure
+                            ? `[VERIFICATION FAILED] Your code did not pass the verification check.\n` +
+                                `Command: ${customVerificationFailure.command}\n` +
+                                `Output:\n` +
+                                `${customVerificationFailure.output}\n\n` +
+                                `Fix the issues above before proceeding.\n`
+                            : '';
+                        resolvedTask =
+                            `[RETRY — Attempt ${attempt + 1}/${maxRetries + 1}]\n` +
+                                `Previous attempt failed: ${lastError}\n` +
+                                verificationFailurePrompt +
+                                (priorOutput ? `Previous output (last 2000 chars):\n${priorOutput}\n` : '') +
+                                `---\n${resolvedTask}`;
+                    }
                 }
                 // If this is an interactive agent, append awareness of non-interactive workers
                 // so the lead knows not to message them and to use step output chaining instead
@@ -3160,6 +3399,7 @@ export class WorkflowRunner {
                 if (usesDedicatedOwner) {
                     const result = await this.executeSupervisedAgentStep(step, { specialist: effectiveSpecialist, owner: effectiveOwner, reviewer: reviewDef }, resolvedTask, timeoutMs, attempt);
                     specialistOutput = result.specialistOutput;
+                    stepOutputForDiagnostic = result.specialistOutput;
                     ownerOutput = result.ownerOutput;
                     ownerElapsed = result.ownerElapsed;
                     completionReason = result.completionReason;
@@ -3228,6 +3468,7 @@ export class WorkflowRunner {
                         }
                     }
                     specialistOutput = output;
+                    stepOutputForDiagnostic = output;
                     ownerOutput = output;
                 }
                 // Even non-interactive steps can emit an explicit OWNER_DECISION contract.
@@ -3281,6 +3522,7 @@ export class WorkflowRunner {
                     }
                 }
                 await this.captureAgentReport(runId, step.name, lastEffectiveAgentDef, lastEffectiveCwd, lastAttemptStartedAt, Date.now());
+                lastAttemptReportCaptured = true;
                 // Mark completed
                 state.row.status = 'completed';
                 state.row.output = combinedOutput;
@@ -3310,6 +3552,26 @@ export class WorkflowRunner {
             catch (err) {
                 lastError = err instanceof Error ? err.message : String(err);
                 lastCompletionReason = err instanceof WorkflowCompletionError ? err.completionReason : undefined;
+                const diagnosticVerification = step.verification;
+                if (err instanceof WorkflowCompletionError &&
+                    err.completionReason === 'failed_verification' &&
+                    diagnosticVerification?.diagnosticAgent &&
+                    attempt < maxRetries) {
+                    lastDiagnosticResult = await this.runDiagnosticAgent(step, lastError, stepOutputForDiagnostic || (this.lastFailedStepOutput.get(step.name) ?? ''), agentMap, runId);
+                }
+                else {
+                    lastDiagnosticResult = null;
+                }
+                if (lastCompletionReason !== 'failed_verification') {
+                    this.lastCustomVerificationFailure.delete(step.name);
+                }
+                if (!(err instanceof BudgetExceededError) && !lastAttemptReportCaptured) {
+                    await this.captureAgentReport(runId, step.name, lastEffectiveAgentDef, lastEffectiveCwd, lastAttemptStartedAt, Date.now());
+                    lastAttemptReportCaptured = true;
+                }
+                if (err instanceof BudgetExceededError) {
+                    break;
+                }
                 if (lastCompletionReason === 'retry_requested_by_owner' && attempt >= maxRetries) {
                     lastError = this.buildOwnerRetryBudgetExceededMessage(step.name, maxRetries, lastError);
                 }
@@ -3330,7 +3592,9 @@ export class WorkflowRunner {
         const verificationValue = typeof step.verification === 'object' && 'value' in step.verification
             ? String(step.verification.value)
             : undefined;
-        await this.captureAgentReport(runId, step.name, lastEffectiveAgentDef, lastEffectiveCwd, lastAttemptStartedAt, Date.now());
+        if (!lastAttemptReportCaptured) {
+            await this.captureAgentReport(runId, step.name, lastEffectiveAgentDef, lastEffectiveCwd, lastAttemptStartedAt, Date.now());
+        }
         await this.trajectory?.stepFailed(step, lastError ?? 'Unknown error', maxRetries + 1, maxRetries, {
             agent: agentName,
             nonInteractive,
@@ -3343,6 +3607,73 @@ export class WorkflowRunner {
         }, lastCompletionReason);
         throw new Error(`Step "${step.name}" failed after ${maxRetries} retries: ${lastError ?? 'Unknown error'}`);
     }
+    async runDiagnosticAgent(step, verificationError, stepOutput, agentMap, runId) {
+        const verification = step.verification;
+        const diagnosticAgentName = verification?.diagnosticAgent;
+        if (!verification || !diagnosticAgentName) {
+            return null;
+        }
+        const rawDiagnosticDef = agentMap.get(diagnosticAgentName);
+        if (!rawDiagnosticDef) {
+            this.log(`[${step.name}] Diagnostic agent "${diagnosticAgentName}" not found — falling back to standard retry`);
+            return null;
+        }
+        const diagnosticAgentDef = {
+            ...WorkflowRunner.resolveAgentDef(rawDiagnosticDef),
+            interactive: false,
+        };
+        const verificationCommand = verification.type === 'custom' ? verification.value : `${verification.type}: ${verification.value}`;
+        const diagnosticTimeout = verification.diagnosticTimeout ?? 60_000;
+        const diagnosticPrompt = `The following verification failed after step "${step.name}".\n\n` +
+            `Verification command: ${verificationCommand}\n` +
+            `Verification output:\n${verificationError}\n\n` +
+            `Step task was:\n${step.task ?? ''}\n\n` +
+            `Step output (last 2000 chars):\n${stepOutput.slice(-2000)}\n\n` +
+            `Analyze what went wrong. Be specific. Do NOT fix the code.`;
+        const diagnosticStep = {
+            ...step,
+            name: `${step.name}-diagnostic-${runId.slice(0, 8)}`,
+            agent: diagnosticAgentName,
+            task: diagnosticPrompt,
+            verification: undefined,
+            retries: 0,
+        };
+        const diagnosticCwd = this.resolveExecutionCwd(diagnosticStep, diagnosticAgentDef);
+        const startedAt = Date.now();
+        try {
+            this.ensureBudgetAllowsSpawn(step.name, diagnosticAgentName);
+            this.log(`[${step.name}] Verification failed — running diagnostic agent '${diagnosticAgentName}'...`);
+            const diagnosticResult = await this.execNonInteractive(diagnosticAgentDef, diagnosticStep, diagnosticTimeout);
+            const elapsedMs = Date.now() - startedAt;
+            await this.captureAgentReport(runId, step.name, diagnosticAgentDef, diagnosticCwd, startedAt, Date.now());
+            const analysis = diagnosticResult.output.trim();
+            const tokenCount = Math.max(1, Math.ceil(analysis.length / 4));
+            const firstLine = analysis
+                .split(/\r?\n/)
+                .map((line) => line.trim())
+                .find(Boolean) ?? '(no analysis returned)';
+            this.log(`[${step.name}] Diagnostic complete (${elapsedMs}ms, ${tokenCount} tokens): ${firstLine}`);
+            return {
+                analysis,
+                metadata: {
+                    agentName: diagnosticAgentName,
+                    elapsedMs,
+                    tokenCount,
+                },
+            };
+        }
+        catch (error) {
+            await this.captureAgentReport(runId, step.name, diagnosticAgentDef, diagnosticCwd, startedAt, Date.now());
+            const message = error instanceof Error ? error.message : String(error);
+            if (/\btimed out\b/i.test(message)) {
+                this.log(`[${step.name}] Diagnostic timed out — falling back to standard retry`);
+            }
+            else {
+                this.log(`[${step.name}] Diagnostic failed — falling back to standard retry: ${message}`);
+            }
+            return null;
+        }
+    }
     buildOwnerRetryBudgetExceededMessage(stepName, maxRetries, ownerDecisionError) {
         const attempts = maxRetries + 1;
         const prefix = `Step "${stepName}" `;
@@ -4340,7 +4671,11 @@ export class WorkflowRunner {
         this.postToChannel(`**[${step.name}]** Assigned to \`${agentName}\` (non-interactive)`);
         const stdoutChunks = [];
         const stderrChunks = [];
-        const env = { ...(this.getRelayEnv() ?? filteredEnv()) };
+        const proxyMode = await this.resolveAgentProxyMode(agentDef, this.currentConfig);
+        const env = { ...(this.getRelayEnv(proxyMode) ?? filteredEnv()) };
+        if (proxyMode?.url && proxyMode.token) {
+            Object.assign(env, resolveProxyEnv(agentDef.cli, proxyMode.url, proxyMode.token));
+        }
         const agentToken = this.agentTokens.get(agentDef.name);
         const mount = this.agentMounts.get(agentDef.name);
         if (agentToken) {
@@ -4356,7 +4691,7 @@ export class WorkflowRunner {
         }
         env.RELAYFILE_BASE_URL =
             env.RELAYFILE_BASE_URL ??
-                this.getRelayEnv()?.RELAYFILE_BASE_URL ??
+                this.getRelayEnv(proxyMode)?.RELAYFILE_BASE_URL ??
                 process.env.RELAYFILE_BASE_URL ??
                 'http://127.0.0.1:8080';
         try {
@@ -4555,6 +4890,11 @@ export class WorkflowRunner {
                 RELAY_API_KEY: this.relayApiKey ?? 'workflow-runner',
                 AGENT_CHANNELS: (agentChannels ?? []).join(','),
             });
+            const proxyMode = await this.resolveAgentProxyMode(agentDef, this.currentConfig);
+            const baseEnv = this.getRelayEnv(proxyMode);
+            const proxyEnvOverrides = proxyMode?.url && proxyMode.token
+                ? resolveProxyEnv(agentDef.cli, proxyMode.url, proxyMode.token)
+                : undefined;
             const spawnOptions = {
                 name: agentName,
                 model: agentDef.constraints?.model,
@@ -4564,6 +4904,7 @@ export class WorkflowRunner {
                 idleThresholdSecs: agentDef.constraints?.idleThresholdSecs,
                 cwd: agentCwd,
                 agentToken: this.agentTokens.get(agentDef.name),
+                env: proxyEnvOverrides ? { ...baseEnv, ...proxyEnvOverrides } : baseEnv,
             };
             const sdkSpawner = getWorkflowSdkSpawner(this.relay, agentDef.cli);
             if (sdkSpawner) {
@@ -4965,10 +5306,31 @@ export class WorkflowRunner {
     }
     // ── Verification ────────────────────────────────────────────────────────
     runVerification(check, output, stepName, injectedTaskText, options) {
-        return runVerification(check, output, stepName, injectedTaskText, { ...options, cwd: this.cwd }, {
-            recordStepToolSideEffect: (name, effect) => this.recordStepToolSideEffect(name, effect),
-            getOrCreateStepEvidenceRecord: (name) => this.getOrCreateStepEvidenceRecord(name),
-            log: (message) => this.log(message),
+        try {
+            const result = runVerification(check, output, stepName, injectedTaskText, { ...options, cwd: this.cwd }, {
+                recordStepToolSideEffect: (name, effect) => this.recordStepToolSideEffect(name, effect),
+                getOrCreateStepEvidenceRecord: (name) => this.getOrCreateStepEvidenceRecord(name),
+                log: (message) => this.log(message),
+            });
+            this.updateCustomVerificationFailure(stepName, check, result.error);
+            return result;
+        }
+        catch (error) {
+            this.updateCustomVerificationFailure(stepName, check, error instanceof Error ? error.message : String(error));
+            throw error;
+        }
+    }
+    updateCustomVerificationFailure(stepName, check, errorMessage) {
+        if (check.type !== 'custom' || !check.value || !errorMessage) {
+            this.lastCustomVerificationFailure.delete(stepName);
+            return;
+        }
+        const marker = `custom check "${check.value}" failed\n`;
+        const markerIndex = errorMessage.indexOf(marker);
+        const output = markerIndex === -1 ? errorMessage.trim() : errorMessage.slice(markerIndex + marker.length).trim();
+        this.lastCustomVerificationFailure.set(stepName, {
+            command: check.value,
+            output,
         });
     }
     // ── State helpers ─────────────────────────────────────────────────────
@@ -5020,6 +5382,18 @@ export class WorkflowRunner {
             });
             if (!report)
                 return;
+            const totalTokens = this.getTotalReportTokens(report);
+            if (this.budgetTracker && report.tokens) {
+                this.budgetTracker.recordUsage(stepName, report.tokens);
+                this.budgetTracker.isOverBudget(stepName);
+                const budgetStatus = this.budgetTracker.getBudgetStatus(stepName);
+                if (budgetStatus.agentLimitExceeded) {
+                    const stepBudget = this.budgetTracker.getStepBudgetStatus(stepName);
+                    const used = stepBudget?.used?.toLocaleString('en-US') ?? totalTokens?.toLocaleString('en-US') ?? '0';
+                    const limit = stepBudget?.limit?.toLocaleString('en-US') ?? '--';
+                    this.log(`[budget] Step ${stepName} exceeded its agent budget (${used} of ${limit})`);
+                }
+            }
             this.agentReports.set(stepName, report);
             this.emit({ type: 'step:agent-report', runId, stepName, report });
             await this.persistAgentReport(runId, stepName, report);
@@ -5171,7 +5545,7 @@ export class WorkflowRunner {
         console.log(chalk.dim('━'.repeat(70)));
         // Always show the summary table — with agent reports when available,
         // with just step/status/duration when not (non-interactive agents).
-        console.log(formatRunSummaryTable(outcomes, this.agentReports));
+        console.log(formatRunSummaryTable(outcomes, this.agentReports, this.budgetTracker?.getRunSummaryBudgetData()));
         // Show errors and output excerpts for failed steps below the table
         for (const outcome of outcomes) {
             if (outcome.status !== 'failed')