agents-relay 2.0.139 → 2.0.141

package/dist/adapters.js

@@ -6,6 +6,7 @@ import { AsyncLocalStorage } from 'node:async_hooks';
 import { withTestInjection } from './e2e-injection.js';
 import { taskReferencePrompt } from './task-context.js';
 import { spawnOwnedProcess, terminateOwnedProcess, ownedProcessTerminationReason } from './owned-process.js';
+import { PreSubmissionRejection } from './worker-rejection.js';
 export function buildCodexArgs(route, input) {
     const args = ['exec', '--json'];
     if (route.profile)
@@ -202,8 +203,14 @@ function rawBrowserWorkspaceCommand(cli, args, stdin, signal) {
                 try {
                     const envelope = parseWorkspaceJson(stdout);
                     const result = envelope.result;
-                    if (result?.ok === false && typeof result.code === 'string' && typeof result.message === 'string')
+                    if (result?.ok === false && typeof result.code === 'string' && typeof result.message === 'string') {
                         reason = `${result.code}: ${result.message}`;
+                        const rejection = PreSubmissionRejection.fromPlatformResponse(result);
+                        if (rejection) {
+                            reject(rejection);
+                            return;
+                        }
+                    }
                 }
                 catch { /* Preserve legacy error handling for other CLI failures. */ }
                 reject(new Error(reason));
@@ -387,6 +394,8 @@ export class ChatGptAdapter {
                     throw error;
                 if (error instanceof StartAckTimeout)
                     throw error;
+                if (error instanceof PreSubmissionRejection)
+                    throw error;
                 throw new LaunchFailure(error instanceof Error ? error.message : String(error));
             }
         })();

package/dist/chatgpt-platform-fallback.js

@@ -0,0 +1,56 @@
+import { eligibleWorkerCandidates, workerCandidates } from './worker-routing.js';
+import { routeExecution } from './execution-routing.js';
+import { eventFor } from './events.js';
+export function codexFallbackRouting(task, adapters, registered, usage) {
+    const requirements = task.workerRequirements ?? { capabilities: [] };
+    const excludedWorkers = new Set((task.routingExclusions ?? []).map(item => item.workerId).filter((id) => Boolean(id)));
+    const excludedAdapters = new Set((task.routingExclusions ?? []).map(item => item.adapter).filter((adapter) => Boolean(adapter)));
+    const candidates = eligibleWorkerCandidates(workerCandidates(adapters, registered, usage), requirements, { strictCapabilities: true })
+        .filter(candidate => candidate.adapter === 'codex' && !excludedWorkers.has(candidate.workerId) && !excludedAdapters.has(candidate.adapter));
+    const excludedRoutes = (task.routingExclusions ?? []).map(item => ({ provider: item.provider, model: item.model, ...(item.profile ? { profile: item.profile } : {}) }));
+    return { candidates, excludedRoutes };
+}
+export async function codexFallbackCompatible(task, adapters, registered, usage) {
+    if (task.adapter !== 'chatgpt' || task.chatgptThreadDelivery || task.workerRequirements?.runtime === 'chatgpt')
+        return false;
+    const requirements = task.workerRequirements ?? { capabilities: [] };
+    const { candidates, excludedRoutes } = codexFallbackRouting(task, adapters, registered, usage);
+    if (candidates.length === 0)
+        return false;
+    try {
+        await routeExecution(candidates, requirements, { registered, usage, taskFacts: { task }, excludedRoutes });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function quarantineUnavailableCodexFallback(transitions, emit, jobId, taskId, error) {
+    const transition = await transitions.apply(jobId, taskId, 'worker.platform_failure', {
+        eligible: (_job, task) => task.state === 'QUEUED' && task.adapter === 'chatgpt' && task.platformFailure?.safeToReroute === true,
+        facts: () => ({ platformFallbackSafe: false }),
+        mutate: (_job, task) => { task.error = `Codex fallback route became unavailable: ${error instanceof Error ? error.message : String(error)}`; },
+    });
+    if (transition?.decision.accepted)
+        await emit(eventFor(jobId, taskId, transition.task.parentTaskId, 'task.blocked', 'blocked', transition.task.error ?? 'Codex fallback route unavailable', 'user', { reason: transition.task.failureReason, phase: 'fallback-routing' }));
+}
+export function persistChatGptPlatformFailure(task, original, executionId, classification, evidence, safeToReroute) {
+    const route = original?.routing;
+    const workerId = original?.workerSelection?.workerId ?? 'chatgpt';
+    const at = new Date().toISOString();
+    task.platformFailure = {
+        classification,
+        executionId: executionId ?? 'unknown',
+        route: { workerId, adapter: 'chatgpt', provider: route?.provider ?? 'unknown', model: route?.model ?? 'unknown', ...(route?.profile ? { profile: route.profile } : {}) },
+        evidence,
+        safeToReroute,
+        at,
+    };
+    if (!task.routingExclusions?.some(item => item.workerId === workerId && item.adapter === 'chatgpt')) {
+        task.routingExclusions = [...(task.routingExclusions ?? []), {
+                ...task.platformFailure.route,
+                reason: classification,
+                at,
+            }];
+    }
+}

package/dist/execution-event-identity.js

@@ -0,0 +1,15 @@
+export function executionEventSource(jobId, taskId, executionId) { return `job/${jobId}/task/${taskId}/execution/${executionId}`; }
+export function eventSourceId(event) { return typeof event.source?.id === 'string' ? event.source.id : undefined; }
+export function executionIdFromSource(sourceId, jobId, taskId) {
+    const prefix = `job/${jobId}/task/${taskId}/execution/`;
+    return sourceId?.startsWith(prefix) ? sourceId.slice(prefix.length) || undefined : undefined;
+}
+const terminalExecutionClaims = new Set();
+export function claimTerminalExecution(sourceId) {
+    terminalExecutionClaims.add(sourceId);
+    const cleanup = setTimeout(() => terminalExecutionClaims.delete(sourceId), 60000);
+    cleanup.unref();
+}
+export function terminalExecutionClaimed(jobId, taskId, executionId) {
+    return terminalExecutionClaims.has(executionEventSource(jobId, taskId, executionId));
+}

package/dist/reconciler-review.js

@@ -11,6 +11,7 @@ import { createTaskEntity } from './workflow/entity-creation.js';
 import { localSourceHead, localWorkingHead } from './local-git-merge.js';
 import { chatgptThreadRequirements, resolveReviewerThreadDestination, resolveImplementationTaskThreadDestination, prepareReviewerThreadDelivery } from './reviewer-thread.js';
 import { reviewGenerationMatches } from './review-generation-fence.js';
+import { codexFallbackRouting, quarantineUnavailableCodexFallback } from './chatgpt-platform-fallback.js';
 export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
     async currentHeadSha(job) {
         // GitHub PR head facts are audit-only. Source identity is local Git.
@@ -268,7 +269,14 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
             return { task, routed: false };
         const usage = this.options.usageSnapshotProvider ? await this.options.usageSnapshotProvider() : undefined;
         const registered = await this.store.listAgents();
-        const candidates = workerCandidates(this.options.adapters, registered, usage).filter(candidate => (implementationThread || reviewerThread) ? candidate.adapter === 'chatgpt' : true);
+        const codexFallback = task.platformFailure?.safeToReroute === true && task.adapter === 'chatgpt';
+        const fallbackRouting = codexFallback ? codexFallbackRouting(task, this.options.adapters, registered, usage) : undefined;
+        const excludedWorkers = new Set((task.routingExclusions ?? []).map(item => item.workerId).filter((id) => Boolean(id)));
+        const excludedAdapters = new Set((task.routingExclusions ?? []).map(item => item.adapter).filter((adapter) => Boolean(adapter)));
+        const candidates = fallbackRouting?.candidates ?? workerCandidates(this.options.adapters, registered, usage)
+            .filter(candidate => !excludedWorkers.has(candidate.workerId))
+            .filter(candidate => !excludedAdapters.has(candidate.adapter))
+            .filter(candidate => (implementationThread || reviewerThread) ? candidate.adapter === 'chatgpt' : true);
         const runtimeSummary = this.options.runtimeSummaryProvider?.();
         const requirements = (implementationThread || reviewerThread) ? chatgptThreadRequirements(task.workerRequirements) : (task.workerRequirements ?? { capabilities: [] });
         const taskFacts = {
@@ -296,7 +304,7 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
         const parentExcludedRoutes = parentRouteFailedBeforeStart && parent?.routing
             ? [{ provider: parent.routing.provider, model: parent.routing.model, profile: parent.routing.profile }]
             : [];
-        const taskExcludedRoutes = (task.routingExclusions ?? []).map(item => ({ provider: item.provider, model: item.model, profile: item.profile }));
+        const taskExcludedRoutes = fallbackRouting?.excludedRoutes ?? (task.routingExclusions ?? []).map(item => ({ provider: item.provider, model: item.model, profile: item.profile }));
         const excludedRoutes = [...taskExcludedRoutes, ...parentExcludedRoutes];
         const routed = await routeExecution(candidates, requirements, {
             decisionEngine: this.options.decisionEngine,
@@ -320,6 +328,17 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
         await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'model.selected', 'queued', 'Selected ' + task.routing.model + ' · thinking ' + (task.routing.reasoning ?? 'unknown'), 'user', { routing: task.routing }, { agent: 'relay', component: 'agents-relay' }));
         return { task, routed: true };
     }
+    async routeTaskForExecutionFailClosed(job, task) {
+        try {
+            return await this.routeTaskForExecution(job, task);
+        }
+        catch (error) {
+            if (task.adapter !== 'chatgpt' || !task.platformFailure?.safeToReroute)
+                throw error;
+            await quarantineUnavailableCodexFallback(this.taskTransitions, event => this.emit(event), job.id, task.id, error);
+            return undefined;
+        }
+    }
     async applyReviewEvent(event) {
         const job = await this.store.load(event.job_id);
         const task = job.tasks.find(item => item.id === event.task_id && item.agentName === 'reviewer');

package/dist/reconciler-runtime.js

@@ -1,6 +1,8 @@
 import { normalizeReviewerTerminalEvent } from './review-terminal-normalization.js';
+import { executionEventSource, eventSourceId, executionIdFromSource, claimTerminalExecution, terminalExecutionClaimed } from './execution-event-identity.js';
+export { executionEventSource } from './execution-event-identity.js';
 import { applyJobEffectOutcomes, applyTaskEffectOutcomes } from './workflow-effect-failures.js';
-import { classifyWorkerRejection, reroutableWorkerRejections } from './worker-rejection.js';
+import { classifyChatGptPlatformFailure, classifyWorkerRejection, reroutableWorkerRejections } from './worker-rejection.js';
 import { applyTaskRetryAction } from './task-actions.js';
 import { DurableTaskTransitionRuntime } from './workflow/durable-transition.js';
 import { eventFor } from './events.js';
@@ -12,24 +14,10 @@ import { createWorkerStartAck } from './worker-start-ack.js';
 import { monitorExecutionProcess } from './execution-process-tracker.js';
 import { HostInteractiveInvocationCoordinator, hostInvocationPorts } from './interactive-invocation.js';
 import { resumeInteractiveTask } from './interactive-resume.js';
-export function executionEventSource(jobId, taskId, executionId) { return `job/${jobId}/task/${taskId}/execution/${executionId}`; }
-function eventSourceId(event) { return typeof event.source?.id === 'string' ? event.source.id : undefined; }
-function executionIdFromSource(sourceId, jobId, taskId) {
-    const prefix = `job/${jobId}/task/${taskId}/execution/`;
-    return sourceId?.startsWith(prefix) ? sourceId.slice(prefix.length) || undefined : undefined;
-}
-const terminalExecutionClaims = new Set();
+import { codexFallbackCompatible, persistChatGptPlatformFailure } from './chatgpt-platform-fallback.js';
 const activeExecutionOwners = new Map();
 import { withExecutionBoundary } from './execution-boundary.js';
 export { withExecutionBoundary } from './execution-boundary.js';
-function claimTerminalExecution(sourceId) {
-    terminalExecutionClaims.add(sourceId);
-    const cleanup = setTimeout(() => terminalExecutionClaims.delete(sourceId), 60000);
-    cleanup.unref();
-}
-function terminalExecutionClaimed(jobId, taskId, executionId) {
-    return terminalExecutionClaims.has(executionEventSource(jobId, taskId, executionId));
-}
 export class ReconcilerRuntimeBase {
     store;
     options;
@@ -271,7 +259,11 @@ export class ReconcilerRuntimeBase {
         }
         return true;
     }
-    async failLaunch(jobId, taskId, executionId, message, phase = 'launch') {
+    async failLaunch(jobId, taskId, executionId, failure, phase = 'launch') {
+        const message = failure instanceof Error ? failure.message : String(failure);
+        const currentJob = await this.store.load(jobId);
+        const currentTask = currentJob.tasks.find(task => task.id === taskId);
+        const platformFailure = currentTask?.adapter === 'chatgpt' ? classifyChatGptPlatformFailure(failure, phase) : undefined;
         const failureReason = phase === 'start-ack' ? 'worker_start_timeout'
             : /BROWSER_WORKSPACE_UNAVAILABLE|browser-workspace runtime dependency unavailable|browser-workspace session start returned no session_id|no close frame received or sent/i.test(message)
                 ? 'browser_workspace_unavailable'
@@ -282,13 +274,20 @@ export class ReconcilerRuntimeBase {
         this.launchFailureClaims.add(claim);
         const cleanup = setTimeout(() => this.launchFailureClaims.delete(claim), 60000);
         cleanup.unref();
-        const workflowEvent = phase === 'start-ack' ? 'worker.start_ack_failed' : 'worker.delivery_failed';
-        const transition = await this.taskTransitions.apply(jobId, taskId, workflowEvent, {
+        const workflowEvent = platformFailure ? 'worker.platform_failure' : phase === 'start-ack' ? 'worker.start_ack_failed' : 'worker.delivery_failed';
+        const usage = this.options.usageSnapshotProvider ? await this.options.usageSnapshotProvider() : undefined;
+        const platformWorkerCompatible = Boolean(platformFailure?.safeToReroute && currentTask && !(currentTask.agentName === 'reviewer' && this.options.reviewer?.threadId)
+            && await codexFallbackCompatible(currentTask, this.options.adapters, await this.store.listAgents(), usage));
+        const transition = await this.taskTransitions.apply(jobId, taskId, platformFailure ? 'worker.platform_failure' : workflowEvent, {
             eligible: (_job, task) => task.executionId === executionId,
-            mutate: (_job, task) => {
-                this.clearExecution(task.id, executionId);
-                task.error = `Worker ${phase} failed: ${message}`;
-                task.failureReason = failureReason;
+            facts: (_job, task) => ({ platformFallbackSafe: task.state === 'QUEUED' && Boolean(platformFailure?.safeToReroute && platformWorkerCompatible && task.attempt < task.maxAttempts) }),
+            mutate: (_job, task, decision) => {
+                if (platformFailure)
+                    persistChatGptPlatformFailure(task, currentTask, executionId, platformFailure.classification, platformFailure.evidence, platformFailure.safeToReroute);
+                task.error = decision.target === 'QUEUED' ? null : `Worker ${phase} failed: ${message}`;
+                task.failureReason = decision.target === 'BLOCKED'
+                    ? (task.platformFailure?.safeToReroute && currentTask?.state === 'QUEUED' ? 'worker_platform_fallback_unavailable' : 'worker_outcome_unknown')
+                    : failureReason;
                 task.leaseOwner = null;
                 task.leaseExpiresAt = null;
             },
@@ -299,21 +298,19 @@ export class ReconcilerRuntimeBase {
             await this.emit(eventFor(jobId, taskId, transition.task.parentTaskId, 'task.process.delivery_failed', 'failed', `Worker ${phase} reported after lifecycle moved to ${transition.from}: ${message}`, 'orchestrator', { phase, authoritative: false, executionId, workflowEvent }, { agent: 'relay', component: 'agents-relay' }));
             return;
         }
-        let runtimeRetry = null;
-        if (failureReason === 'browser_workspace_unavailable' && transition.task.attempt < transition.task.maxAttempts) {
-            const current = (await this.store.load(jobId)).tasks.find(task => task.id === taskId);
-            if (current?.state === 'FAILED' && current.failureReason === failureReason && current.attempt === transition.task.attempt) {
-                await applyTaskRetryAction(current);
-                current.routing = undefined;
-                current.workerSelection = undefined;
-                await this.store.saveTask(current);
-                runtimeRetry = current;
+        if (executionId) {
+            const live = this.live.get(taskId);
+            if (live?.executionId === executionId) {
+                live.controller.abort();
+                live.execution.cancel();
+                this.clearExecution(taskId, executionId);
             }
         }
-        const event = eventFor(jobId, taskId, transition.task.parentTaskId, 'task.failed', 'failed', transition.task.error ?? `Worker ${phase} failed: ${message}`, 'user', { phase, reason: failureReason, workflowEvent }, { agent: 'relay', component: 'agents-relay', watchdog: true });
+        const runtimeRetry = transition.decision.target === 'QUEUED' ? transition.task : null;
+        const event = eventFor(jobId, taskId, transition.task.parentTaskId, 'task.failed', 'failed', transition.task.error ?? `Worker ${phase} failed: ${message}`, 'user', { phase, reason: transition.task.failureReason ?? failureReason, workflowEvent, ...(transition.task.platformFailure ? { platformFailure: transition.task.platformFailure } : {}) }, { agent: 'relay', component: 'agents-relay', watchdog: true });
         this.detach(this.emit(event), jobId, taskId, 'worker failure event');
         if (runtimeRetry) {
-            this.detach(this.emit(eventFor(jobId, taskId, runtimeRetry.parentTaskId, 'task.runtime_retry', 'queued', 'Browser Workspace runtime unavailable; retrying the same Task', 'orchestrator', { previousFailure: failureReason, attempt: runtimeRetry.attempt, maxAttempts: runtimeRetry.maxAttempts })), jobId, taskId, 'runtime retry event');
+            this.detach(this.emit(eventFor(jobId, taskId, runtimeRetry.parentTaskId, 'task.rerouting', 'queued', 'ChatGPT platform rejection recorded; routing the same Task through Execution Router', 'orchestrator', { previousFailure: transition.task.platformFailure?.classification, executionId, attempt: runtimeRetry.attempt, maxAttempts: runtimeRetry.maxAttempts })), jobId, taskId, 'runtime retry event');
             this.detach(this.eventCoordinator.accept({ jobId, reason: 'browser-workspace-runtime-retry' }), jobId, taskId, 'runtime retry reconcile wake');
             return;
         }

package/dist/reconciler.js

@@ -10,6 +10,7 @@ import { dependencyReady, schedule, transitionTaskEvent } from './scheduler.js';
 import { applyTaskRetryAction } from './task-actions.js';
 import { LaunchFailure, StartAckTimeout } from './adapters.js';
 import { eventFor } from './events.js';
+import { PreSubmissionRejection } from './worker-rejection.js';
 import { createPlanRound, materializePlannerChild, pendingPlan } from './planner.js';
 import { retryPendingPlannerUnblocks } from './planner-runtime.js';
 import { dispatchPlannerOrchestration, plannerOrchestrationFacts } from './workflow/planner-orchestration-v2.js';
@@ -373,7 +374,10 @@ export class Reconciler extends ReconcilerReviewBase {
                 await bindPlannedReviewHead(this.store, freshTask, await this.currentHeadSha(freshJob));
             const implementationThread = resolveImplementationTaskThreadDestination(freshJob, freshTask);
             if ((!freshTask.routing || ((implementationThread || (freshTask.agentName === 'reviewer' && resolveReviewerThreadDestination(freshJob, this.options.reviewer?.threadId))) && freshTask.adapter !== 'chatgpt')) && freshTask.adapter !== 'orchestrator') {
-                freshTask = (await this.routeTaskForExecution(freshJob, freshTask)).task;
+                const routed = await this.routeTaskForExecutionFailClosed(freshJob, freshTask);
+                if (!routed)
+                    return;
+                freshTask = routed.task;
             }
             if (['codex', 'chatgpt'].includes(freshTask.adapter) && !freshTask.routing) {
                 throw new Error('Task ' + freshTask.id + ' requires routing metadata before execution claim');
@@ -509,10 +513,10 @@ export class Reconciler extends ReconcilerReviewBase {
         catch (error) {
             await startAckSetup?.stop();
             terminalWait?.cancel();
-            await this.failLaunch(job.id, task.id, task.executionId, error instanceof Error ? error.message : String(error));
+            await this.failLaunch(job.id, task.id, task.executionId, error);
             return;
         }
-        void (execution.launched ?? Promise.resolve()).then(() => Promise.all([recordThreadDelivery(this.store, job.id, task.id, durableExecutionId, workerTask), this.emit(eventFor(job.id, task.id, task.parentTaskId, 'task.process.launched', 'running', `Task ${task.id} process launched`, 'user', { adapter: adapter.id, model: task.routing?.model, pid: execution.pid ?? null, executionId: durableExecutionId }, { agent: 'relay', component: 'agents-relay' }))])).catch(error => this.failLaunch(job.id, task.id, durableExecutionId, error instanceof Error ? error.message : String(error), 'launch'));
+        void (execution.launched ?? Promise.resolve()).then(() => Promise.all([recordThreadDelivery(this.store, job.id, task.id, durableExecutionId, workerTask), this.emit(eventFor(job.id, task.id, task.parentTaskId, 'task.process.launched', 'running', `Task ${task.id} process launched`, 'user', { adapter: adapter.id, model: task.routing?.model, pid: execution.pid ?? null, executionId: durableExecutionId }, { agent: 'relay', component: 'agents-relay' }))])).catch(error => this.failLaunch(job.id, task.id, durableExecutionId, error, 'launch'));
         if (startAckSetup)
             void startAckSetup.ack.finally(() => { void startAckSetup.stop(); }).catch(() => { });
         this.live.set(task.id, { jobId: job.id, taskId: task.id, executionId: durableExecutionId, execution, controller, launchBarrier: startedAt, workerStarted: false, processSettled: false });
@@ -529,9 +533,9 @@ export class Reconciler extends ReconcilerReviewBase {
         }, Math.max(1, task.timeoutMs));
         this.terminalTimers.set(task.id, terminalTimer);
         this.detach(execution.promise.then(result => this.runtimeSettled(job.id, task.id, durableExecutionId, result, null), error => error instanceof StartAckTimeout
-            ? this.failLaunch(job.id, task.id, durableExecutionId, error.message, 'start-ack')
-            : error instanceof LaunchFailure
-                ? this.failLaunch(job.id, task.id, durableExecutionId, error.message, 'delivery')
+            ? this.failLaunch(job.id, task.id, durableExecutionId, error, 'start-ack')
+            : error instanceof LaunchFailure || error instanceof PreSubmissionRejection
+                ? this.failLaunch(job.id, task.id, durableExecutionId, error, 'delivery')
                 : this.runtimeSettled(job.id, task.id, durableExecutionId, null, error instanceof Error ? error.message : String(error))), job.id, task.id, 'worker runtime completion');
     }
     async applyPlannerTree(jobId, planId, executionId, proposal) {

package/dist/worker-rejection.js

@@ -9,3 +9,48 @@ export function classifyWorkerRejection(message) {
     return 'worker_process_failed';
 }
 export const reroutableWorkerRejections = new Set(['rate_limit_exceeded', 'model_not_found', 'provider_unavailable']);
+/** Constructed only from a platform response that explicitly says no submission occurred. */
+export class PreSubmissionRejection extends Error {
+    classification;
+    platformEvidence;
+    constructor(classification, platformEvidence) {
+        super(platformEvidence);
+        this.classification = classification;
+        this.platformEvidence = platformEvidence;
+        this.name = 'PreSubmissionRejection';
+    }
+    static fromPlatformResponse(response) {
+        if (!response || typeof response !== 'object' || Array.isArray(response))
+            return undefined;
+        const result = response;
+        if (result.status !== 'rejected' || result.submitted !== false || typeof result.code !== 'string' || typeof result.message !== 'string')
+            return undefined;
+        const classifications = {
+            MODEL_UNAVAILABLE: 'model_unavailable',
+            MODEL_NOT_FOUND: 'model_unavailable',
+            MCP_LOGIN_REQUIRED: 'mcp_login_required',
+            PROJECT_SETUP_UNAVAILABLE: 'project_setup_unavailable',
+            BROWSER_WORKSPACE_UNAVAILABLE: 'browser_workspace_unavailable',
+        };
+        const classification = classifications[result.code];
+        if (!classification)
+            return undefined;
+        const platformEvidence = JSON.stringify({ status: result.status, submitted: result.submitted, code: result.code, message: result.message });
+        return new PreSubmissionRejection(classification, platformEvidence);
+    }
+}
+/** Only positive pre-submission rejection evidence permits another route to launch. */
+export function classifyChatGptPlatformFailure(error, phase) {
+    if (error instanceof PreSubmissionRejection)
+        return {
+            classification: error.classification,
+            safeToReroute: true,
+            evidence: error.platformEvidence,
+        };
+    const evidence = error instanceof Error ? error.message : String(error);
+    if (phase === 'start-ack')
+        return { classification: 'start_ack_timeout', safeToReroute: false, evidence };
+    if (phase === 'launch')
+        return { classification: 'launch_failure', safeToReroute: false, evidence };
+    return { classification: 'outcome_unknown', safeToReroute: false, evidence };
+}

package/dist/worker-routing.js

@@ -74,22 +74,19 @@ export function workerCandidates(adapters, registered, snapshot) {
         });
     });
 }
-/**
- * Worker legality is intentionally narrow. Descriptive capability labels and provider
- * quota are facts for decide(), not hard gates. An explicit runtime is retained as a
- * compatibility/caller-owned constraint, and an explicitly offline worker is illegal.
- */
-export function satisfiesWorker(candidate, requirements) {
+export function satisfiesWorker(candidate, requirements, options = {}) {
     if (candidate.availability === 'offline')
         return false;
     if (requirements.runtime && candidate.runtime !== requirements.runtime)
         return false;
+    if (options.strictCapabilities && (requirements.capabilities ?? []).some(capability => !candidate.capabilities.includes(capability)))
+        return false;
     if (candidate.adapter === 'chatgpt' && candidate.browserWorkspaceCapacity?.available === 0)
         return false;
     return true;
 }
-export function eligibleWorkerCandidates(candidates, requirements) {
-    return candidates.filter(candidate => satisfiesWorker(candidate, requirements));
+export function eligibleWorkerCandidates(candidates, requirements, options = {}) {
+    return candidates.filter(candidate => satisfiesWorker(candidate, requirements, options));
 }
 function deterministicWorker(eligible) {
     return eligible.find(candidate => candidate.adapter === 'codex') ?? eligible[0];

package/dist/workflow/contracts.js

@@ -40,6 +40,7 @@ export const WORKFLOW_EVENT_NAMES = [
     'watchdog.failed',
     'worker.delivery_failed',
     'worker.start_ack_failed',
+    'worker.platform_failure',
 ];
 export const WORKFLOW_FACT_NAMES = [
     'dependenciesSatisfied',
@@ -59,6 +60,7 @@ export const WORKFLOW_FACT_NAMES = [
     'implementationComplete',
     'headAvailable',
     'mergeCapable',
+    'platformFallbackSafe',
 ];
 export const WORKFLOW_MUTATION_NAMES = [
     'mutation.clearError',
@@ -68,6 +70,8 @@ export const WORKFLOW_MUTATION_NAMES = [
     'mutation.markLeaseExpired',
     'mutation.markStartupOrphanedExhausted',
     'mutation.markPlannerUnavailable',
+    'mutation.preparePlatformFallback',
+    'mutation.quarantinePlatformFailure',
 ];
 export const WORKFLOW_EFFECT_NAMES = [
     'effect.launchTask',

package/dist/workflow/definitions-v2.js

@@ -28,6 +28,7 @@ export const taskLifecycleV2 = load('task-lifecycle', TASK_STATES, {
     troubleshooterRecovery: boolGuard('troubleshooterRecovery'),
     retryAvailable: boolGuard('retryAvailable'),
     autonomousJob: boolGuard('autonomousJob'),
+    platformFallbackSafe: boolGuard('platformFallbackSafe'),
 });
 export const jobLifecycleV2 = load('job-lifecycle', JOB_STATES, {
     notMerged: boolGuard('notMerged'),

package/dist/workflow/runtime.js

@@ -34,6 +34,23 @@ export function applyTaskMutation(task, mutation) {
         task.error = 'Orphaned after relayd restart after maximum attempts';
     if (mutation === 'mutation.markPlannerUnavailable')
         task.error = 'No objective planner configured';
+    if (mutation === 'mutation.preparePlatformFallback') {
+        task.error = null;
+        task.failureReason = undefined;
+        task.routing = undefined;
+        task.workerSelection = undefined;
+        task.leaseOwner = null;
+        task.leaseExpiresAt = null;
+        task.executionId = null;
+    }
+    if (mutation === 'mutation.quarantinePlatformFailure') {
+        task.routing = undefined;
+        task.workerSelection = undefined;
+        task.leaseOwner = null;
+        task.leaseExpiresAt = null;
+        task.executionId = null;
+        task.failureReason = task.platformFailure?.safeToReroute ? 'worker_platform_fallback_unavailable' : 'worker_outcome_unknown';
+    }
 }
 export function applyTaskGraphTarget(task, target, timestamp = new Date().toISOString()) {
     const previous = Date.parse(task.updatedAt), candidate = Date.parse(timestamp);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-relay",
-  "version": "2.0.139",
+  "version": "2.0.141",
   "description": "Durable async agent jobs coordinated through GitHub pull requests",
   "repository": {
     "type": "git",
@@ -18,7 +18,10 @@
     "dev": "tsx src/cli.ts",
     "test:publish": "npm run build && node --import ./test/test-store-env.mjs --test --test-concurrency=1 --test-force-exit test/*.test.js",
     "test:fast": "npm run build && node --import ./test/test-store-env.mjs --test --test-concurrency=2 test/workflow-lifecycle.test.js test/workflow-v2-lifecycle-parity.test.js test/workflow-effects.test.js test/relay-store.test.js test/local-authority.test.js test/local-jobid-routing.test.js test/local-sqlite-jobid.test.js test/no-github.test.js test/scheduled-jobs.test.js test/reconcile-coordinator.test.js test/service-publication.test.js test/github-webhook.test.js",
-    "test:full": "npm run build && node --import ./test/test-store-env.mjs --test --test-concurrency=1 test/*.test.js",
+    "test:full": "npm run build && node --import ./test/test-store-env.mjs --test --test-concurrency=1 test/*.test.js && npm run test:verification:l3",
+    "test:verification:l1": "node --test test/verification/harness.test.mjs",
+    "test:verification:l3": "npm run build && node --test test/verification/harness.test.mjs test/verification/l3-sqlite.test.mjs test/verification/l3-ingress.test.mjs test/verification/l3-replay.test.mjs",
+    "test:verification": "npm run test:verification:l1 && npm run test:verification:l3",
     "e2e": "node e2e/runner/run.mjs"
   },
   "devDependencies": {

package/workflow/task-lifecycle.mmd

@@ -7,6 +7,7 @@ blocked["state: BLOCKED"]
 succeeded["state: SUCCEEDED"]
 failed["state: FAILED"]
 cancelled["state: CANCELLED"]
+platformFallbackSafe["guard: platformFallbackSafe"]
 
 depSat["guard: dependenciesSatisfied"]
 depUnsat["guard: dependenciesUnsatisfied"]
@@ -124,6 +125,13 @@ queued -->|on: effect.launchTask.failed| failed
 queued -->|on: watchdog.failed| failed
 queued -->|on: worker.delivery_failed| failed
 queued -->|on: worker.start_ack_failed| failed
+queued -->|on: worker.platform_failure| platformFallbackSafe
+platformFallbackSafe -->|true| platformFallbackClearFailure
+platformFallbackClearFailure["action: mutation.preparePlatformFallback"]
+platformFallbackClearFailure --> queued
+platformFallbackSafe -->|false| platformFallbackQuarantine
+platformFallbackQuarantine["action: mutation.quarantinePlatformFailure"]
+platformFallbackQuarantine --> blocked
 queued -->|on: planner.unavailable| plannerUnavailableMark
 plannerUnavailableMark --> failed
 queued -->|on: execution.orphaned| orphanRetryAvailable
@@ -150,6 +158,9 @@ running -->|on: task.completed| completeClearError
 completeClearError --> completeClearReason
 completeClearReason --> succeeded
 running -->|on: task.failed| failed
+running -->|on: worker.platform_failure| runningPlatformFailureQuarantine
+runningPlatformFailureQuarantine["action: mutation.quarantinePlatformFailure"]
+runningPlatformFailureQuarantine --> blocked
 running -->|on: watchdog.failed| failed
 running -->|on: planner.failed| plannerRetryAvailable
 running -->|on: execution.orphaned| orphanRetryAvailable