@jsonstudio/rcc 0.90.876 → 0.90.1270

package/dist/server/runtime/http-server/request-executor.js

@@ -1,22 +1,108 @@
 import { attachProviderRuntimeMetadata } from '../../../providers/core/runtime/provider-runtime-metadata.js';
+import { computeProviderFailureBackoffDelayMs, describeProviderFailureDecision, isBlockingRecoverableProviderFailure, resolveProviderFailureExclusionDecision, isProviderFailureHealthNeutral, normalizeProviderFailureCodeKey, resolveProviderFailureRetryEligibility, resolveProviderFailureClassification, resolveProviderFailureActionPlan } from '../../../providers/core/runtime/provider-failure-policy.js';
 import { buildRequestMetadata, cloneClientHeaders, decorateMetadataForAttempt, ensureClientHeadersOnPayload, resolveClientRequestId } from './executor-metadata.js';
+import { loadRoutingInstructionStateSync, rebindResponsesConversationRequestId } from '../../../modules/llmswitch/bridge.js';
 import { convertProviderResponseIfNeeded as convertProviderResponseWithBridge } from './executor/provider-response-converter.js';
 import { ensureHubPipeline, runHubPipeline } from './executor-pipeline.js';
 // Import from new executor submodules
 import { isVerboseErrorLoggingEnabled } from './executor/env-config.js';
-import { resolveMaxProviderAttempts, describeRetryReason, isPromptTooLongError, shouldRetryProviderError, waitBeforeRetry } from './executor/retry-engine.js';
+import { resolveMaxProviderAttempts, describeRetryReason, isPromptTooLongError, waitBeforeRetry } from './executor/retry-engine.js';
+import { isClientDisconnectAbortError } from './executor-provider.js';
 import {} from './executor/sse-error-handler.js';
 import { extractUsageFromResult, mergeUsageMetrics } from './executor/usage-aggregator.js';
 import { bindSessionConversationSession, extractRetryErrorSignature, extractStatusCodeFromError, injectAntigravityRetrySignal, isAntigravityProviderKey, isAntigravityReauthRequired403, isGoogleAccountVerificationRequiredError, isSseDecodeRetryableNetworkError, isSseDecodeRateLimitError, resolveAntigravityMaxProviderAttempts, shouldRotateAntigravityAliasOnRetry } from './executor/request-retry-helpers.js';
-import { cloneRequestPayload, extractProviderModel, extractResponseStatus, normalizeProviderResponse, resolveRequestSemantics } from './executor/provider-response-utils.js';
+import { extractProviderModel, extractResponseStatus, normalizeProviderResponse, resolveRequestSemantics } from './executor/provider-response-utils.js';
 import { isPoolExhaustedPipelineError, mergeMetadataPreservingDefined, resolvePoolCooldownWaitMs, writeInboundClientSnapshot } from './executor/request-executor-core-utils.js';
 import { resolveProviderRuntimeOrThrow } from './executor/provider-runtime-resolver.js';
 import { resolveProviderRequestContext } from './executor/provider-request-context.js';
 import { isServerToolEnabled } from './servertool-admin-state.js';
-import { registerRequestLogContext, resolveSessionLogColor } from '../../utils/request-log-color.js';
-import { STREAM_LOG_FINISH_REASON_KEY } from '../../utils/finish-reason.js';
+import { registerRequestLogContext } from '../../utils/request-log-color.js';
+import { getClientConnectionAbortSignal } from '../../utils/client-connection-state.js';
+import { deriveFinishReason, STREAM_LOG_FINISH_REASON_KEY } from '../../utils/finish-reason.js';
+import { allowSnapshotLocalDiskWrite } from '../../../utils/snapshot-local-disk-gate.js';
+import { writeProviderSnapshot } from '../../../providers/core/utils/snapshot-writer.js';
+import { REASONING_STOP_FINALIZED_FLAG_KEY, REASONING_STOP_FINALIZED_MARKER } from './executor/servertool-response-normalizer.js';
 import { createNoopProviderTrafficGovernor, getSharedProviderTrafficGovernor } from './provider-traffic-governor.js';
+import { recordVirtualRouterHitRollup } from './executor/log-rollup.js';
 const DEFAULT_MAX_PROVIDER_ATTEMPTS = 6;
+const NON_BLOCKING_LOG_THROTTLE_MS = 60_000;
+const nonBlockingLogState = new Map();
+const requestDegradedLogState = new Set();
+const RECOVERABLE_BACKOFF_TTL_MS = 5 * 60_000;
+const recoverableErrorBackoffState = new Map();
+const recoverableRetryGateState = new Map();
+const recoverableRetryWaiterState = new Map();
+const providerTransportBackoffState = new Map();
+const providerTransportBackoffGateState = new Map();
+const SESSION_STORM_BACKOFF_TTL_MS = 10 * 60_000;
+const sessionStormBackoffState = new Map();
+const sessionStormBackoffGateState = new Map();
+const logicalChainRetryState = new Map();
+const PROVIDER_SWITCH_LOG_THROTTLE_MS = 5_000;
+const providerSwitchLogState = new Map();
+const RETRY_SNAPSHOT_PARSE_MAX_CHARS = 256 * 1024;
+const RETRY_SNAPSHOT_RESTORE_MAX_CHARS = 2 * 1024 * 1024;
+const RETRY_SNAPSHOT_SERIALIZE_MAX_CHARS = 256 * 1024;
+const RETRY_PAYLOAD_ESTIMATE_MAX_BYTES = RETRY_SNAPSHOT_SERIALIZE_MAX_CHARS * 2;
+const RETRY_PAYLOAD_ESTIMATE_NODE_BUDGET = 4000;
+const MAX_CONTEXT_OVERFLOW_RETRIES = 3;
+function formatUnknownError(error) {
+    if (error instanceof Error) {
+        return error.stack || `${error.name}: ${error.message}`;
+    }
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return String(error);
+    }
+}
+function cloneErrorForReporting(error) {
+    if (!error || typeof error !== 'object') {
+        return error;
+    }
+    if (error instanceof Error) {
+        const cloned = new Error(error.message);
+        cloned.name = error.name;
+        if (typeof error.stack === 'string') {
+            cloned.stack = error.stack;
+        }
+        return Object.assign(cloned, error);
+    }
+    if (Array.isArray(error)) {
+        return [...error];
+    }
+    return { ...error };
+}
+function logRequestExecutorNonBlockingError(stage, error, details) {
+    const now = Date.now();
+    const last = nonBlockingLogState.get(stage) ?? 0;
+    if (now - last < NON_BLOCKING_LOG_THROTTLE_MS) {
+        return;
+    }
+    nonBlockingLogState.set(stage, now);
+    try {
+        const detailSuffix = details && Object.keys(details).length > 0 ? ` details=${JSON.stringify(details)}` : '';
+        console.warn(`[request-executor] ${stage} failed (non-blocking): ${formatUnknownError(error)}${detailSuffix}`);
+    }
+    catch {
+        // Never throw from non-blocking logging.
+    }
+}
+function logRequestExecutorDegraded(stage, requestId, details) {
+    const key = `${requestId}:${stage}`;
+    if (requestDegradedLogState.has(key)) {
+        return;
+    }
+    requestDegradedLogState.add(key);
+    try {
+        const detailSuffix = details && Object.keys(details).length > 0 ? ` details=${JSON.stringify(details)}` : '';
+        console.warn(`[request-executor][degraded] req=${requestId} stage=${stage}${detailSuffix}`);
+    }
+    catch {
+        // Never throw from degraded logging.
+    }
+}
 function readString(value) {
     if (typeof value !== 'string') {
         return undefined;
@@ -24,6 +110,55 @@ function readString(value) {
     const normalized = value.trim();
     return normalized || undefined;
 }
+function normalizeStoplessLogMode(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'on' || normalized === 'off' || normalized === 'endless') {
+        return normalized;
+    }
+    return undefined;
+}
+function readPersistedStoplessLogState(stickyKey) {
+    if (!stickyKey) {
+        return {};
+    }
+    const state = loadRoutingInstructionStateSync(stickyKey);
+    if (!state || typeof state !== 'object' || Array.isArray(state)) {
+        return {};
+    }
+    const record = state;
+    const mode = normalizeStoplessLogMode(record.reasoningStopMode);
+    return {
+        ...(mode ? { mode } : {}),
+        ...(typeof record.reasoningStopArmed === 'boolean'
+            ? { armed: record.reasoningStopArmed }
+            : {})
+    };
+}
+function resolveStoplessLogState(metadata) {
+    const sessionId = readString(metadata.sessionId);
+    const conversationId = readString(metadata.conversationId);
+    const directMode = normalizeStoplessLogMode(metadata.reasoningStopMode)
+        ?? normalizeStoplessLogMode(metadata.stoplessMode);
+    const directArmed = typeof metadata.reasoningStopArmed === 'boolean'
+        ? metadata.reasoningStopArmed
+        : (typeof metadata.stoplessArmed === 'boolean' ? metadata.stoplessArmed : undefined);
+    const persistedBySession = readPersistedStoplessLogState(sessionId ? `session:${sessionId}` : '');
+    const persistedByConversation = readPersistedStoplessLogState(conversationId ? `conversation:${conversationId}` : '');
+    const mode = directMode ??
+        persistedBySession.mode ??
+        persistedByConversation.mode;
+    if (!mode) {
+        return {};
+    }
+    const armed = directArmed ??
+        persistedBySession.armed ??
+        persistedByConversation.armed ??
+        false;
+    return { mode, armed };
+}
 function readStatusCodeCandidate(value) {
     if (typeof value === 'number' && Number.isFinite(value)) {
         return value;
@@ -40,10 +175,26 @@ function readStatusCodeCandidate(value) {
     return undefined;
 }
 function parseJsonRecordFromText(text) {
+    if (typeof text !== 'string' || !text) {
+        return null;
+    }
+    if (text.length > RETRY_SNAPSHOT_PARSE_MAX_CHARS) {
+        logRequestExecutorNonBlockingError('parseJsonRecordFromText.oversized_skip', new Error('candidate text too large'), { candidateLength: text.length, maxChars: RETRY_SNAPSHOT_PARSE_MAX_CHARS });
+        return null;
+    }
     const normalized = text.trim();
     if (!normalized) {
         return null;
     }
+    const shouldLogParseFailure = (candidate) => {
+        const trimmed = candidate.trimStart();
+        if (trimmed.startsWith('{')) {
+            return true;
+        }
+        // Only treat as JSON array candidate when '[' is followed by JSON-looking payload,
+        // otherwise strings like "[servertool] xxx" should not trigger JSON parse noise.
+        return /^\[\s*[\[{"]/u.test(trimmed);
+    };
     const parseCandidate = (candidate) => {
         try {
             const parsed = JSON.parse(candidate);
@@ -51,14 +202,21 @@ function parseJsonRecordFromText(text) {
                 return parsed;
             }
         }
-        catch {
+        catch (error) {
+            if (shouldLogParseFailure(candidate)) {
+                logRequestExecutorNonBlockingError('parseJsonRecordFromText.parseCandidate', error, {
+                    candidateLength: candidate.length
+                });
+            }
             return null;
         }
         return null;
     };
-    const direct = parseCandidate(normalized);
-    if (direct) {
-        return direct;
+    if (shouldLogParseFailure(normalized)) {
+        const direct = parseCandidate(normalized);
+        if (direct) {
+            return direct;
+        }
     }
     const firstBrace = normalized.indexOf('{');
     const lastBrace = normalized.lastIndexOf('}');
@@ -208,12 +366,1343 @@ function readHubStageTop(metadata) {
         .filter((entry) => Boolean(entry));
     return normalized.length ? normalized : undefined;
 }
+function isServerToolFollowupRequest(metadata) {
+    if (!metadata || typeof metadata !== 'object' || Array.isArray(metadata)) {
+        return false;
+    }
+    const rt = metadata.__rt && typeof metadata.__rt === 'object' && !Array.isArray(metadata.__rt)
+        ? metadata.__rt
+        : undefined;
+    const raw = rt?.serverToolFollowup;
+    return raw === true || (typeof raw === 'string' && raw.trim().toLowerCase() === 'true');
+}
+function readHubDecodeBreakdown(hubStageTop) {
+    if (!Array.isArray(hubStageTop) || hubStageTop.length === 0) {
+        return { sseDecodeMs: 0, codecDecodeMs: 0 };
+    }
+    let sseDecodeMs = 0;
+    let codecDecodeMs = 0;
+    for (const entry of hubStageTop) {
+        const stage = String(entry.stage || '').trim().toLowerCase();
+        const totalMs = Number.isFinite(entry.totalMs) ? Math.max(0, Math.round(entry.totalMs)) : 0;
+        if (!(totalMs > 0) || !stage) {
+            continue;
+        }
+        // `resp_inbound.stage1_sse_decode` is a stable stage checkpoint even for non-stream JSON
+        // responses; counting it as "SSE decode time" makes non-stream requests look like they spent
+        // seconds decoding SSE when they only performed wrapper/text probes. Only explicit codec
+        // decoding work should contribute decode timings.
+        if (stage.includes('codec_decode')) {
+            codecDecodeMs += totalMs;
+        }
+    }
+    return { sseDecodeMs, codecDecodeMs };
+}
+function serializeRequestPayloadForRetry(payload) {
+    if (!payload || typeof payload !== 'object') {
+        return undefined;
+    }
+    try {
+        return JSON.stringify(payload);
+    }
+    catch (error) {
+        logRequestExecutorNonBlockingError('serializeRequestPayloadForRetry', error);
+        return undefined;
+    }
+}
+function cloneRequestPayloadForRetry(payload) {
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        return undefined;
+    }
+    try {
+        const cloned = structuredClone(payload);
+        if (cloned && typeof cloned === 'object' && !Array.isArray(cloned)) {
+            return cloned;
+        }
+    }
+    catch (error) {
+        logRequestExecutorNonBlockingError('cloneRequestPayloadForRetry.structuredClone', error);
+    }
+    return undefined;
+}
+function estimateRetryPayloadBytes(value, options) {
+    const maxBytes = options?.maxBytes ?? Number.POSITIVE_INFINITY;
+    const depth = options?.depth ?? 0;
+    const seen = options?.seen ?? new Set();
+    const nodeBudget = options?.nodeBudget ?? RETRY_PAYLOAD_ESTIMATE_NODE_BUDGET;
+    const visitedNodes = (options?.visitedNodes ?? 0) + 1;
+    if (visitedNodes > nodeBudget) {
+        return maxBytes + 1;
+    }
+    if (value === null || value === undefined) {
+        return 4;
+    }
+    const valueType = typeof value;
+    if (valueType === 'string') {
+        return Math.min(maxBytes + 1, value.length * 2 + 2);
+    }
+    if (valueType === 'number') {
+        return 8;
+    }
+    if (valueType === 'boolean') {
+        return 4;
+    }
+    if (valueType === 'bigint') {
+        return String(value).length + 8;
+    }
+    if (valueType === 'symbol' || valueType === 'function') {
+        return 16;
+    }
+    if (seen.has(value)) {
+        return 8;
+    }
+    seen.add(value);
+    if (depth >= 8) {
+        return 64;
+    }
+    let bytes = 0;
+    if (Array.isArray(value)) {
+        bytes += 2;
+        for (const item of value) {
+            bytes += estimateRetryPayloadBytes(item, {
+                maxBytes: Math.max(0, maxBytes - bytes),
+                depth: depth + 1,
+                seen,
+                nodeBudget,
+                visitedNodes
+            });
+            if (bytes > maxBytes) {
+                return maxBytes + 1;
+            }
+        }
+        return bytes;
+    }
+    if (value && typeof value === 'object') {
+        bytes += 2;
+        for (const [key, child] of Object.entries(value)) {
+            bytes += key.length * 2 + 4;
+            bytes += estimateRetryPayloadBytes(child, {
+                maxBytes: Math.max(0, maxBytes - bytes),
+                depth: depth + 1,
+                seen,
+                nodeBudget,
+                visitedNodes
+            });
+            if (bytes > maxBytes) {
+                return maxBytes + 1;
+            }
+        }
+        return bytes;
+    }
+    return 16;
+}
+function prepareRequestPayloadRetrySeed(payload) {
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        return { mode: 'none' };
+    }
+    const estimatedBytes = estimateRetryPayloadBytes(payload, {
+        maxBytes: RETRY_PAYLOAD_ESTIMATE_MAX_BYTES + 1
+    });
+    if (estimatedBytes <= RETRY_PAYLOAD_ESTIMATE_MAX_BYTES) {
+        const serializedPayload = serializeRequestPayloadForRetry(payload);
+        if (typeof serializedPayload === 'string'
+            && serializedPayload.length <= RETRY_SNAPSHOT_SERIALIZE_MAX_CHARS) {
+            return {
+                mode: 'serialized',
+                serializedPayload
+            };
+        }
+    }
+    const snapshotPayload = cloneRequestPayloadForRetry(payload);
+    if (snapshotPayload) {
+        return {
+            mode: 'snapshot',
+            snapshotPayload
+        };
+    }
+    const serializedPayload = serializeRequestPayloadForRetry(payload);
+    if (typeof serializedPayload === 'string'
+        && serializedPayload.length <= RETRY_SNAPSHOT_SERIALIZE_MAX_CHARS) {
+        return {
+            mode: 'serialized',
+            serializedPayload
+        };
+    }
+    return { mode: 'none' };
+}
+function restoreRequestPayloadFromRetrySeed(seed) {
+    if (seed.mode === 'serialized') {
+        return restoreRequestPayloadFromRetrySnapshot(seed.serializedPayload);
+    }
+    if (seed.mode === 'snapshot') {
+        return cloneRequestPayloadForRetry(seed.snapshotPayload) ?? { ...seed.snapshotPayload };
+    }
+    return undefined;
+}
+function resolveOriginalRequestForResponseConversion(seed) {
+    if (seed.mode === 'snapshot') {
+        return seed.snapshotPayload;
+    }
+    return restoreRequestPayloadFromRetrySeed(seed);
+}
+function restoreRequestPayloadFromRetrySnapshot(serializedPayload, fallbackPayload) {
+    if (serializedPayload && typeof serializedPayload === 'string') {
+        if (serializedPayload.length > RETRY_SNAPSHOT_RESTORE_MAX_CHARS) {
+            logRequestExecutorNonBlockingError('restoreRequestPayloadFromRetrySnapshot.oversized_skip', 'serialized retry payload too large', { payloadLength: serializedPayload.length, maxChars: RETRY_SNAPSHOT_RESTORE_MAX_CHARS });
+        }
+        else {
+            try {
+                const parsed = JSON.parse(serializedPayload);
+                if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                    return parsed;
+                }
+            }
+            catch (error) {
+                logRequestExecutorNonBlockingError('restoreRequestPayloadFromRetrySnapshot.parseSerialized', error, {
+                    payloadLength: serializedPayload.length
+                });
+            }
+        }
+    }
+    if (!fallbackPayload || typeof fallbackPayload !== 'object') {
+        return undefined;
+    }
+    const clonedFallback = cloneRequestPayloadForRetry(fallbackPayload);
+    if (clonedFallback && typeof clonedFallback === 'object') {
+        return clonedFallback;
+    }
+    return { ...fallbackPayload };
+}
 function truncateReason(reason, maxLength = 220) {
     if (reason.length <= maxLength) {
         return reason;
     }
     return `${reason.slice(0, Math.max(0, maxLength - 1))}…`;
 }
+function normalizeCodeKey(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = value.trim().toUpperCase();
+    return normalized || undefined;
+}
+function isServerToolFollowupErrorCode(value) {
+    const normalized = normalizeCodeKey(value);
+    return Boolean(normalized && normalized.startsWith('SERVERTOOL_'));
+}
+function createClientDisconnectedAbortError(reason) {
+    const message = typeof reason === 'string' && reason.trim()
+        ? reason.trim()
+        : reason instanceof Error && typeof reason.message === 'string' && reason.message.trim()
+            ? reason.message.trim()
+            : 'CLIENT_DISCONNECTED';
+    return Object.assign(new Error(message), {
+        code: 'CLIENT_DISCONNECTED',
+        name: 'AbortError',
+        retryable: false
+    });
+}
+function throwIfClientAbortSignalAborted(signal) {
+    if (!signal?.aborted) {
+        return;
+    }
+    const reason = signal.reason;
+    throw reason instanceof Error ? reason : createClientDisconnectedAbortError(reason);
+}
+async function waitWithClientAbortSignal(ms, signal) {
+    throwIfClientAbortSignalAborted(signal);
+    if (!(ms > 0)) {
+        return;
+    }
+    await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            cleanup();
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            cleanup();
+            const reason = signal.reason;
+            reject(reason instanceof Error ? reason : createClientDisconnectedAbortError(reason));
+        };
+        const cleanup = () => {
+            clearTimeout(timer);
+            try {
+                signal?.removeEventListener?.('abort', onAbort);
+            }
+            catch (error) {
+                logRequestExecutorNonBlockingError('waitWithClientAbortSignal.removeEventListener', error);
+            }
+        };
+        try {
+            signal?.addEventListener?.('abort', onAbort, { once: true });
+        }
+        catch (error) {
+            logRequestExecutorNonBlockingError('waitWithClientAbortSignal.addEventListener', error);
+        }
+    });
+}
+function isRequestExecutorProviderErrorStage(value) {
+    return (value === 'provider.runtime_resolve'
+        || value === 'provider.send'
+        || value === 'host.response_contract'
+        || value === 'host.stopless_contract'
+        || value === 'provider.followup'
+        || value === 'provider.sse_decode'
+        || value === 'provider.http');
+}
+function isHostRequestExecutorErrorStage(stage) {
+    return stage === 'host.stopless_contract' || stage === 'host.response_contract';
+}
+function resolveRequestExecutorProviderErrorClassification(args) {
+    return resolveProviderFailureClassification({
+        error: args.error,
+        stage: args.stage,
+        statusCode: typeof args.retryError.statusCode === 'number'
+            ? args.retryError.statusCode
+            : extractStatusCodeFromError(args.error),
+        errorCode: normalizeProviderFailureCodeKey(args.error?.code)
+            ?? normalizeProviderFailureCodeKey(args.retryError.errorCode),
+        upstreamCode: normalizeProviderFailureCodeKey(args.error?.upstreamCode)
+            ?? normalizeProviderFailureCodeKey(args.retryError.upstreamCode),
+        reason: String(args.retryError.reason || args.error?.message || '')
+    });
+}
+function isLastAvailableProvider429(args) {
+    const status = typeof args.retryError.statusCode === 'number' ? args.retryError.statusCode : undefined;
+    const errorCode = normalizeCodeKey(args.retryError.errorCode);
+    const upstreamCode = normalizeCodeKey(args.retryError.upstreamCode);
+    const is429 = status === 429 || errorCode === 'HTTP_429' || upstreamCode === 'HTTP_429';
+    if (!is429 || !readString(args.providerKey)) {
+        return false;
+    }
+    if (!Array.isArray(args.routePool) || args.routePool.length === 0) {
+        return true;
+    }
+    return !hasAlternativeRouteCandidate({
+        providerKey: args.providerKey,
+        routePool: args.routePool,
+        excludedProviderKeys: args.excludedProviderKeys
+    });
+}
+function shouldApplyProviderTransportBackoff(args) {
+    const stage = args.stage ?? 'provider.send';
+    if (stage === 'provider.followup' || isHostRequestExecutorErrorStage(stage)) {
+        return false;
+    }
+    // Fast path: blocking-recoverable errors (429/5xx/network/traffic-saturated etc.)
+    // always get transport backoff.  Reuses shared provider-failure policy to avoid
+    // duplicate status/code predicate logic.
+    if (isBlockingRecoverableProviderFailure({
+        statusCode: args.retryError.statusCode,
+        errorCode: args.retryError.errorCode,
+        upstreamCode: args.retryError.upstreamCode,
+        reason: args.retryError.reason
+    })) {
+        return true;
+    }
+    // Broader catch: also apply for any classified-recoverable error (includes network
+    // transport codes like ECONNRESET that aren't covered by blocking-recoverable's
+    // status/code checks).
+    return resolveRequestExecutorProviderErrorClassification({
+        error: args.error,
+        retryError: args.retryError,
+        stage
+    }) === 'recoverable';
+}
+function extractRequestExecutorProviderErrorStage(error) {
+    if (!error || typeof error !== 'object') {
+        return undefined;
+    }
+    const record = error;
+    const directStage = record.requestExecutorProviderErrorStage;
+    if (isRequestExecutorProviderErrorStage(directStage)) {
+        return directStage;
+    }
+    const details = record.details && typeof record.details === 'object' && !Array.isArray(record.details)
+        ? record.details
+        : undefined;
+    const detailStage = details?.requestExecutorProviderErrorStage
+        ?? details?.source;
+    return isRequestExecutorProviderErrorStage(detailStage) ? detailStage : undefined;
+}
+function resolveRequestExecutorProviderErrorReportPlan(args) {
+    const errorCode = normalizeCodeKey(args.error?.code)
+        ?? normalizeCodeKey(args.retryError.errorCode);
+    const upstreamCode = normalizeCodeKey(args.error?.upstreamCode)
+        ?? normalizeCodeKey(args.retryError.upstreamCode);
+    const statusCode = typeof args.retryError.statusCode === 'number'
+        ? args.retryError.statusCode
+        : extractStatusCodeFromError(args.error);
+    const explicitStage = extractRequestExecutorProviderErrorStage(args.error);
+    const stageHint = explicitStage
+        ? explicitStage
+        : (args.fallbackStage === 'provider.runtime_resolve'
+            ? 'provider.runtime_resolve'
+            : (args.fallbackStage === 'provider.http'
+                ? 'provider.http'
+                : (args.fallbackStage === 'host.response_contract'
+                    ? 'host.response_contract'
+                    : (args.fallbackStage === 'host.stopless_contract'
+                        ? 'host.stopless_contract'
+                        : (isSseDecodeRateLimitError(args.error, statusCode) || isSseDecodeRetryableNetworkError(args.error, statusCode)
+                            ? 'provider.sse_decode'
+                            : (isServerToolFollowupErrorCode(errorCode) || isServerToolFollowupErrorCode(upstreamCode)
+                                ? 'provider.followup'
+                                : args.fallbackStage))))));
+    return {
+        ...(errorCode ? { errorCode } : {}),
+        ...(upstreamCode ? { upstreamCode } : {}),
+        ...(typeof statusCode === 'number' ? { statusCode } : {}),
+        stageHint
+    };
+}
+function isHealthNeutralProviderError(args) {
+    return isProviderFailureHealthNeutral({
+        stage: args.stage,
+        error: args.error,
+        errorCode: args.errorCode,
+        upstreamCode: args.upstreamCode,
+        statusCode: args.statusCode,
+        classification: args.classification
+    });
+}
+function resolveReportedProviderErrorRecoverable(args) {
+    if (args.stage === 'provider.followup' || isHostRequestExecutorErrorStage(args.stage)) {
+        return false;
+    }
+    const classification = resolveRequestExecutorProviderErrorClassification({
+        error: args.error,
+        retryError: args.retryError,
+        stage: args.stage
+    });
+    if (classification === 'special_400') {
+        return false;
+    }
+    if (classification === 'unrecoverable') {
+        return false;
+    }
+    if (classification === 'recoverable') {
+        return true;
+    }
+    return false;
+}
+async function reportRequestExecutorProviderError(args) {
+    const reportPlan = resolveRequestExecutorProviderErrorReportPlan({
+        error: args.error,
+        retryError: args.retryError,
+        fallbackStage: args.stageHint ?? 'provider.send'
+    });
+    const errorCode = reportPlan.errorCode;
+    const upstreamCode = reportPlan.upstreamCode;
+    const statusCode = reportPlan.statusCode;
+    const stage = reportPlan.stageHint;
+    const classification = resolveRequestExecutorProviderErrorClassification({
+        error: args.error,
+        retryError: args.retryError,
+        stage
+    });
+    const affectsHealth = !isHealthNeutralProviderError({
+        stage,
+        error: args.error,
+        errorCode,
+        upstreamCode,
+        statusCode,
+        classification
+    });
+    if (isHostRequestExecutorErrorStage(stage)) {
+        args.logStage('host.contract_failure.classified', args.requestId, {
+            providerKey: args.providerKey,
+            stage,
+            ...(typeof statusCode === 'number' ? { statusCode } : {}),
+            ...(errorCode ? { errorCode } : {}),
+            ...(upstreamCode ? { upstreamCode } : {}),
+            reason: args.retryError.reason,
+            attempt: args.attempt
+        });
+        return;
+    }
+    try {
+        const { emitProviderError } = await import('../../../providers/core/utils/provider-error-reporter.js');
+        emitProviderError({
+            error: args.error,
+            stage,
+            runtime: {
+                requestId: args.requestId,
+                providerKey: args.providerKey,
+                providerId: args.providerId,
+                providerType: args.providerType,
+                providerFamily: args.providerFamily,
+                providerProtocol: args.providerProtocol,
+                routeName: args.routeName,
+                pipelineId: args.providerKey,
+                target: args.target,
+                runtimeKey: args.runtimeKey
+            },
+            dependencies: args.dependencies,
+            statusCode,
+            recoverable: resolveReportedProviderErrorRecoverable({
+                stage,
+                error: args.error,
+                retryError: args.retryError
+            }),
+            affectsHealth,
+            details: {
+                source: stage,
+                ...(classification ? { errorClassification: classification } : {}),
+                ...(errorCode ? { errorCode } : {}),
+                ...(upstreamCode ? { upstreamCode } : {}),
+                reason: args.retryError.reason,
+                attempt: args.attempt,
+                ...(args.extraDetails ?? {})
+            }
+        });
+    }
+    catch (reportError) {
+        args.logStage('provider.error_reporter.failed', args.requestId, {
+            providerKey: args.providerKey,
+            stage,
+            ...(typeof statusCode === 'number' ? { statusCode } : {}),
+            message: reportError instanceof Error ? reportError.message : String(reportError ?? 'Unknown reporter error'),
+            attempt: args.attempt
+        });
+    }
+}
+function buildRecoverableErrorBackoffKey(args) {
+    const providerScope = (() => {
+        const raw = (typeof args.providerKey === 'string' && args.providerKey.trim())
+            || (typeof args.runtimeKey === 'string' && args.runtimeKey.trim())
+            || 'unknown';
+        return `provider:${raw}`;
+    })();
+    const statusPart = typeof args.statusCode === 'number' ? `status:${args.statusCode}` : 'status:none';
+    const errorPart = normalizeCodeKey(args.errorCode) ?? 'error:none';
+    const upstreamPart = normalizeCodeKey(args.upstreamCode) ?? 'upstream:none';
+    const reasonPart = (() => {
+        if (typeof args.reason !== 'string') {
+            return 'reason:none';
+        }
+        const normalized = args.reason.trim().toLowerCase();
+        if (!normalized) {
+            return 'reason:none';
+        }
+        if (normalized.includes('fetch failed'))
+            return 'reason:fetch_failed';
+        if (normalized.includes('building not completed'))
+            return 'reason:building_not_completed';
+        if (normalized.includes('network'))
+            return 'reason:network';
+        if (normalized.includes('timeout'))
+            return 'reason:timeout';
+        return 'reason:other';
+    })();
+    return `${providerScope}|${statusPart}|${errorPart}|${upstreamPart}|${reasonPart}`;
+}
+function consumeRecoverableErrorBackoffMs(key, args) {
+    const now = Date.now();
+    for (const [existingKey, state] of recoverableErrorBackoffState.entries()) {
+        if (now - state.updatedAtMs >= RECOVERABLE_BACKOFF_TTL_MS) {
+            recoverableErrorBackoffState.delete(existingKey);
+        }
+    }
+    const previous = recoverableErrorBackoffState.get(key);
+    const consecutive = previous && now - previous.updatedAtMs < RECOVERABLE_BACKOFF_TTL_MS
+        ? Math.min(previous.consecutive + 1, 16)
+        : 1;
+    recoverableErrorBackoffState.set(key, {
+        consecutive,
+        updatedAtMs: now
+    });
+    return computeProviderFailureBackoffDelayMs({
+        scope: 'recoverable',
+        statusCode: args.statusCode,
+        consecutive
+    });
+}
+function isNetworkTransportLikeError(error) {
+    if (!error || typeof error !== 'object') {
+        return false;
+    }
+    const record = error;
+    const code = typeof record.code === 'string' ? record.code.trim().toUpperCase() : '';
+    if (code === 'ECONNRESET'
+        || code === 'ECONNREFUSED'
+        || code === 'EHOSTUNREACH'
+        || code === 'ENOTFOUND'
+        || code === 'EAI_AGAIN'
+        || code === 'EPIPE'
+        || code === 'ETIMEDOUT'
+        || code === 'ECONNABORTED') {
+        return true;
+    }
+    const name = typeof record.name === 'string' ? record.name : '';
+    const message = typeof record.message === 'string' ? record.message.toLowerCase() : '';
+    if (name === 'AbortError' || message.includes('operation was aborted')) {
+        return true;
+    }
+    return (message.includes('fetch failed')
+        || message.includes('network timeout')
+        || message.includes('socket hang up')
+        || message.includes('client network socket disconnected')
+        || message.includes('tls handshake timeout')
+        || message.includes('unable to verify the first certificate')
+        || message.includes('network error')
+        || message.includes('temporarily unreachable'));
+}
+function consumeProviderScopedRetryBackoffMs(key, args) {
+    const now = Date.now();
+    for (const [existingKey, state] of recoverableErrorBackoffState.entries()) {
+        if (now - state.updatedAtMs >= RECOVERABLE_BACKOFF_TTL_MS) {
+            recoverableErrorBackoffState.delete(existingKey);
+        }
+    }
+    const previous = recoverableErrorBackoffState.get(key);
+    const consecutive = previous && now - previous.updatedAtMs < RECOVERABLE_BACKOFF_TTL_MS
+        ? Math.min(previous.consecutive + 1, 16)
+        : 1;
+    recoverableErrorBackoffState.set(key, {
+        consecutive,
+        updatedAtMs: now
+    });
+    return computeProviderFailureBackoffDelayMs({
+        scope: 'provider',
+        error: args.error,
+        statusCode: args.statusCode,
+        consecutive
+    });
+}
+function buildProviderTransportBackoffKey(args) {
+    const runtimeKey = normalizeRuntimeKey(args.runtimeKey);
+    if (runtimeKey) {
+        return `runtime:${runtimeKey}`;
+    }
+    const providerKey = readString(args.providerKey);
+    if (providerKey) {
+        return `provider:${providerKey}`;
+    }
+    return undefined;
+}
+function consumeProviderTransportBackoffMs(key, args) {
+    const now = Date.now();
+    for (const [existingKey, state] of providerTransportBackoffState.entries()) {
+        if (now - state.updatedAtMs >= RECOVERABLE_BACKOFF_TTL_MS) {
+            providerTransportBackoffState.delete(existingKey);
+        }
+    }
+    const previous = providerTransportBackoffState.get(key);
+    const consecutive = previous && now - previous.updatedAtMs < RECOVERABLE_BACKOFF_TTL_MS
+        ? Math.min(previous.consecutive + 1, 16)
+        : 1;
+    const delayMs = computeProviderFailureBackoffDelayMs({
+        scope: 'provider',
+        error: args.error,
+        statusCode: args.statusCode,
+        consecutive
+    });
+    providerTransportBackoffState.set(key, {
+        consecutive,
+        updatedAtMs: now,
+        nextAllowedAtMs: now + delayMs
+    });
+    return delayMs;
+}
+function peekProviderTransportBackoffWaitMs(key) {
+    const state = providerTransportBackoffState.get(key);
+    if (!state) {
+        return 0;
+    }
+    const now = Date.now();
+    if (now - state.updatedAtMs >= RECOVERABLE_BACKOFF_TTL_MS) {
+        providerTransportBackoffState.delete(key);
+        return 0;
+    }
+    return Math.max(0, state.nextAllowedAtMs - now);
+}
+function clearProviderTransportBackoff(key) {
+    if (!key) {
+        return;
+    }
+    providerTransportBackoffState.delete(key);
+}
+async function waitProviderTransportBackoffWithGate(key, ms, signal) {
+    if (!(ms > 0)) {
+        return;
+    }
+    const normalizedKey = key.trim() || 'provider:unknown';
+    const previous = providerTransportBackoffGateState.get(normalizedKey) ?? Promise.resolve();
+    let release = () => undefined;
+    const current = new Promise((resolve) => {
+        release = resolve;
+    });
+    providerTransportBackoffGateState.set(normalizedKey, current);
+    try {
+        await previous.catch((error) => {
+            logRequestExecutorNonBlockingError('waitProviderTransportBackoffWithGate.previous', error, {
+                key: normalizedKey
+            });
+        });
+        await waitWithClientAbortSignal(ms, signal);
+    }
+    finally {
+        release();
+        if (providerTransportBackoffGateState.get(normalizedKey) === current) {
+            providerTransportBackoffGateState.delete(normalizedKey);
+        }
+    }
+}
+function resolveProviderRetryEligibilityPlan(args) {
+    const antigravityRecoveryEligible = args.allowAntigravityRecovery
+        && isAntigravityProviderKey(args.providerKey)
+        && (args.isVerify || args.isReauth);
+    const eligibility = resolveProviderFailureRetryEligibility({
+        error: args.error,
+        stage: args.stage,
+        statusCode: args.retryError.statusCode,
+        errorCode: args.retryError.errorCode,
+        upstreamCode: args.retryError.upstreamCode,
+        reason: args.retryError.reason,
+        classification: resolveRequestExecutorProviderErrorClassification({
+            error: args.error,
+            retryError: args.retryError,
+            stage: args.stage
+        }),
+        attempt: args.attempt,
+        maxAttempts: args.maxAttempts,
+        promptTooLong: args.promptTooLong,
+        contextOverflowRetries: args.contextOverflowRetries,
+        maxContextOverflowRetries: args.maxContextOverflowRetries ?? MAX_CONTEXT_OVERFLOW_RETRIES,
+        allowNonPolicyRetry: antigravityRecoveryEligible,
+        stageOutsideProviderFailurePolicy: args.stage === 'host.response_contract'
+            || args.stage === 'host.stopless_contract'
+    });
+    return {
+        shouldRetry: eligibility.shouldRetry,
+        blockingRecoverable: eligibility.blockingRecoverable
+    };
+}
+async function resolveProviderRetryExecutionPlan(args) {
+    const hostContractFailure = isHostRequestExecutorErrorStage(args.stage ?? 'provider.send');
+    const rerouteHostContractFailure = args.stage === 'host.stopless_contract';
+    const classification = resolveRequestExecutorProviderErrorClassification({
+        error: args.error,
+        retryError: args.retryError,
+        stage: args.stage
+    });
+    const eligibilityPlan = resolveProviderRetryEligibilityPlan({
+        error: args.error,
+        retryError: args.retryError,
+        attempt: args.attempt,
+        maxAttempts: args.maxAttempts,
+        stage: args.stage,
+        providerKey: args.providerKey,
+        promptTooLong: args.promptTooLong,
+        contextOverflowRetries: args.contextOverflowRetries,
+        maxContextOverflowRetries: args.maxContextOverflowRetries,
+        isVerify: args.isVerify,
+        isReauth: args.isReauth,
+        allowAntigravityRecovery: args.allowAntigravityRecovery
+    });
+    args.recordAttempt({ error: true });
+    if (!eligibilityPlan.shouldRetry) {
+        return {
+            shouldRetry: false,
+            blockingRecoverable: eligibilityPlan.blockingRecoverable,
+            excludedCurrentProvider: false,
+            holdOnLastAvailable429: false,
+            retryBackoffMs: 0,
+            recoverableBackoffMs: 0,
+            antigravityRetrySignal: args.antigravityRetrySignal ?? null
+        };
+    }
+    const exclusionPlan = hostContractFailure
+        ? {
+            excludedCurrentProvider: rerouteHostContractFailure
+                ? applyRetryExclusionForCurrentProvider({
+                    providerKey: args.providerKey,
+                    excludedProviderKeys: args.excludedProviderKeys
+                })
+                : false,
+            antigravityRetrySignal: args.antigravityRetrySignal ?? null
+        }
+        : args.forceExcludeCurrentProviderOnRetry
+            ? {
+                excludedCurrentProvider: applyRetryExclusionForCurrentProvider({
+                    providerKey: args.providerKey,
+                    excludedProviderKeys: args.excludedProviderKeys
+                }),
+                antigravityRetrySignal: args.antigravityRetrySignal ?? null
+            }
+            : resolveProviderRetryExclusionPlan({
+                providerKey: args.providerKey,
+                status: args.status,
+                error: args.error,
+                classification,
+                promptTooLong: Boolean(args.promptTooLong),
+                isVerify: Boolean(args.isVerify),
+                isReauth: Boolean(args.isReauth),
+                antigravityRetrySignal: args.antigravityRetrySignal ?? null,
+                routePool: args.routePool,
+                excludedProviderKeys: args.excludedProviderKeys
+            });
+    const holdOnLastAvailable429 = isLastAvailableProvider429({
+        providerKey: args.providerKey,
+        routePool: args.routePool,
+        excludedProviderKeys: args.excludedProviderKeys,
+        retryError: args.retryError
+    });
+    if (classification === 'unrecoverable'
+        && !exclusionPlan.excludedCurrentProvider
+        && args.error?.retryable !== true) {
+        return {
+            shouldRetry: false,
+            blockingRecoverable: eligibilityPlan.blockingRecoverable,
+            excludedCurrentProvider: false,
+            holdOnLastAvailable429,
+            retryBackoffMs: 0,
+            recoverableBackoffMs: 0,
+            antigravityRetrySignal: exclusionPlan.antigravityRetrySignal
+        };
+    }
+    const retryBackoffPlan = await resolveProviderRetryBackoffPlan({
+        error: args.error,
+        retryError: args.retryError,
+        providerKey: args.providerKey,
+        runtimeKey: args.runtimeKey,
+        logicalRequestChainKey: args.logicalRequestChainKey,
+        logicalChainRetryLimitStageRequestId: args.logicalChainRetryLimitStageRequestId,
+        attempt: args.attempt,
+        forceProviderScopedBackoff: exclusionPlan.excludedCurrentProvider,
+        forceAttemptScopedBackoff: hostContractFailure && !exclusionPlan.excludedCurrentProvider,
+        abortSignal: args.abortSignal,
+        logStage: args.logStage
+    });
+    const retrySwitchPlan = buildProviderRetrySwitchPlan({
+        runtimeKey: args.runtimeKey,
+        routePool: args.routePool,
+        runtimeManager: args.runtimeManager,
+        excludedProviderKeys: args.excludedProviderKeys,
+        excludedCurrentProvider: exclusionPlan.excludedCurrentProvider,
+        promptTooLong: args.promptTooLong,
+        error: args.error,
+        retryError: args.retryError,
+        backoffScope: retryBackoffPlan.backoffScope
+    });
+    if (classification === 'unrecoverable'
+        && retrySwitchPlan.switchAction === 'exclude_and_reroute'
+        && !hasAlternativeRouteCandidate({
+            providerKey: args.providerKey,
+            routePool: args.routePool,
+            excludedProviderKeys: args.excludedProviderKeys
+        })) {
+        return {
+            shouldRetry: false,
+            blockingRecoverable: eligibilityPlan.blockingRecoverable,
+            excludedCurrentProvider: exclusionPlan.excludedCurrentProvider,
+            holdOnLastAvailable429,
+            retryBackoffMs: 0,
+            recoverableBackoffMs: 0,
+            antigravityRetrySignal: exclusionPlan.antigravityRetrySignal
+        };
+    }
+    return {
+        shouldRetry: true,
+        blockingRecoverable: eligibilityPlan.blockingRecoverable,
+        excludedCurrentProvider: exclusionPlan.excludedCurrentProvider,
+        holdOnLastAvailable429,
+        retryBackoffMs: retryBackoffPlan.retryBackoffMs,
+        recoverableBackoffMs: retryBackoffPlan.recoverableBackoffMs,
+        backoffScope: retryBackoffPlan.backoffScope,
+        retrySwitchPlan,
+        antigravityRetrySignal: exclusionPlan.antigravityRetrySignal
+    };
+}
+function hasAlternativeRouteCandidate(args) {
+    const currentProviderKey = readString(args.providerKey);
+    if (!Array.isArray(args.routePool) || args.routePool.length === 0) {
+        return true;
+    }
+    return args.routePool.some((candidate) => {
+        const normalized = readString(candidate);
+        if (!normalized) {
+            return false;
+        }
+        if (currentProviderKey && normalized === currentProviderKey) {
+            return false;
+        }
+        return !args.excludedProviderKeys.has(normalized);
+    });
+}
+function resolveExcludedProviderReselectionPlan(args) {
+    const hasAlternativeCandidate = hasAlternativeRouteCandidate({
+        providerKey: args.providerKey,
+        routePool: args.routePool,
+        excludedProviderKeys: args.excludedProviderKeys
+    });
+    const classification = args.lastError
+        ? resolveRequestExecutorProviderErrorClassification({
+            error: args.lastError,
+            retryError: extractRetryErrorSnapshot(args.lastError),
+            stage: 'provider.send'
+        })
+        : undefined;
+    return {
+        hasAlternativeCandidate,
+        keepExcludedForNextAttempt: classification === 'unrecoverable' || hasAlternativeCandidate
+    };
+}
+async function resolveRequestExecutorProviderFailurePlan(args) {
+    const reportPlan = resolveRequestExecutorProviderErrorReportPlan({
+        error: args.error,
+        retryError: args.retryError,
+        fallbackStage: args.stage
+    });
+    const retryExecutionPlan = await resolveProviderRetryExecutionPlan({
+        error: args.error,
+        retryError: args.retryError,
+        attempt: args.attempt,
+        maxAttempts: args.maxAttempts,
+        stage: reportPlan.stageHint,
+        providerKey: args.providerKey,
+        runtimeKey: args.runtimeKey,
+        logicalRequestChainKey: args.logicalRequestChainKey,
+        logicalChainRetryLimitStageRequestId: args.logicalChainRetryLimitStageRequestId,
+        routePool: args.routePool,
+        runtimeManager: args.runtimeManager,
+        excludedProviderKeys: args.excludedProviderKeys,
+        recordAttempt: args.recordAttempt,
+        logStage: args.logStage,
+        promptTooLong: args.promptTooLong,
+        contextOverflowRetries: args.contextOverflowRetries,
+        maxContextOverflowRetries: args.maxContextOverflowRetries,
+        isVerify: args.isVerify,
+        isReauth: args.isReauth,
+        allowAntigravityRecovery: args.allowAntigravityRecovery,
+        antigravityRetrySignal: args.antigravityRetrySignal,
+        status: args.status,
+        forceExcludeCurrentProviderOnRetry: args.forceExcludeCurrentProviderOnRetry,
+        abortSignal: args.abortSignal
+    });
+    // `reportRequestExecutorProviderError -> emitProviderError` may back-propagate
+    // `recoverable` onto the original error object (`err.retryable = recoverable`).
+    // Retry planning must use the provider's original retry hint, not the router-facing
+    // classification side effect, otherwise retryable 403/compat cases can be downgraded
+    // before host failover sees them.
+    await reportRequestExecutorProviderError({
+        error: cloneErrorForReporting(args.error),
+        retryError: args.retryError,
+        requestId: args.requestId,
+        providerKey: args.providerKey,
+        providerId: args.providerId,
+        providerType: args.providerType,
+        providerFamily: args.providerFamily,
+        providerProtocol: args.providerProtocol,
+        routeName: args.routeName,
+        runtimeKey: args.runtimeKey,
+        target: args.target,
+        dependencies: args.dependencies,
+        attempt: args.attempt,
+        logStage: args.logStage,
+        stageHint: reportPlan.stageHint
+    });
+    const retryTelemetryPlan = retryExecutionPlan.shouldRetry && retryExecutionPlan.retrySwitchPlan && retryExecutionPlan.backoffScope
+        ? buildProviderRetryTelemetryPlan({
+            requestId: args.requestId,
+            attempt: args.attempt,
+            maxAttempts: args.maxAttempts,
+            providerKey: args.providerKey,
+            retryError: args.retryError,
+            excludedProviderKeys: args.excludedProviderKeys,
+            routeHint: args.routeHint,
+            retryExecutionPlan,
+            stage: args.stage,
+            runtimeKey: args.runtimeKey,
+            promptTooLong: args.promptTooLong,
+            contextOverflowRetries: args.contextOverflowRetries,
+            maxContextOverflowRetries: args.maxContextOverflowRetries
+        })
+        : undefined;
+    return {
+        reportPlan,
+        retryExecutionPlan,
+        ...(retryTelemetryPlan ? { retryTelemetryPlan } : {})
+    };
+}
+function emitRequestExecutorProviderRetryTelemetry(args) {
+    if (args.retryTelemetryPlan.runtimeScopeExcludeDetails) {
+        args.logStage('provider.retry.runtime_scope_exclude', args.requestId, args.retryTelemetryPlan.runtimeScopeExcludeDetails);
+    }
+    args.logProviderRetrySwitch(args.retryTelemetryPlan.switchLogArgs);
+    args.logStage('provider.retry', args.requestId, args.retryTelemetryPlan.retryStageDetails);
+}
+function buildProviderRetryTelemetryPlan(args) {
+    if (!args.retryExecutionPlan.retrySwitchPlan || !args.retryExecutionPlan.backoffScope) {
+        throw new Error('retry telemetry requires retrySwitchPlan/backoffScope');
+    }
+    const retrySwitchPlan = args.retryExecutionPlan.retrySwitchPlan;
+    const nextAttempt = Math.min(args.maxAttempts, args.attempt + 1);
+    const switchLogArgs = {
+        requestId: args.requestId,
+        attempt: args.attempt,
+        maxAttempts: args.maxAttempts,
+        providerKey: args.providerKey,
+        nextAttempt,
+        reason: args.retryError.reason,
+        backoffMs: args.retryExecutionPlan.retryBackoffMs,
+        statusCode: args.retryError.statusCode,
+        errorCode: args.retryError.errorCode,
+        upstreamCode: args.retryError.upstreamCode,
+        switchAction: retrySwitchPlan.switchAction,
+        backoffScope: args.retryExecutionPlan.backoffScope,
+        decisionLabel: retrySwitchPlan.decisionLabel,
+        stage: args.stage,
+        runtimeScopeExcludedCount: retrySwitchPlan.runtimeScopeExcludedCount
+    };
+    const retryStageDetails = {
+        providerKey: args.providerKey,
+        attempt: args.attempt,
+        nextAttempt,
+        excluded: Array.from(args.excludedProviderKeys),
+        reason: args.retryError.reason,
+        routeHint: args.routeHint,
+        switchAction: retrySwitchPlan.switchAction,
+        ...(typeof args.retryError.statusCode === 'number' ? { statusCode: args.retryError.statusCode } : {}),
+        ...(args.retryError.errorCode ? { errorCode: args.retryError.errorCode } : {}),
+        ...(args.retryError.upstreamCode ? { upstreamCode: args.retryError.upstreamCode } : {}),
+        retryBackoffMs: args.retryExecutionPlan.retryBackoffMs,
+        recoverableBackoffMs: args.retryExecutionPlan.recoverableBackoffMs,
+        backoffScope: args.retryExecutionPlan.backoffScope,
+        decisionLabel: retrySwitchPlan.decisionLabel,
+        ...(retrySwitchPlan.runtimeScopeExcludedCount > 0
+            ? { runtimeScopeExcludedCount: retrySwitchPlan.runtimeScopeExcludedCount }
+            : {}),
+        holdOnLastAvailable429: args.retryExecutionPlan.holdOnLastAvailable429,
+        blockingRecoverable: args.retryExecutionPlan.blockingRecoverable,
+        ...(args.promptTooLong
+            ? {
+                contextOverflowRetries: args.contextOverflowRetries,
+                maxContextOverflowRetries: args.maxContextOverflowRetries
+            }
+            : {})
+    };
+    const runtimeScopeExcludeDetails = retrySwitchPlan.runtimeScopeExcluded.length > 0
+        ? {
+            providerKey: args.providerKey,
+            runtimeKey: args.runtimeKey,
+            excludedRuntimeScope: retrySwitchPlan.runtimeScopeExcluded,
+            attempt: args.attempt
+        }
+        : undefined;
+    return {
+        switchLogArgs,
+        retryStageDetails,
+        runtimeScopeExcludeDetails
+    };
+}
+async function resolveProviderRetryBackoffPlan(args) {
+    const actionPlan = resolveProviderFailureActionPlan({
+        error: args.error,
+        statusCode: args.retryError.statusCode,
+        errorCode: args.retryError.errorCode,
+        upstreamCode: args.retryError.upstreamCode,
+        reason: args.retryError.reason,
+        forceProviderScopedBackoff: args.forceProviderScopedBackoff,
+        forceAttemptScopedBackoff: args.forceAttemptScopedBackoff,
+        retryAction: args.forceProviderScopedBackoff ? 'reroute_explicit_alternative' : 'retry_same_provider'
+    });
+    const blockingRecoverable = actionPlan.blockingRecoverable;
+    if (blockingRecoverable) {
+        const logicalChainRetry = consumeLogicalChainRecoverableRetry(args.logicalRequestChainKey);
+        if (!logicalChainRetry.allowed) {
+            args.logStage('provider.retry.logical_chain_limit_hit', args.logicalChainRetryLimitStageRequestId, {
+                providerKey: args.providerKey,
+                logicalRequestChainKey: args.logicalRequestChainKey,
+                logicalChainRecoverableRetries: logicalChainRetry.count,
+                logicalChainRecoverableRetryLimit: logicalChainRetry.limit,
+                attempt: args.attempt,
+                ...(typeof args.retryError.statusCode === 'number' ? { statusCode: args.retryError.statusCode } : {}),
+                ...(args.retryError.errorCode ? { errorCode: args.retryError.errorCode } : {}),
+                ...(args.retryError.upstreamCode ? { upstreamCode: args.retryError.upstreamCode } : {}),
+                reason: args.retryError.reason
+            });
+            throw args.error;
+        }
+    }
+    if (actionPlan.backoff.scope === 'attempt') {
+        const retryBackoffMs = await waitBeforeRetry(args.error, {
+            attempt: args.attempt,
+            signal: args.abortSignal
+        });
+        return {
+            blockingRecoverable,
+            retryBackoffMs,
+            recoverableBackoffMs: 0,
+            backoffScope: 'attempt'
+        };
+    }
+    if (actionPlan.backoff.scope === 'provider') {
+        const providerScopedKey = buildRecoverableErrorBackoffKey({
+            providerKey: args.providerKey,
+            runtimeKey: args.runtimeKey,
+            statusCode: args.retryError.statusCode,
+            errorCode: args.retryError.errorCode,
+            upstreamCode: args.retryError.upstreamCode,
+            reason: args.retryError.reason
+        });
+        const retryBackoffMs = consumeProviderScopedRetryBackoffMs(providerScopedKey, {
+            error: args.error,
+            statusCode: args.retryError.statusCode
+        });
+        await waitRecoverableBackoffWithGlobalGate(providerScopedKey, retryBackoffMs, args.abortSignal);
+        return {
+            blockingRecoverable,
+            retryBackoffMs,
+            recoverableBackoffMs: 0,
+            backoffScope: 'provider'
+        };
+    }
+    if (actionPlan.backoff.scope !== 'recoverable') {
+        const retryBackoffMs = await waitBeforeRetry(args.error, {
+            attempt: args.attempt,
+            signal: args.abortSignal
+        });
+        return {
+            blockingRecoverable,
+            retryBackoffMs,
+            recoverableBackoffMs: 0,
+            backoffScope: 'attempt'
+        };
+    }
+    const recoverableKey = buildRecoverableErrorBackoffKey({
+        providerKey: args.providerKey,
+        runtimeKey: args.runtimeKey,
+        statusCode: args.retryError.statusCode,
+        errorCode: args.retryError.errorCode,
+        upstreamCode: args.retryError.upstreamCode,
+        reason: args.retryError.reason
+    });
+    const recoverableBackoffMs = consumeRecoverableErrorBackoffMs(recoverableKey, {
+        statusCode: args.retryError.statusCode,
+        errorCode: args.retryError.errorCode,
+        upstreamCode: args.retryError.upstreamCode,
+        reason: args.retryError.reason
+    });
+    await waitRecoverableBackoffWithGlobalGate(recoverableKey, recoverableBackoffMs, args.abortSignal);
+    return {
+        blockingRecoverable,
+        retryBackoffMs: recoverableBackoffMs,
+        recoverableBackoffMs,
+        backoffScope: 'recoverable'
+    };
+}
+function buildProviderRetrySwitchPlan(args) {
+    const switchAction = args.excludedCurrentProvider ? 'exclude_and_reroute' : 'retry_same_provider';
+    let runtimeScopeExcluded = [];
+    const isProviderTrafficSaturated = args.retryError?.errorCode === 'PROVIDER_TRAFFIC_SATURATED'
+        || (typeof args.error?.code === 'string'
+            && args.error.code === 'PROVIDER_TRAFFIC_SATURATED');
+    if (!args.promptTooLong
+        && args.excludedCurrentProvider
+        && isProviderTrafficSaturated
+        && Array.isArray(args.routePool)
+        && args.routePool.length > 0
+        && args.runtimeManager) {
+        runtimeScopeExcluded = excludeProvidersSharingRuntimeFromRoutePool({
+            routePool: args.routePool,
+            runtimeKey: args.runtimeKey ?? '',
+            runtimeManager: args.runtimeManager,
+            excludedProviderKeys: args.excludedProviderKeys
+        });
+    }
+    return {
+        switchAction,
+        decisionLabel: describeProviderFailureDecision({
+            action: switchAction === 'exclude_and_reroute' ? 'reroute_explicit_alternative' : 'retry_same_provider',
+            backoffScope: args.backoffScope
+        }),
+        runtimeScopeExcluded,
+        runtimeScopeExcludedCount: runtimeScopeExcluded.length
+    };
+}
+async function waitRecoverableBackoffMs(ms, signal) {
+    await waitWithClientAbortSignal(ms, signal);
+}
+function resolveRecoverableBackoffMaxWaiters() {
+    const raw = process.env.ROUTECODEX_RECOVERABLE_BACKOFF_MAX_WAITERS
+        ?? process.env.RCC_RECOVERABLE_BACKOFF_MAX_WAITERS
+        ?? '';
+    const parsed = Number.parseInt(String(raw).trim(), 10);
+    if (Number.isFinite(parsed) && parsed >= 1) {
+        return parsed;
+    }
+    return 64;
+}
+function acquireRecoverableWaiterSlot(key) {
+    const normalizedKey = key.trim() || 'recoverable:unknown';
+    const now = Date.now();
+    for (const [existingKey, state] of recoverableRetryWaiterState.entries()) {
+        if (state.activeWaiters <= 0 || now - state.updatedAtMs >= RECOVERABLE_BACKOFF_TTL_MS) {
+            recoverableRetryWaiterState.delete(existingKey);
+        }
+    }
+    const current = recoverableRetryWaiterState.get(normalizedKey);
+    const nextActiveWaiters = (current?.activeWaiters ?? 0) + 1;
+    const maxWaiters = resolveRecoverableBackoffMaxWaiters();
+    if (nextActiveWaiters > maxWaiters) {
+        throw Object.assign(new Error(`recoverable retry waiters overloaded for key ${normalizedKey}`), {
+            statusCode: 429,
+            code: 'PROVIDER_TRAFFIC_SATURATED',
+            retryable: true,
+            details: {
+                reason: 'recoverable_waiter_overload',
+                recoverableKey: normalizedKey,
+                activeWaiters: current?.activeWaiters ?? 0,
+                maxWaiters
+            }
+        });
+    }
+    recoverableRetryWaiterState.set(normalizedKey, {
+        activeWaiters: nextActiveWaiters,
+        updatedAtMs: now
+    });
+    return {
+        key: normalizedKey,
+        activeWaiters: nextActiveWaiters
+    };
+}
+function releaseRecoverableWaiterSlot(key) {
+    const normalizedKey = key.trim() || 'recoverable:unknown';
+    const current = recoverableRetryWaiterState.get(normalizedKey);
+    if (!current) {
+        return;
+    }
+    const nextActiveWaiters = Math.max(0, current.activeWaiters - 1);
+    if (nextActiveWaiters === 0) {
+        recoverableRetryWaiterState.delete(normalizedKey);
+        return;
+    }
+    recoverableRetryWaiterState.set(normalizedKey, {
+        activeWaiters: nextActiveWaiters,
+        updatedAtMs: Date.now()
+    });
+}
+function acquireRecoverableRetryWaiterSlotForTests(key) {
+    return acquireRecoverableWaiterSlot(key);
+}
+function releaseRecoverableRetryWaiterSlotForTests(key) {
+    releaseRecoverableWaiterSlot(key);
+}
+async function waitRecoverableBackoffWithGlobalGate(key, ms, signal) {
+    const waiter = acquireRecoverableWaiterSlot(key);
+    const normalizedKey = waiter.key;
+    const previous = recoverableRetryGateState.get(normalizedKey) ?? Promise.resolve();
+    let release = () => undefined;
+    const current = new Promise((resolve) => {
+        release = resolve;
+    });
+    recoverableRetryGateState.set(normalizedKey, current);
+    try {
+        await previous.catch((error) => {
+            logRequestExecutorNonBlockingError('waitRecoverableBackoffWithGlobalGate.previous', error, {
+                key: normalizedKey
+            });
+        });
+        await waitRecoverableBackoffMs(ms, signal);
+    }
+    finally {
+        release();
+        if (recoverableRetryGateState.get(normalizedKey) === current) {
+            recoverableRetryGateState.delete(normalizedKey);
+        }
+        releaseRecoverableWaiterSlot(normalizedKey);
+    }
+}
+function deriveLogicalRequestChainKey(requestId) {
+    const normalized = typeof requestId === 'string' ? requestId.trim() : '';
+    if (!normalized) {
+        return 'request-chain:unknown';
+    }
+    const root = normalized.split(':')[0]?.trim() || normalized;
+    return root || 'request-chain:unknown';
+}
+function resolveLogicalChainRecoverableRetryLimit() {
+    const raw = process.env.ROUTECODEX_LOGICAL_CHAIN_RECOVERABLE_RETRY_LIMIT
+        ?? process.env.RCC_LOGICAL_CHAIN_RECOVERABLE_RETRY_LIMIT
+        ?? '';
+    const parsed = Number.parseInt(String(raw).trim(), 10);
+    if (Number.isFinite(parsed) && parsed >= 1) {
+        return parsed;
+    }
+    return 8;
+}
+function retainLogicalRequestChain(key) {
+    const normalizedKey = key.trim() || 'request-chain:unknown';
+    const now = Date.now();
+    for (const [existingKey, state] of logicalChainRetryState.entries()) {
+        if (state.activeExecutions <= 0 && now - state.updatedAtMs >= RECOVERABLE_BACKOFF_TTL_MS) {
+            logicalChainRetryState.delete(existingKey);
+        }
+    }
+    const current = logicalChainRetryState.get(normalizedKey);
+    logicalChainRetryState.set(normalizedKey, {
+        recoverableRetries: current?.recoverableRetries ?? 0,
+        updatedAtMs: now,
+        activeExecutions: (current?.activeExecutions ?? 0) + 1
+    });
+    return normalizedKey;
+}
+function releaseLogicalRequestChain(key) {
+    const current = logicalChainRetryState.get(key);
+    if (!current) {
+        return;
+    }
+    const nextActiveExecutions = Math.max(0, current.activeExecutions - 1);
+    if (nextActiveExecutions === 0) {
+        logicalChainRetryState.delete(key);
+        return;
+    }
+    logicalChainRetryState.set(key, {
+        ...current,
+        activeExecutions: nextActiveExecutions,
+        updatedAtMs: Date.now()
+    });
+}
+function consumeLogicalChainRecoverableRetry(key) {
+    const normalizedKey = key.trim() || 'request-chain:unknown';
+    const limit = resolveLogicalChainRecoverableRetryLimit();
+    const current = logicalChainRetryState.get(normalizedKey) ?? {
+        recoverableRetries: 0,
+        updatedAtMs: 0,
+        activeExecutions: 0
+    };
+    const count = current.recoverableRetries + 1;
+    const next = {
+        ...current,
+        recoverableRetries: count,
+        updatedAtMs: Date.now()
+    };
+    logicalChainRetryState.set(normalizedKey, next);
+    return {
+        allowed: count <= limit,
+        count,
+        limit
+    };
+}
+function resetRequestExecutorInternalStateForTests() {
+    nonBlockingLogState.clear();
+    requestDegradedLogState.clear();
+    recoverableErrorBackoffState.clear();
+    recoverableRetryGateState.clear();
+    recoverableRetryWaiterState.clear();
+    providerTransportBackoffState.clear();
+    providerTransportBackoffGateState.clear();
+    sessionStormBackoffState.clear();
+    sessionStormBackoffGateState.clear();
+    logicalChainRetryState.clear();
+    providerSwitchLogState.clear();
+}
+function peekRecoverableRetryWaitersForTests(key) {
+    const normalizedKey = key.trim() || 'recoverable:unknown';
+    return recoverableRetryWaiterState.get(normalizedKey)?.activeWaiters ?? 0;
+}
 function resolveTrafficRuntimeProfile(runtimeKey, handle, providerKey) {
     const runtimeCandidate = handle.runtime;
     if (runtimeCandidate && typeof runtimeCandidate === 'object') {
@@ -247,6 +1736,127 @@ function resolveTrafficRuntimeProfile(runtimeKey, handle, providerKey) {
         }
     };
 }
+function normalizeRuntimeKey(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = value.trim();
+    return normalized || undefined;
+}
+function resolveRuntimeKeyForProvider(runtimeManager, providerKey) {
+    return normalizeRuntimeKey(runtimeManager.resolveRuntimeKey(providerKey));
+}
+function applyRetryExclusionForCurrentProvider(args) {
+    const providerKey = readString(args.providerKey);
+    if (!providerKey) {
+        return false;
+    }
+    args.excludedProviderKeys.add(providerKey);
+    return true;
+}
+function isProviderTrafficSaturatedRetryError(args) {
+    const code = normalizeCodeKey(args.error?.code);
+    const upstreamCode = normalizeCodeKey(args.error?.upstreamCode);
+    if (code === 'PROVIDER_TRAFFIC_SATURATED' || upstreamCode === 'PROVIDER_TRAFFIC_SATURATED') {
+        return true;
+    }
+    return args.status === 429 && code === 'PROVIDER_TRAFFIC_SATURATED';
+}
+function resolveProviderRetryExclusionPlan(args) {
+    const providerKey = readString(args.providerKey);
+    let nextAntigravityRetrySignal = args.antigravityRetrySignal;
+    if (!providerKey) {
+        return {
+            excludedCurrentProvider: false,
+            antigravityRetrySignal: nextAntigravityRetrySignal
+        };
+    }
+    const isAntigravity = isAntigravityProviderKey(providerKey);
+    const is429 = args.status === 429;
+    const exclusionDecision = resolveProviderFailureExclusionDecision({
+        promptTooLong: args.promptTooLong,
+        classification: args.classification,
+        isProviderTrafficSaturated: isProviderTrafficSaturatedRetryError({ status: args.status, error: args.error }),
+        isNetworkTransport: isNetworkTransportLikeError(args.error),
+        hasAlternativeCandidate: hasExplicitAlternativeRouteCandidate({
+            providerKey,
+            routePool: args.routePool,
+            excludedProviderKeys: args.excludedProviderKeys
+        }),
+        isAntigravity,
+        is429,
+        isVerify: args.isVerify,
+        isReauth: args.isReauth,
+        shouldRotateAntigravityAlias: shouldRotateAntigravityAliasOnRetry(args.error)
+    });
+    if (exclusionDecision.excludeCurrentProvider && isAntigravity && (args.isVerify || is429)) {
+        const excludedCurrentProvider = applyRetryExclusionForCurrentProvider({
+            providerKey,
+            excludedProviderKeys: args.excludedProviderKeys
+        });
+        nextAntigravityRetrySignal = nextAntigravityRetrySignal
+            ? { ...nextAntigravityRetrySignal, avoidAllOnRetry: true }
+            : { signature: extractRetryErrorSignature(args.error), consecutive: 1, avoidAllOnRetry: true };
+        return {
+            excludedCurrentProvider,
+            antigravityRetrySignal: nextAntigravityRetrySignal
+        };
+    }
+    if (exclusionDecision.excludeCurrentProvider && isAntigravity && args.isReauth) {
+        return {
+            excludedCurrentProvider: applyRetryExclusionForCurrentProvider({
+                providerKey,
+                excludedProviderKeys: args.excludedProviderKeys
+            }),
+            antigravityRetrySignal: nextAntigravityRetrySignal
+        };
+    }
+    if (exclusionDecision.excludeCurrentProvider) {
+        return {
+            excludedCurrentProvider: applyRetryExclusionForCurrentProvider({
+                providerKey,
+                excludedProviderKeys: args.excludedProviderKeys
+            }),
+            antigravityRetrySignal: nextAntigravityRetrySignal
+        };
+    }
+    return {
+        excludedCurrentProvider: false,
+        antigravityRetrySignal: nextAntigravityRetrySignal
+    };
+}
+function excludeProvidersSharingRuntimeFromRoutePool(args) {
+    const currentRuntimeKey = normalizeRuntimeKey(args.runtimeKey);
+    if (!currentRuntimeKey) {
+        return [];
+    }
+    const added = [];
+    for (const providerKey of args.routePool) {
+        if (typeof providerKey !== 'string') {
+            continue;
+        }
+        const normalizedProviderKey = providerKey.trim();
+        if (!normalizedProviderKey) {
+            continue;
+        }
+        const candidateRuntimeKey = resolveRuntimeKeyForProvider(args.runtimeManager, normalizedProviderKey);
+        if (candidateRuntimeKey !== currentRuntimeKey) {
+            continue;
+        }
+        if (args.excludedProviderKeys.has(normalizedProviderKey)) {
+            continue;
+        }
+        args.excludedProviderKeys.add(normalizedProviderKey);
+        added.push(normalizedProviderKey);
+    }
+    return added;
+}
+function hasExplicitAlternativeRouteCandidate(args) {
+    if (!Array.isArray(args.routePool) || args.routePool.length === 0) {
+        return false;
+    }
+    return hasAlternativeRouteCandidate(args);
+}
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -318,26 +1928,19 @@ function backfillResponsesOutputTextIfMissing(body) {
     body.output_text = text;
 }
 function emitVirtualRouterConcurrencyLog(args) {
-    const timestamp = (() => {
-        const now = new Date();
-        const hh = String(now.getHours()).padStart(2, '0');
-        const mm = String(now.getMinutes()).padStart(2, '0');
-        const ss = String(now.getSeconds()).padStart(2, '0');
-        return `${hh}:${mm}:${ss}`;
-    })();
-    const sessionLabel = args.sessionId ? ` sid=${args.sessionId}` : '';
-    const routeBase = args.routeName && args.routeName.trim() ? args.routeName.trim() : 'route';
-    const routeLabel = args.poolId && args.poolId.trim() ? `${routeBase}/${args.poolId.trim()}` : routeBase;
-    const providerLabel = args.providerKey && args.providerKey.trim() ? args.providerKey.trim() : 'unknown-provider';
-    const modelLabel = args.model && args.model.trim() ? `.${args.model.trim()}` : '';
-    const reasonLabel = args.reason && args.reason.trim() ? ` reason=${args.reason.trim()}` : '';
-    const prefixColor = '\x1b[38;5;208m';
-    const timeColor = '\x1b[90m';
-    const routeColor = resolveSessionLogColor(args.sessionId);
-    const white = '\x1b[97m';
-    const reset = '\x1b[0m';
-    const concurrencyLabel = `${white}[concurrency:${Math.max(0, Math.floor(args.activeInFlight))}/${Math.max(1, Math.floor(args.maxInFlight))}]${reset}`;
-    console.log(`${prefixColor}[virtual-router-hit]${reset} ${concurrencyLabel} ${timeColor}${timestamp}${reset}${sessionLabel} ${routeColor}${routeLabel} -> ${providerLabel}${modelLabel}${reasonLabel}${reset}`);
+    recordVirtualRouterHitRollup({
+        routeName: args.routeName,
+        poolId: args.poolId,
+        providerKey: args.providerKey,
+        model: args.model,
+        sessionId: args.sessionId,
+        projectPath: args.projectPath,
+        reason: args.reason,
+        stoplessMode: args.stoplessMode,
+        stoplessArmed: args.stoplessArmed,
+        activeInFlight: args.activeInFlight,
+        maxInFlight: args.maxInFlight
+    });
 }
 function hasNonEmptyToolCalls(value) {
     if (!Array.isArray(value) || value.length <= 0) {
@@ -378,11 +1981,280 @@ function containsToolRegistryMissingText(value) {
     }
     return false;
 }
-function detectRetryableEmptyAssistantResponse(body) {
-    if (!isRecord(body)) {
+function shouldBypassProviderResponseConversion(normalized) {
+    return typeof normalized.status === 'number' && normalized.status >= 400;
+}
+function resolveSessionStormBackoffScope(metadata) {
+    const sessionId = readString(metadata.sessionId);
+    if (sessionId) {
+        return `session:${sessionId}`;
+    }
+    const conversationId = readString(metadata.conversationId);
+    if (conversationId) {
+        return `conversation:${conversationId}`;
+    }
+    const workdir = readString(metadata.clientWorkdir)
+        ?? readString(metadata.client_workdir)
+        ?? readString(metadata.workdir)
+        ?? readString(metadata.cwd);
+    if (workdir) {
+        return `workdir:${workdir}`;
+    }
+    return undefined;
+}
+function isSessionStormBackoffCandidate(error) {
+    const codeSource = error && typeof error === 'object'
+        ? error.code
+        : undefined;
+    const code = normalizeCodeKey(codeSource);
+    if (code === 'PROVIDER_NOT_AVAILABLE' || code === 'ERR_NO_PROVIDER_TARGET') {
+        return true;
+    }
+    const status = extractStatusCodeFromError(error);
+    if (status === 429 || status === 502 || status === 503 || status === 504) {
+        return true;
+    }
+    if (isNetworkTransportLikeError(error)) {
+        return true;
+    }
+    const message = error instanceof Error
+        ? error.message
+        : error && typeof error === 'object' && typeof error.message === 'string'
+            ? String(error.message)
+            : String(error ?? '');
+    const normalized = message.trim().toLowerCase();
+    return (normalized.includes('fetch failed')
+        || normalized.includes('all providers unavailable')
+        || normalized.includes('no available providers after applying routing instructions')
+        || normalized.includes('connect timeout')
+        || normalized.includes('request timeout'));
+}
+function resolveSessionStormBackoffBaseMs() {
+    const raw = process.env.ROUTECODEX_SESSION_STORM_BACKOFF_BASE_MS
+        ?? process.env.RCC_SESSION_STORM_BACKOFF_BASE_MS
+        ?? '';
+    const parsed = Number.parseInt(String(raw).trim(), 10);
+    if (Number.isFinite(parsed) && parsed > 0) {
+        return parsed;
+    }
+    return process.env.NODE_ENV === 'test' ? 200 : 1_000;
+}
+function resolveSessionStormBackoffMaxMs() {
+    const raw = process.env.ROUTECODEX_SESSION_STORM_BACKOFF_MAX_MS
+        ?? process.env.RCC_SESSION_STORM_BACKOFF_MAX_MS
+        ?? '';
+    const parsed = Number.parseInt(String(raw).trim(), 10);
+    if (Number.isFinite(parsed) && parsed > 0) {
+        return parsed;
+    }
+    return process.env.NODE_ENV === 'test' ? 5_000 : 30_000;
+}
+function consumeSessionStormBackoffMs(key) {
+    const now = Date.now();
+    for (const [existingKey, state] of sessionStormBackoffState.entries()) {
+        if (now - state.updatedAtMs >= SESSION_STORM_BACKOFF_TTL_MS) {
+            sessionStormBackoffState.delete(existingKey);
+        }
+    }
+    const previous = sessionStormBackoffState.get(key);
+    const consecutive = previous && now - previous.updatedAtMs < SESSION_STORM_BACKOFF_TTL_MS
+        ? Math.min(previous.consecutive + 1, 16)
+        : 1;
+    const delayMs = Math.min(resolveSessionStormBackoffMaxMs(), resolveSessionStormBackoffBaseMs() * Math.pow(2, Math.max(0, consecutive - 1)));
+    sessionStormBackoffState.set(key, {
+        consecutive,
+        updatedAtMs: now,
+        nextAllowedAtMs: now + delayMs
+    });
+    return delayMs;
+}
+function peekSessionStormBackoffWaitMs(key) {
+    const state = sessionStormBackoffState.get(key);
+    if (!state) {
+        return 0;
+    }
+    const now = Date.now();
+    if (now - state.updatedAtMs >= SESSION_STORM_BACKOFF_TTL_MS) {
+        sessionStormBackoffState.delete(key);
+        return 0;
+    }
+    return Math.max(0, state.nextAllowedAtMs - now);
+}
+function clearSessionStormBackoff(key) {
+    if (!key) {
+        return;
+    }
+    sessionStormBackoffState.delete(key);
+}
+async function waitSessionStormBackoffWithGate(key, ms, signal) {
+    if (!(ms > 0)) {
+        return;
+    }
+    const normalizedKey = key.trim() || 'session:unknown';
+    const previous = sessionStormBackoffGateState.get(normalizedKey) ?? Promise.resolve();
+    let release = () => undefined;
+    const current = new Promise((resolve) => {
+        release = resolve;
+    });
+    sessionStormBackoffGateState.set(normalizedKey, current);
+    try {
+        await previous.catch((error) => {
+            logRequestExecutorNonBlockingError('waitSessionStormBackoffWithGate.previous', error, {
+                key: normalizedKey
+            });
+        });
+        await waitWithClientAbortSignal(ms, signal);
+    }
+    finally {
+        release();
+        if (sessionStormBackoffGateState.get(normalizedKey) === current) {
+            sessionStormBackoffGateState.delete(normalizedKey);
+        }
+    }
+}
+function detectRetryableEmptyAssistantResponse(body) {
+    if (!isRecord(body)) {
+        return null;
+    }
+    if (Object.prototype.hasOwnProperty.call(body, '__sse_responses')) {
+        return null;
+    }
+    const choices = Array.isArray(body.choices) ? body.choices : [];
+    if (choices.length > 0) {
+        const firstChoice = isRecord(choices[0]) ? choices[0] : undefined;
+        if (!firstChoice) {
+            return null;
+        }
+        const finishReason = readString(firstChoice.finish_reason)?.toLowerCase() ?? '';
+        const message = isRecord(firstChoice.message) ? firstChoice.message : undefined;
+        const hasToolCalls = hasNonEmptyToolCalls(message?.tool_calls);
+        const hasText = valueHasNonEmptyText(message?.content)
+            || valueHasNonEmptyText(message?.reasoning_content)
+            || valueHasNonEmptyText(message?.reasoning)
+            || valueHasNonEmptyText(firstChoice.content);
+        const combinedText = [
+            message?.content,
+            message?.reasoning_content,
+            message?.reasoning,
+            firstChoice.content
+        ]
+            .filter((item) => valueHasNonEmptyText(item))
+            .map((item) => String(item))
+            .join('\n');
+        if ((finishReason === 'stop' || finishReason === 'tool_calls' || !finishReason) && !hasToolCalls && !hasText) {
+            return {
+                reason: `finish_reason=${finishReason || 'unknown'} but assistant text/tool_calls are empty`,
+                marker: 'chat_empty_assistant'
+            };
+        }
+        if ((finishReason === 'stop' || finishReason === 'tool_calls' || !finishReason) && !hasToolCalls && containsToolRegistryMissingText(combinedText)) {
+            return {
+                reason: 'assistant emitted textual tool-not-found complaint without structured tool_calls',
+                marker: 'chat_textual_tool_registry_missing'
+            };
+        }
+    }
+    const status = readString(body.status)?.toLowerCase() ?? '';
+    if (status === 'completed' || status === 'stop') {
+        const requiredAction = isRecord(body.required_action) ? body.required_action : undefined;
+        const submitToolOutputs = requiredAction && isRecord(requiredAction.submit_tool_outputs)
+            ? requiredAction.submit_tool_outputs
+            : undefined;
+        const hasRequiredActionToolCalls = hasNonEmptyToolCalls(submitToolOutputs?.tool_calls);
+        const hasFunctionCalls = hasOutputFunctionCalls(body.output);
+        const hasText = valueHasNonEmptyText(body.output_text)
+            || valueHasNonEmptyText(body.output)
+            || valueHasNonEmptyText(body.reasoning);
+        if (!hasRequiredActionToolCalls && !hasFunctionCalls && !hasText) {
+            return {
+                reason: `responses status=${status} but output text/tool_calls are empty`,
+                marker: 'responses_empty_output'
+            };
+        }
+        if (!hasRequiredActionToolCalls &&
+            !hasFunctionCalls &&
+            containsToolRegistryMissingText(body.output_text)) {
+            return {
+                reason: 'responses completed with textual tool-not-found complaint but no function_call output',
+                marker: 'responses_textual_tool_registry_missing'
+            };
+        }
+    }
+    return null;
+}
+async function persistEmptyAssistantProviderSnapshots(args) {
+    const requestPayload = args.providerRequestPayload && typeof args.providerRequestPayload === 'object'
+        ? args.providerRequestPayload
+        : { payload: args.providerRequestPayload };
+    await writeProviderSnapshot({
+        phase: 'provider-request',
+        requestId: args.requestId,
+        clientRequestId: args.requestId,
+        entryEndpoint: args.entryEndpoint,
+        providerKey: args.providerKey,
+        providerId: args.providerId,
+        headers: args.providerRequestHeaders,
+        url: args.providerRequestUrl,
+        data: requestPayload,
+        forceLocalDiskWriteWhenDisabled: true
+    });
+    await writeProviderSnapshot({
+        phase: 'provider-response',
+        requestId: args.requestId,
+        clientRequestId: args.requestId,
+        entryEndpoint: args.entryEndpoint,
+        providerKey: args.providerKey,
+        providerId: args.providerId,
+        headers: args.normalizedResponse.headers && typeof args.normalizedResponse.headers === 'object'
+            ? args.normalizedResponse.headers
+            : undefined,
+        url: typeof args.normalizedResponse.url === 'string'
+            ? String(args.normalizedResponse.url)
+            : args.providerRequestUrl,
+        data: {
+            emptyAssistantSignal: args.emptyAssistantSignal,
+            normalizedResponse: {
+                status: args.normalizedResponse.status ?? null,
+                headers: args.normalizedResponse.headers ?? null,
+                body: args.normalizedResponse.body ?? null
+            },
+            convertedResponse: {
+                status: args.convertedResponse.status ?? null,
+                headers: args.convertedResponse.headers ?? null,
+                body: args.convertedResponse.body ?? null
+            }
+        },
+        forceLocalDiskWriteWhenDisabled: true
+    });
+}
+function bodyContainsReasoningStopFinalizedMarker(body) {
+    if (!body || typeof body !== 'object') {
+        return false;
+    }
+    try {
+        return JSON.stringify(body).includes(REASONING_STOP_FINALIZED_MARKER);
+    }
+    catch (error) {
+        logRequestExecutorNonBlockingError('bodyContainsReasoningStopFinalizedMarker.stringify', error);
+        return false;
+    }
+}
+function detectStoplessTerminationWithoutFinalization(body, stoplessMode) {
+    if ((stoplessMode !== 'on' && stoplessMode !== 'endless') || !isRecord(body)) {
         return null;
     }
     if (Object.prototype.hasOwnProperty.call(body, '__sse_responses')) {
+        const finishReason = readString(body[STREAM_LOG_FINISH_REASON_KEY])?.toLowerCase() ?? '';
+        const finalized = body[REASONING_STOP_FINALIZED_FLAG_KEY] === true;
+        if (!finalized && finishReason === 'stop') {
+            return {
+                reason: `stopless=${stoplessMode} but streamed wrapper completed with finish_reason=stop without reasoning.stop finalized marker`,
+                marker: 'stream_wrapper_stopless_missing_reasoning_stop_finalization'
+            };
+        }
+        return null;
+    }
+    if (bodyContainsReasoningStopFinalizedMarker(body)) {
         return null;
     }
     const choices = Array.isArray(body.choices) ? body.choices : [];
@@ -394,29 +2266,10 @@ function detectRetryableEmptyAssistantResponse(body) {
         const finishReason = readString(firstChoice.finish_reason)?.toLowerCase() ?? '';
         const message = isRecord(firstChoice.message) ? firstChoice.message : undefined;
         const hasToolCalls = hasNonEmptyToolCalls(message?.tool_calls);
-        const hasText = valueHasNonEmptyText(message?.content)
-            || valueHasNonEmptyText(message?.reasoning_content)
-            || valueHasNonEmptyText(message?.reasoning)
-            || valueHasNonEmptyText(firstChoice.content);
-        const combinedText = [
-            message?.content,
-            message?.reasoning_content,
-            message?.reasoning,
-            firstChoice.content
-        ]
-            .filter((item) => valueHasNonEmptyText(item))
-            .map((item) => String(item))
-            .join('\n');
-        if ((finishReason === 'stop' || finishReason === 'tool_calls' || !finishReason) && !hasToolCalls && !hasText) {
-            return {
-                reason: `finish_reason=${finishReason || 'unknown'} but assistant text/tool_calls are empty`,
-                marker: 'chat_empty_assistant'
-            };
-        }
-        if ((finishReason === 'stop' || finishReason === 'tool_calls' || !finishReason) && !hasToolCalls && containsToolRegistryMissingText(combinedText)) {
+        if (finishReason === 'stop' && !hasToolCalls) {
             return {
-                reason: 'assistant emitted textual tool-not-found complaint without structured tool_calls',
-                marker: 'chat_textual_tool_registry_missing'
+                reason: `stopless=${stoplessMode} but chat completion stopped without reasoning.stop finalized marker`,
+                marker: 'chat_stopless_missing_reasoning_stop_finalization'
             };
         }
     }
@@ -428,21 +2281,10 @@ function detectRetryableEmptyAssistantResponse(body) {
             : undefined;
         const hasRequiredActionToolCalls = hasNonEmptyToolCalls(submitToolOutputs?.tool_calls);
         const hasFunctionCalls = hasOutputFunctionCalls(body.output);
-        const hasText = valueHasNonEmptyText(body.output_text)
-            || valueHasNonEmptyText(body.output)
-            || valueHasNonEmptyText(body.reasoning);
-        if (!hasRequiredActionToolCalls && !hasFunctionCalls && !hasText) {
-            return {
-                reason: `responses status=${status} but output text/tool_calls are empty`,
-                marker: 'responses_empty_output'
-            };
-        }
-        if (!hasRequiredActionToolCalls &&
-            !hasFunctionCalls &&
-            containsToolRegistryMissingText(body.output_text)) {
+        if (!hasRequiredActionToolCalls && !hasFunctionCalls) {
             return {
-                reason: 'responses completed with textual tool-not-found complaint but no function_call output',
-                marker: 'responses_textual_tool_registry_missing'
+                reason: `stopless=${stoplessMode} but responses output completed without reasoning.stop finalized marker`,
+                marker: 'responses_stopless_missing_reasoning_stop_finalization'
             };
         }
     }
@@ -461,17 +2303,53 @@ export class HubRequestExecutor {
             this.trafficGovernor = createNoopProviderTrafficGovernor();
             return;
         }
+        const disableTrafficGovernor = process.env.ROUTECODEX_PROVIDER_TRAFFIC_NOOP === '1'
+            || process.env.RCC_PROVIDER_TRAFFIC_NOOP === '1';
+        if (disableTrafficGovernor) {
+            this.trafficGovernor = createNoopProviderTrafficGovernor();
+            return;
+        }
         this.trafficGovernor = getSharedProviderTrafficGovernor();
     }
     logProviderRetrySwitch(args) {
+        const now = Date.now();
         const providerLabel = args.providerKey || 'unknown-provider';
-        const retryTag = `[provider-switch] req=${args.requestId} attempt=${args.attempt}/${args.maxAttempts} -> ${args.nextAttempt}/${args.maxAttempts}`;
+        const dedupeKey = [
+            providerLabel,
+            args.switchAction,
+            typeof args.statusCode === 'number' ? String(args.statusCode) : 'none',
+            args.errorCode || 'none',
+            args.upstreamCode || 'none',
+            truncateReason(args.reason, 96)
+        ].join('|');
+        const prior = providerSwitchLogState.get(dedupeKey);
+        if (prior && now - prior.lastAtMs < PROVIDER_SWITCH_LOG_THROTTLE_MS) {
+            prior.suppressed += 1;
+            prior.lastAtMs = now;
+            providerSwitchLogState.set(dedupeKey, prior);
+            return;
+        }
+        if (prior?.suppressed && prior.suppressed > 0) {
+            console.warn(`[provider-switch] aggregated key=${JSON.stringify(dedupeKey)} suppressed=${prior.suppressed} ` +
+                `windowMs=${PROVIDER_SWITCH_LOG_THROTTLE_MS}`);
+        }
+        providerSwitchLogState.set(dedupeKey, { lastAtMs: now, suppressed: 0 });
+        const boundedNextAttempt = Math.max(args.attempt, Math.min(args.maxAttempts, args.nextAttempt));
+        const retryTag = `[provider-switch] req=${args.requestId} attempt=${args.attempt}/${args.maxAttempts} -> ` +
+            `${boundedNextAttempt}/${args.maxAttempts}`;
         const details = [
             `provider=${providerLabel}`,
             `switch=${args.switchAction}`,
+            ...(args.decisionLabel ? [`decision=${args.decisionLabel}`] : []),
+            ...(args.backoffScope ? [`backoffScope=${args.backoffScope}`] : []),
+            ...(args.stage ? [`stage=${args.stage}`] : []),
             ...(typeof args.statusCode === 'number' ? [`status=${args.statusCode}`] : []),
             ...(args.errorCode ? [`code=${args.errorCode}`] : []),
             ...(args.upstreamCode ? [`upstreamCode=${args.upstreamCode}`] : []),
+            ...(typeof args.backoffMs === 'number' ? [`backoff=${Math.max(0, Math.round(args.backoffMs))}ms`] : []),
+            ...(typeof args.runtimeScopeExcludedCount === 'number' && args.runtimeScopeExcludedCount > 0
+                ? [`runtimeScopeExcluded=${args.runtimeScopeExcludedCount}`]
+                : []),
             `reason=${JSON.stringify(truncateReason(args.reason))}`
         ];
         console.warn(`${retryTag} ${details.join(' ')}`);
@@ -480,6 +2358,15 @@ export class HubRequestExecutor {
         // Stats must remain stable across provider retries and requestId enhancements.
         const statsRequestId = input.requestId;
         const executorRequestId = input.requestId;
+        const logicalRequestChainKey = retainLogicalRequestChain(deriveLogicalRequestChainKey(executorRequestId));
+        let logicalRequestChainReleased = false;
+        const releaseLogicalRequestChainIfNeeded = () => {
+            if (logicalRequestChainReleased) {
+                return;
+            }
+            logicalRequestChainReleased = true;
+            releaseLogicalRequestChain(logicalRequestChainKey);
+        };
         this.deps.stats.recordRequestStart(statsRequestId);
         const requestStartedAt = Date.now();
         let recordedAnyAttempt = false;
@@ -500,6 +2387,21 @@ export class HubRequestExecutor {
                 const inboundClientHeaders = cloneClientHeaders(initialMetadata?.clientHeaders);
                 const providerRequestId = input.requestId;
                 const clientRequestId = resolveClientRequestId(initialMetadata, providerRequestId);
+                const sessionStormBackoffScope = resolveSessionStormBackoffScope(initialMetadata);
+                if (sessionStormBackoffScope) {
+                    const pendingSessionStormWaitMs = peekSessionStormBackoffWaitMs(sessionStormBackoffScope);
+                    if (pendingSessionStormWaitMs > 0) {
+                        this.logStage('request.session_storm_backoff_wait', providerRequestId, {
+                            scope: sessionStormBackoffScope,
+                            waitMs: pendingSessionStormWaitMs
+                        });
+                        await waitSessionStormBackoffWithGate(sessionStormBackoffScope, pendingSessionStormWaitMs, getClientConnectionAbortSignal(initialMetadata));
+                        this.logStage('request.session_storm_backoff_wait.completed', providerRequestId, {
+                            scope: sessionStormBackoffScope,
+                            waitMs: pendingSessionStormWaitMs
+                        });
+                    }
+                }
                 this.logStage('request.received', providerRequestId, {
                     endpoint: input.entryEndpoint,
                     stream: initialMetadata.stream === true
@@ -515,7 +2417,7 @@ export class HubRequestExecutor {
                 let aggregatedUsage;
                 const excludedProviderKeys = new Set();
                 let maxAttempts = resolveMaxProviderAttempts();
-                const originalRequestSnapshot = cloneRequestPayload(input.body);
+                const retryPayloadSeed = prepareRequestPayloadRetrySeed(input.body);
                 let attempt = 0;
                 let lastError;
                 let initialRoutePool = null;
@@ -523,18 +2425,23 @@ export class HubRequestExecutor {
                 let poolCooldownWaitBudgetMs = 60 * 1000;
                 let forcedRouteHint;
                 let contextOverflowRetries = 0;
-                const MAX_CONTEXT_OVERFLOW_RETRIES = 3;
+                let cumulativeExternalLatencyMs = 0;
+                let cumulativeTrafficWaitMs = 0;
+                let cumulativeClientInjectWaitMs = 0;
                 while (attempt < maxAttempts) {
                     attempt += 1;
                     // Ensure each attempt starts from the base requestId so pipeline snapshots
                     // don't inherit a provider-specific id from a previous attempt.
                     input.requestId = providerRequestId;
-                    if (originalRequestSnapshot && typeof originalRequestSnapshot === 'object') {
-                        const cloned = cloneRequestPayload(originalRequestSnapshot) ??
-                            { ...originalRequestSnapshot };
-                        input.body = cloned;
+                    if (attempt > 1 && retryPayloadSeed.mode !== 'none') {
+                        const cloned = restoreRequestPayloadFromRetrySeed(retryPayloadSeed);
+                        if (cloned && typeof cloned === 'object') {
+                            input.body = cloned;
+                        }
                     }
                     const metadataForAttempt = decorateMetadataForAttempt(initialMetadata, attempt, excludedProviderKeys);
+                    const clientAbortSignal = getClientConnectionAbortSignal(metadataForAttempt);
+                    throwIfClientAbortSignalAborted(clientAbortSignal);
                     if (forcedRouteHint) {
                         metadataForAttempt.routeHint = forcedRouteHint;
                     }
@@ -595,7 +2502,7 @@ export class HubRequestExecutor {
                                     reason: 'provider_pool_cooling_down'
                                 });
                                 poolCooldownWaitBudgetMs -= cooldownWaitMs;
-                                await new Promise((resolve) => setTimeout(resolve, cooldownWaitMs));
+                                await waitWithClientAbortSignal(cooldownWaitMs, clientAbortSignal);
                                 attempt = Math.max(0, attempt - 1);
                                 continue;
                             }
@@ -607,6 +2514,7 @@ export class HubRequestExecutor {
                     }
                     const pipelineMetadata = pipelineResult.metadata ?? {};
                     const mergedMetadata = mergeMetadataPreservingDefined(metadataForAttempt, pipelineMetadata);
+                    throwIfClientAbortSignalAborted(clientAbortSignal);
                     registerRequestLogContext(input.requestId, {
                         sessionId: mergedMetadata.sessionId,
                         conversationId: mergedMetadata.conversationId
@@ -636,6 +2544,36 @@ export class HubRequestExecutor {
                             requestId: input.requestId
                         });
                     }
+                    if (excludedProviderKeys.has(target.providerKey)) {
+                        const reselectedExcludedPlan = resolveExcludedProviderReselectionPlan({
+                            providerKey: target.providerKey,
+                            routePool: routePoolForAttempt,
+                            excludedProviderKeys,
+                            lastError
+                        });
+                        this.logStage('provider.retry.excluded_target_reselected', providerRequestId, {
+                            providerKey: target.providerKey,
+                            excluded: Array.from(excludedProviderKeys),
+                            attempt,
+                            hasAlternativeCandidate: reselectedExcludedPlan.hasAlternativeCandidate
+                        });
+                        if (!reselectedExcludedPlan.keepExcludedForNextAttempt) {
+                            excludedProviderKeys.delete(target.providerKey);
+                        }
+                        else {
+                            if (reselectedExcludedPlan.hasAlternativeCandidate) {
+                                continue;
+                            }
+                            if (lastError) {
+                                throw lastError;
+                            }
+                            throw Object.assign(new Error(`Virtual router reselected excluded provider ${target.providerKey}`), {
+                                code: 'ERR_EXCLUDED_PROVIDER_RESELECTED',
+                                requestId: input.requestId,
+                                providerKey: target.providerKey
+                            });
+                        }
+                    }
                     // Ensure response-side conversion always uses the route-selected target metadata.
                     // ServerTool followups may carry stale metadata from the previous hop; response compat
                     // must follow the current target/provider, not the inherited request profile.
@@ -646,7 +2584,7 @@ export class HubRequestExecutor {
                     else if (Object.prototype.hasOwnProperty.call(mergedMetadata, 'compatibilityProfile')) {
                         delete mergedMetadata.compatibilityProfile;
                     }
-                    let runtimeKey;
+                    let runtimeKey = typeof target.runtimeKey === 'string' ? target.runtimeKey : '';
                     let handle;
                     let providerContext;
                     try {
@@ -670,7 +2608,6 @@ export class HubRequestExecutor {
                         runtimeKey = resolved.runtimeKey;
                         handle = resolved.handle;
                         this.logStage('provider.runtime_resolve.completed', providerRequestId, {
-                            providerKey: target.providerKey,
                             runtimeKey,
                             providerType: handle.providerType,
                             providerFamily: handle.providerFamily,
@@ -705,49 +2642,66 @@ export class HubRequestExecutor {
                             ...(retryError.upstreamCode ? { upstreamCode: retryError.upstreamCode } : {}),
                             attempt
                         });
-                        lastError = error;
-                        const shouldRetry = attempt < maxAttempts && shouldRetryProviderError(error);
-                        if (!shouldRetry) {
-                            recordAttempt({ error: true });
-                            throw error;
-                        }
-                        recordAttempt({ error: true });
-                        const retryBackoffMs = await waitBeforeRetry(error, { attempt });
-                        const singleProviderPool = Boolean(initialRoutePool && initialRoutePool.length === 1 && initialRoutePool[0] === target.providerKey);
-                        if (!singleProviderPool && target.providerKey) {
-                            excludedProviderKeys.add(target.providerKey);
-                        }
-                        const switchAction = singleProviderPool ? 'retry_same_provider' : 'exclude_and_reroute';
-                        this.logProviderRetrySwitch({
+                        const providerFailurePlan = await resolveRequestExecutorProviderFailurePlan({
+                            error,
+                            retryError,
                             requestId: providerRequestId,
-                            attempt,
-                            maxAttempts,
-                            providerKey: target.providerKey,
-                            nextAttempt: attempt + 1,
-                            reason: retryError.reason,
-                            statusCode: retryError.statusCode,
-                            errorCode: retryError.errorCode,
-                            upstreamCode: retryError.upstreamCode,
-                            switchAction
-                        });
-                        this.logStage('provider.retry', input.requestId, {
                             providerKey: target.providerKey,
+                            providerType: typeof target.providerType === 'string'
+                                ? String(target.providerType)
+                                : undefined,
+                            providerProtocol: target.outboundProfile,
+                            routeName: pipelineResult.routingDecision?.routeName,
+                            runtimeKey,
+                            target: target,
+                            dependencies: this.deps.getModuleDependencies(),
                             attempt,
-                            nextAttempt: attempt + 1,
-                            excluded: Array.from(excludedProviderKeys),
-                            reason: retryError.reason,
+                            maxAttempts,
+                            stage: 'provider.runtime_resolve',
+                            logicalRequestChainKey,
+                            logicalChainRetryLimitStageRequestId: providerRequestId,
+                            excludedProviderKeys,
+                            recordAttempt,
+                            logStage: (stage, requestId, details) => this.logStage(stage, requestId, details),
                             routeHint: forcedRouteHint,
-                            switchAction,
-                            ...(typeof retryError.statusCode === 'number' ? { statusCode: retryError.statusCode } : {}),
-                            ...(retryError.errorCode ? { errorCode: retryError.errorCode } : {}),
-                            ...(retryError.upstreamCode ? { upstreamCode: retryError.upstreamCode } : {}),
-                            retryBackoffMs
+                            forceExcludeCurrentProviderOnRetry: true,
+                            abortSignal: clientAbortSignal
+                        });
+                        lastError = error;
+                        const retryExecutionPlan = providerFailurePlan.retryExecutionPlan;
+                        if (!retryExecutionPlan.shouldRetry || !retryExecutionPlan.retrySwitchPlan || !retryExecutionPlan.backoffScope) {
+                            throw error;
+                        }
+                        if (!providerFailurePlan.retryTelemetryPlan) {
+                            throw error;
+                        }
+                        emitRequestExecutorProviderRetryTelemetry({
+                            requestId: input.requestId,
+                            retryTelemetryPlan: providerFailurePlan.retryTelemetryPlan,
+                            logStage: (stage, requestId, details) => this.logStage(stage, requestId, details),
+                            logProviderRetrySwitch: (switchArgs) => this.logProviderRetrySwitch(switchArgs)
                         });
                         continue;
                     }
                     const previousRequestId = input.requestId;
                     if (providerContext.requestId !== input.requestId) {
                         input.requestId = providerContext.requestId;
+                        try {
+                            await rebindResponsesConversationRequestId(previousRequestId, input.requestId);
+                        }
+                        catch (error) {
+                            logRequestExecutorNonBlockingError('responsesConversation.rebindRequestId', error, {
+                                previousRequestId,
+                                requestId: input.requestId,
+                                providerKey: target.providerKey,
+                                runtimeKey
+                            });
+                            logRequestExecutorDegraded('responsesConversation.rebindRequestId', input.requestId, {
+                                previousRequestId,
+                                providerKey: target.providerKey,
+                                runtimeKey
+                            });
+                        }
                     }
                     this.logStage('provider.context_resolve.completed', input.requestId, {
                         providerKey: target.providerKey,
@@ -782,6 +2736,7 @@ export class HubRequestExecutor {
                         providerLabel,
                         attempt
                     });
+                    throwIfClientAbortSignalAborted(clientAbortSignal);
                     this.logStage('provider.metadata_attach.start', input.requestId, {
                         providerKey: target.providerKey,
                         runtimeKey,
@@ -799,60 +2754,111 @@ export class HubRequestExecutor {
                         runtimeKey,
                         target,
                         metadata: mergedMetadata,
-                        compatibilityProfile: target.compatibilityProfile
+                        compatibilityProfile: target.compatibilityProfile,
+                        abortSignal: getClientConnectionAbortSignal(mergedMetadata)
                     });
                     this.logStage('provider.metadata_attach.completed', input.requestId, {
                         providerKey: target.providerKey,
                         runtimeKey,
                         attempt
                     });
+                    const providerTransportBackoffKey = buildProviderTransportBackoffKey({
+                        providerKey: target.providerKey,
+                        runtimeKey
+                    });
                     let trafficPermit = null;
+                    let trafficPolicyMaxInFlight = 0;
+                    let trafficActiveInFlightAtAcquire = 0;
                     let providerSendStartedAtMs = 0;
+                    let providerSendElapsedMs = 0;
+                    const stoplessLogState = resolveStoplessLogState(mergedMetadata);
+                    const providerRequestedStream = typeof providerPayload?.stream === 'boolean'
+                        ? Boolean(providerPayload.stream)
+                        : undefined;
+                    const bypassTrafficGovernor = isServerToolFollowupRequest(metadataForAttempt);
                     try {
-                        this.logStage('provider.traffic.acquire.start', input.requestId, {
-                            providerKey: target.providerKey,
-                            runtimeKey,
-                            attempt
-                        });
-                        const trafficAcquired = await this.trafficGovernor.acquire({
-                            runtimeKey,
-                            providerKey: target.providerKey,
-                            requestId: input.requestId,
-                            runtime: resolveTrafficRuntimeProfile(runtimeKey, handle, target.providerKey),
-                            // If current route pool has alternatives, do not stall too long on quota/RPM gating.
-                            // Switch provider after 10s wait so weighted pools can continue serving.
-                            softWaitTimeoutMs: routePoolForAttempt.length > 1 ? 10_000 : undefined
-                        });
-                        trafficPermit = trafficAcquired.permit;
-                        if (trafficAcquired.waitedMs > 0) {
-                            this.logStage('provider.traffic.acquire.wait', input.requestId, {
+                        throwIfClientAbortSignalAborted(clientAbortSignal);
+                        if (providerTransportBackoffKey) {
+                            const pendingProviderTransportWaitMs = peekProviderTransportBackoffWaitMs(providerTransportBackoffKey);
+                            if (pendingProviderTransportWaitMs > 0) {
+                                this.logStage('provider.transport_backoff_wait', input.requestId, {
+                                    providerKey: target.providerKey,
+                                    runtimeKey,
+                                    waitMs: pendingProviderTransportWaitMs,
+                                    attempt
+                                });
+                                await waitProviderTransportBackoffWithGate(providerTransportBackoffKey, pendingProviderTransportWaitMs, clientAbortSignal);
+                                this.logStage('provider.transport_backoff_wait.completed', input.requestId, {
+                                    providerKey: target.providerKey,
+                                    runtimeKey,
+                                    waitMs: pendingProviderTransportWaitMs,
+                                    attempt
+                                });
+                            }
+                        }
+                        if (bypassTrafficGovernor) {
+                            this.logStage('provider.traffic.acquire.bypassed', input.requestId, {
                                 providerKey: target.providerKey,
                                 runtimeKey,
-                                waitedMs: trafficAcquired.waitedMs,
+                                reason: 'servertool_followup',
+                                attempt
+                            });
+                        }
+                        else {
+                            this.logStage('provider.traffic.acquire.start', input.requestId, {
+                                providerKey: target.providerKey,
+                                runtimeKey,
+                                attempt
+                            });
+                            const trafficAcquired = await this.trafficGovernor.acquire({
+                                runtimeKey,
+                                providerKey: target.providerKey,
+                                requestId: input.requestId,
+                                runtime: resolveTrafficRuntimeProfile(runtimeKey, handle, target.providerKey),
+                                // Hard rule (2026-04): local traffic saturation must block-wait/backoff instead of
+                                // switch storm. Do not use soft timeout here.
+                                softWaitTimeoutMs: undefined
+                            });
+                            trafficPermit = trafficAcquired.permit;
+                            trafficPolicyMaxInFlight = trafficAcquired.policy.concurrency.maxInFlight;
+                            trafficActiveInFlightAtAcquire = trafficAcquired.activeInFlight;
+                            if (trafficAcquired.waitedMs > 0) {
+                                cumulativeTrafficWaitMs += trafficAcquired.waitedMs;
+                                this.logStage('provider.traffic.acquire.wait', input.requestId, {
+                                    providerKey: target.providerKey,
+                                    runtimeKey,
+                                    waitedMs: trafficAcquired.waitedMs,
+                                    attempt
+                                });
+                            }
+                            this.logStage('provider.traffic.acquire.completed', input.requestId, {
+                                providerKey: target.providerKey,
+                                runtimeKey,
+                                maxInFlight: trafficAcquired.policy.concurrency.maxInFlight,
+                                requestsPerMinute: trafficAcquired.policy.rpm.requestsPerMinute,
+                                activeInFlight: trafficAcquired.activeInFlight,
+                                rpmInWindow: trafficAcquired.rpmInWindow,
                                 attempt
                             });
                         }
-                        this.logStage('provider.traffic.acquire.completed', input.requestId, {
-                            providerKey: target.providerKey,
-                            runtimeKey,
-                            maxInFlight: trafficAcquired.policy.concurrency.maxInFlight,
-                            requestsPerMinute: trafficAcquired.policy.rpm.requestsPerMinute,
-                            activeInFlight: trafficAcquired.activeInFlight,
-                            rpmInWindow: trafficAcquired.rpmInWindow,
-                            attempt
-                        });
                         const routingDecisionRecord = pipelineResult.routingDecision && typeof pipelineResult.routingDecision === 'object'
                             ? pipelineResult.routingDecision
                             : undefined;
                         emitVirtualRouterConcurrencyLog({
                             sessionId: readString(mergedMetadata.sessionId) ?? readString(mergedMetadata.conversationId),
+                            projectPath: readString(mergedMetadata.clientWorkdir)
+                                ?? readString(mergedMetadata.client_workdir)
+                                ?? readString(mergedMetadata.workdir)
+                                ?? readString(mergedMetadata.cwd),
                             routeName: pipelineResult.routingDecision?.routeName,
                             poolId: readString(routingDecisionRecord?.poolId),
                             providerKey: target.providerKey,
                             model: providerModel,
                             reason: readString(routingDecisionRecord?.reasoning),
-                            activeInFlight: trafficAcquired.activeInFlight,
-                            maxInFlight: trafficAcquired.policy.concurrency.maxInFlight
+                            stoplessMode: stoplessLogState.mode,
+                            stoplessArmed: stoplessLogState.armed,
+                            activeInFlight: trafficActiveInFlightAtAcquire,
+                            maxInFlight: trafficPolicyMaxInFlight
                         });
                         providerSendStartedAtMs = Date.now();
                         this.logStage('provider.send.start', input.requestId, {
@@ -863,14 +2869,19 @@ export class HubRequestExecutor {
                             providerFamily: handle.providerFamily,
                             model: providerModel,
                             providerLabel,
+                            providerRequestedStream,
                             attempt
                         });
+                        throwIfClientAbortSignalAborted(clientAbortSignal);
+                        allowSnapshotLocalDiskWrite(executorRequestId, providerRequestId, input.requestId, clientRequestId);
                         const providerResponse = await handle.instance.processIncoming(providerPayload);
                         const responseStatus = extractResponseStatus(providerResponse);
+                        providerSendElapsedMs = Date.now() - providerSendStartedAtMs;
+                        cumulativeExternalLatencyMs += providerSendElapsedMs;
                         this.logStage('provider.send.completed', input.requestId, {
                             providerKey: target.providerKey,
                             status: responseStatus,
-                            elapsedMs: Date.now() - providerSendStartedAtMs,
+                            elapsedMs: providerSendElapsedMs,
                             providerType: handle.providerType,
                             providerFamily: handle.providerFamily,
                             model: providerModel,
@@ -926,34 +2937,58 @@ export class HubRequestExecutor {
                             processMode: pipelineResult.processMode,
                             attempt
                         });
-                        const converted = await this.convertProviderResponseIfNeeded({
-                            entryEndpoint: input.entryEndpoint,
-                            providerProtocol,
-                            providerType: handle.providerType,
-                            requestId: input.requestId,
-                            serverToolsEnabled,
-                            wantsStream: wantsStreamBase,
-                            originalRequest: originalRequestSnapshot,
-                            requestSemantics,
-                            processMode: pipelineResult.processMode,
-                            response: normalized,
-                            pipelineMetadata: mergedMetadata
-                        });
+                        const converted = shouldBypassProviderResponseConversion(normalized)
+                            ? (() => {
+                                this.logStage('provider.response_convert.skipped', input.requestId, {
+                                    providerKey: target.providerKey,
+                                    status: normalized.status,
+                                    reason: 'non_success_status_bypass',
+                                    attempt
+                                });
+                                return normalized;
+                            })()
+                            : await this.convertProviderResponseIfNeeded({
+                                entryEndpoint: input.entryEndpoint,
+                                providerProtocol,
+                                providerType: handle.providerType,
+                                requestId: input.requestId,
+                                serverToolsEnabled,
+                                wantsStream: wantsStreamBase,
+                                originalRequest: resolveOriginalRequestForResponseConversion(retryPayloadSeed),
+                                requestSemantics,
+                                processMode: pipelineResult.processMode,
+                                response: normalized,
+                                pipelineMetadata: mergedMetadata
+                            });
                         const clientInjectWaitMsRaw = converted.timingBreakdown?.hubResponseExcludedMs;
                         const clientInjectWaitMs = typeof clientInjectWaitMsRaw === 'number' && Number.isFinite(clientInjectWaitMsRaw)
                             ? Math.max(0, Math.floor(clientInjectWaitMsRaw))
                             : 0;
+                        if (clientInjectWaitMs > 0) {
+                            cumulativeClientInjectWaitMs += clientInjectWaitMs;
+                        }
                         const hubResponseElapsedMsRaw = Date.now() - hubResponseStartedAtMs;
                         const hubResponseElapsedMs = Math.max(0, hubResponseElapsedMsRaw - clientInjectWaitMs);
                         const convertedBodyRecord = converted.body && typeof converted.body === 'object'
                             ? converted.body
                             : undefined;
+                        const normalizedBodyRecord = normalized.body && typeof normalized.body === 'object'
+                            ? normalized.body
+                            : undefined;
                         if (convertedBodyRecord) {
                             backfillResponsesOutputTextIfMissing(convertedBodyRecord);
                         }
-                        const finishReason = convertedBodyRecord && typeof convertedBodyRecord[STREAM_LOG_FINISH_REASON_KEY] === 'string'
-                            ? String(convertedBodyRecord[STREAM_LOG_FINISH_REASON_KEY])
-                            : undefined;
+                        const finishReason = (() => {
+                            if (convertedBodyRecord
+                                && typeof convertedBodyRecord[STREAM_LOG_FINISH_REASON_KEY] === 'string') {
+                                return String(convertedBodyRecord[STREAM_LOG_FINISH_REASON_KEY]);
+                            }
+                            const fromConverted = deriveFinishReason(convertedBodyRecord);
+                            if (fromConverted) {
+                                return fromConverted;
+                            }
+                            return deriveFinishReason(normalizedBodyRecord);
+                        })();
                         this.logStage('provider.response_convert.completed', input.requestId, {
                             providerKey: target.providerKey,
                             status: converted.status,
@@ -1010,41 +3045,7 @@ export class HubRequestExecutor {
                             errorToThrow.statusCode = statusCode;
                             errorToThrow.status = statusCode;
                             errorToThrow.response = { data: bodyForError };
-                            try {
-                                const { emitProviderError } = await import('../../../providers/core/utils/provider-error-reporter.js');
-                                emitProviderError({
-                                    error: errorToThrow,
-                                    stage: 'provider.http',
-                                    runtime: {
-                                        requestId: input.requestId,
-                                        providerKey: target.providerKey,
-                                        providerId: handle.providerId,
-                                        providerType: handle.providerType,
-                                        providerFamily: handle.providerFamily,
-                                        providerProtocol,
-                                        routeName: pipelineResult.routingDecision?.routeName,
-                                        pipelineId: target.providerKey,
-                                        target,
-                                        runtimeKey
-                                    },
-                                    dependencies: this.deps.getModuleDependencies(),
-                                    statusCode,
-                                    recoverable: statusCode === 401 ||
-                                        statusCode === 429 ||
-                                        statusCode === 408 ||
-                                        statusCode === 425 ||
-                                        statusCode >= 500,
-                                    affectsHealth: true,
-                                    details: {
-                                        source: 'converted_response_status',
-                                        convertedStatus: statusCode,
-                                        wrappedErrorResponse: true
-                                    }
-                                });
-                            }
-                            catch {
-                                // best-effort; never block retry/failover path
-                            }
+                            errorToThrow.requestExecutorProviderErrorStage = 'provider.http';
                             throw errorToThrow;
                         }
                         this.logStage('provider.response_status_check.completed', input.requestId, {
@@ -1052,15 +3053,66 @@ export class HubRequestExecutor {
                             convertedStatus,
                             attempt
                         });
+                        clearProviderTransportBackoff(providerTransportBackoffKey);
+                        if (!bypassTrafficGovernor) {
+                            try {
+                                await this.trafficGovernor.observeOutcome?.({
+                                    runtimeKey,
+                                    providerKey: target.providerKey,
+                                    requestId: input.requestId,
+                                    success: true,
+                                    statusCode: convertedStatus,
+                                    activeInFlight: trafficActiveInFlightAtAcquire,
+                                    configuredMaxInFlight: trafficPolicyMaxInFlight || undefined
+                                });
+                            }
+                            catch (observeError) {
+                                this.logStage('provider.traffic.observe_outcome.error', input.requestId, {
+                                    providerKey: target.providerKey,
+                                    runtimeKey,
+                                    message: observeError instanceof Error
+                                        ? observeError.message
+                                        : String(observeError ?? 'Unknown observe outcome error'),
+                                    attempt
+                                });
+                            }
+                        }
                         const emptyAssistantSignal = detectRetryableEmptyAssistantResponse(converted.body);
                         if (emptyAssistantSignal) {
                             const bodyForError = converted.body;
+                            try {
+                                await persistEmptyAssistantProviderSnapshots({
+                                    requestId: input.requestId,
+                                    entryEndpoint: input.entryEndpoint,
+                                    providerKey: target.providerKey,
+                                    providerId: handle.providerId,
+                                    providerRequestPayload: providerPayload,
+                                    providerRequestHeaders: providerPayload && typeof providerPayload === 'object'
+                                        ? providerPayload.headers
+                                        : undefined,
+                                    providerRequestUrl: providerPayload && typeof providerPayload === 'object' && typeof providerPayload.url === 'string'
+                                        ? String(providerPayload.url)
+                                        : undefined,
+                                    normalizedResponse: normalized,
+                                    convertedResponse: converted,
+                                    emptyAssistantSignal
+                                });
+                            }
+                            catch (snapshotError) {
+                                logRequestExecutorNonBlockingError('host.response_contract.empty_assistant.snapshot', snapshotError, {
+                                    requestId: input.requestId,
+                                    providerKey: target.providerKey,
+                                    marker: emptyAssistantSignal.marker
+                                });
+                            }
                             const errorToThrow = new Error(`Upstream returned empty assistant payload: ${emptyAssistantSignal.reason}`);
                             errorToThrow.statusCode = 502;
                             errorToThrow.status = 502;
                             errorToThrow.code = 'EMPTY_ASSISTANT_RESPONSE';
+                            errorToThrow.retryable = true;
+                            errorToThrow.requestExecutorProviderErrorStage = 'host.response_contract';
                             errorToThrow.response = { data: bodyForError };
-                            this.logStage('provider.empty_assistant_retry', input.requestId, {
+                            this.logStage('host.response_contract.empty_assistant', input.requestId, {
                                 providerKey: target.providerKey,
                                 marker: emptyAssistantSignal.marker,
                                 reason: emptyAssistantSignal.reason,
@@ -1068,6 +3120,29 @@ export class HubRequestExecutor {
                             });
                             throw errorToThrow;
                         }
+                        const stoplessTerminationSignal = detectStoplessTerminationWithoutFinalization(converted.body, stoplessLogState.mode);
+                        if (stoplessTerminationSignal) {
+                            const bodyForError = converted.body && typeof converted.body === 'object'
+                                ? converted.body
+                                : undefined;
+                            const errorToThrow = new Error(`Stopless contract violated: ${stoplessTerminationSignal.reason}`);
+                            errorToThrow.statusCode = 502;
+                            errorToThrow.status = 502;
+                            errorToThrow.code = 'STOPLESS_FINALIZATION_MISSING';
+                            errorToThrow.retryable = true;
+                            errorToThrow.requestExecutorProviderErrorStage = 'host.stopless_contract';
+                            if (bodyForError) {
+                                errorToThrow.response = { data: bodyForError };
+                            }
+                            this.logStage('host.stopless_finalization_missing', input.requestId, {
+                                providerKey: target.providerKey,
+                                marker: stoplessTerminationSignal.marker,
+                                reason: stoplessTerminationSignal.reason,
+                                stoplessMode: stoplessLogState.mode,
+                                attempt
+                            });
+                            throw errorToThrow;
+                        }
                         this.logStage('provider.usage_extract.start', input.requestId, {
                             providerKey: target.providerKey,
                             source: 'converted_response',
@@ -1096,24 +3171,92 @@ export class HubRequestExecutor {
                             attempt
                         });
                         recordAttempt({ usage: aggregatedUsage, error: false });
+                        if (sessionStormBackoffScope) {
+                            clearSessionStormBackoff(sessionStormBackoffScope);
+                        }
                         const metadataHubStageTop = readHubStageTop(mergedMetadata);
+                        const hubDecodeBreakdown = readHubDecodeBreakdown(metadataHubStageTop);
                         return {
                             ...converted,
                             usageLogInfo: {
                                 providerKey: target.providerKey,
                                 model: providerModel,
+                                routeName: pipelineResult.routingDecision?.routeName,
+                                poolId: readString(routingDecisionRecord?.poolId),
+                                finishReason,
                                 usage: aggregatedUsage,
+                                externalLatencyMs: cumulativeExternalLatencyMs > 0 ? cumulativeExternalLatencyMs : undefined,
+                                trafficWaitMs: cumulativeTrafficWaitMs > 0 ? cumulativeTrafficWaitMs : undefined,
+                                clientInjectWaitMs: cumulativeClientInjectWaitMs > 0 ? cumulativeClientInjectWaitMs : undefined,
+                                sseDecodeMs: hubDecodeBreakdown.sseDecodeMs > 0 ? hubDecodeBreakdown.sseDecodeMs : undefined,
+                                codecDecodeMs: hubDecodeBreakdown.codecDecodeMs > 0 ? hubDecodeBreakdown.codecDecodeMs : undefined,
+                                providerAttemptCount: attempt,
+                                retryCount: Math.max(0, attempt - 1),
                                 hubStageTop: metadataHubStageTop,
                                 requestStartedAtMs: requestStartedAt,
                                 timingRequestIds: Array.from(new Set([providerRequestId, input.requestId].filter((value) => Boolean(value)))),
                                 sessionId: mergedMetadata.sessionId,
-                                conversationId: mergedMetadata.conversationId
+                                conversationId: mergedMetadata.conversationId,
+                                projectPath: readString(mergedMetadata.clientWorkdir)
+                                    ?? readString(mergedMetadata.client_workdir)
+                                    ?? readString(mergedMetadata.workdir)
+                                    ?? readString(mergedMetadata.cwd)
                             }
                         };
                     }
                     catch (error) {
+                        if (providerSendStartedAtMs > 0 && providerSendElapsedMs <= 0) {
+                            const failedSendElapsedMs = Math.max(0, Date.now() - providerSendStartedAtMs);
+                            if (failedSendElapsedMs > 0) {
+                                providerSendElapsedMs = failedSendElapsedMs;
+                                cumulativeExternalLatencyMs += failedSendElapsedMs;
+                                this.logStage('provider.send.failed_elapsed', input.requestId, {
+                                    providerKey: target.providerKey,
+                                    elapsedMs: failedSendElapsedMs,
+                                    attempt
+                                });
+                            }
+                        }
                         const errorMessage = error instanceof Error ? error.message : String(error ?? 'Unknown error');
                         const retryError = extractRetryErrorSnapshot(error);
+                        if (sessionStormBackoffScope && isSessionStormBackoffCandidate(error)) {
+                            const backoffMs = consumeSessionStormBackoffMs(sessionStormBackoffScope);
+                            this.logStage('request.session_storm_backoff.recorded', input.requestId, {
+                                scope: sessionStormBackoffScope,
+                                backoffMs,
+                                consecutive: sessionStormBackoffState.get(sessionStormBackoffScope)?.consecutive ?? 0,
+                                reason: retryError.reason,
+                                errorCode: retryError.errorCode,
+                                upstreamCode: retryError.upstreamCode,
+                                statusCode: retryError.statusCode
+                            });
+                        }
+                        if (!bypassTrafficGovernor) {
+                            try {
+                                await this.trafficGovernor.observeOutcome?.({
+                                    runtimeKey,
+                                    providerKey: target.providerKey,
+                                    requestId: input.requestId,
+                                    success: false,
+                                    statusCode: retryError.statusCode,
+                                    errorCode: retryError.errorCode,
+                                    upstreamCode: retryError.upstreamCode,
+                                    reason: retryError.reason,
+                                    activeInFlight: trafficActiveInFlightAtAcquire,
+                                    configuredMaxInFlight: trafficPolicyMaxInFlight || undefined
+                                });
+                            }
+                            catch (observeError) {
+                                this.logStage('provider.traffic.observe_outcome.error', input.requestId, {
+                                    providerKey: target.providerKey,
+                                    runtimeKey,
+                                    message: observeError instanceof Error
+                                        ? observeError.message
+                                        : String(observeError ?? 'Unknown observe outcome error'),
+                                    attempt
+                                });
+                            }
+                        }
                         this.logStage('provider.send.error', input.requestId, {
                             providerKey: target.providerKey,
                             message: errorMessage,
@@ -1127,85 +3270,41 @@ export class HubRequestExecutor {
                             attempt
                         });
                         lastError = error;
-                        if (isAntigravityProviderKey(target.providerKey)) {
-                            const signature = extractRetryErrorSignature(error);
-                            const consecutive = antigravityRetrySignal && antigravityRetrySignal.signature === signature
-                                ? antigravityRetrySignal.consecutive + 1
-                                : 1;
-                            antigravityRetrySignal = { signature, consecutive };
-                        }
-                        else {
-                            antigravityRetrySignal = null;
-                        }
-                        const status = extractStatusCodeFromError(error);
-                        if (isSseDecodeRateLimitError(error, status)) {
-                            try {
-                                const { emitProviderError } = await import('../../../providers/core/utils/provider-error-reporter.js');
-                                emitProviderError({
-                                    error,
-                                    stage: 'provider.sse_decode',
-                                    runtime: {
-                                        requestId: input.requestId,
-                                        providerKey: target.providerKey,
-                                        providerId: handle.providerId,
-                                        providerType: handle.providerType,
-                                        providerFamily: handle.providerFamily,
-                                        providerProtocol,
-                                        routeName: pipelineResult.routingDecision?.routeName,
-                                        pipelineId: target.providerKey,
-                                        target,
-                                        runtimeKey
-                                    },
-                                    dependencies: this.deps.getModuleDependencies(),
-                                    statusCode: 429,
-                                    recoverable: true,
-                                    affectsHealth: true,
-                                    details: {
-                                        source: 'sse_decode_rate_limit',
-                                        errorCode: typeof error?.code === 'string' ? String(error.code) : undefined,
-                                        upstreamCode: typeof error?.upstreamCode === 'string' ? String(error.upstreamCode) : undefined,
-                                        message: errorMessage
-                                    }
-                                });
-                            }
-                            catch {
-                                // best-effort; never block retry/failover path
-                            }
-                        }
-                        else if (isSseDecodeRetryableNetworkError(error, status)) {
-                            try {
-                                const { emitProviderError } = await import('../../../providers/core/utils/provider-error-reporter.js');
-                                emitProviderError({
-                                    error,
-                                    stage: 'provider.sse_decode',
-                                    runtime: {
-                                        requestId: input.requestId,
-                                        providerKey: target.providerKey,
-                                        providerId: handle.providerId,
-                                        providerType: handle.providerType,
-                                        providerFamily: handle.providerFamily,
-                                        providerProtocol,
-                                        routeName: pipelineResult.routingDecision?.routeName,
-                                        pipelineId: target.providerKey,
-                                        target,
-                                        runtimeKey
-                                    },
-                                    dependencies: this.deps.getModuleDependencies(),
-                                    statusCode: 502,
-                                    recoverable: true,
-                                    affectsHealth: true,
-                                    details: {
-                                        source: 'sse_decode_network_error',
-                                        errorCode: typeof error?.code === 'string' ? String(error.code) : undefined,
-                                        upstreamCode: typeof error?.upstreamCode === 'string' ? String(error.upstreamCode) : undefined,
-                                        message: errorMessage
-                                    }
-                                });
-                            }
-                            catch {
-                                // best-effort; never block retry/failover path
-                            }
+                        const status = typeof retryError.statusCode === 'number'
+                            ? retryError.statusCode
+                            : extractStatusCodeFromError(error);
+                        if (providerTransportBackoffKey
+                            && shouldApplyProviderTransportBackoff({
+                                error,
+                                retryError,
+                                stage: 'provider.send'
+                            })) {
+                            const providerBackoffMs = consumeProviderTransportBackoffMs(providerTransportBackoffKey, {
+                                error,
+                                statusCode: status
+                            });
+                            this.logStage('provider.transport_backoff.recorded', input.requestId, {
+                                providerKey: target.providerKey,
+                                runtimeKey,
+                                backoffKey: providerTransportBackoffKey,
+                                backoffMs: providerBackoffMs,
+                                consecutive: providerTransportBackoffState.get(providerTransportBackoffKey)?.consecutive ?? 0,
+                                reason: retryError.reason,
+                                errorCode: retryError.errorCode,
+                                upstreamCode: retryError.upstreamCode,
+                                statusCode: status,
+                                attempt
+                            });
                         }
+                        const nextAntigravityRetrySignal = isAntigravityProviderKey(target.providerKey)
+                            ? (() => {
+                                const signature = extractRetryErrorSignature(error);
+                                const consecutive = antigravityRetrySignal && antigravityRetrySignal.signature === signature
+                                    ? antigravityRetrySignal.consecutive + 1
+                                    : 1;
+                                return { signature, consecutive };
+                            })()
+                            : null;
                         const isVerify = status === 403 && isGoogleAccountVerificationRequiredError(error);
                         const isReauth = status === 403 && isAntigravityReauthRequired403(error);
                         const promptTooLong = isPromptTooLongError(error);
@@ -1215,72 +3314,53 @@ export class HubRequestExecutor {
                                 forcedRouteHint = 'longcontext';
                             }
                         }
-                        const shouldRetry = attempt < maxAttempts &&
-                            (promptTooLong
-                                ? contextOverflowRetries < MAX_CONTEXT_OVERFLOW_RETRIES
-                                : (shouldRetryProviderError(error) ||
-                                    (isAntigravityProviderKey(target.providerKey) && (isVerify || isReauth))));
-                        if (!shouldRetry) {
-                            recordAttempt({ error: true });
-                            throw error;
-                        }
-                        // Record this failed provider attempt even if the overall request succeeds later via failover.
-                        recordAttempt({ error: true });
-                        const retryBackoffMs = await waitBeforeRetry(error, { attempt });
-                        const singleProviderPool = Boolean(initialRoutePool && initialRoutePool.length === 1 && initialRoutePool[0] === target.providerKey);
-                        if (promptTooLong && target.providerKey) {
-                            excludedProviderKeys.add(target.providerKey);
-                        }
-                        if (!promptTooLong && !singleProviderPool && target.providerKey) {
-                            const is429 = status === 429;
-                            if (isAntigravityProviderKey(target.providerKey) && (isVerify || is429)) {
-                                // For Antigravity 403 verify / 429 states:
-                                // - exclude the current providerKey so we don't immediately retry the same account
-                                // - avoid ALL other Antigravity aliases on retry (prefer non-Antigravity fallbacks)
-                                excludedProviderKeys.add(target.providerKey);
-                                if (antigravityRetrySignal) {
-                                    antigravityRetrySignal.avoidAllOnRetry = true;
-                                }
-                                else {
-                                    antigravityRetrySignal = { signature: extractRetryErrorSignature(error), consecutive: 1, avoidAllOnRetry: true };
-                                }
-                            }
-                            else if (isAntigravityProviderKey(target.providerKey) && isReauth) {
-                                // Antigravity OAuth reauth-required 403:
-                                // - exclude the current providerKey so router can pick another alias
-                                // - DO NOT avoid all Antigravity on retry; switching aliases is the intended recovery path.
-                                excludedProviderKeys.add(target.providerKey);
-                            }
-                            else if (!isAntigravityProviderKey(target.providerKey) || shouldRotateAntigravityAliasOnRetry(error)) {
-                                excludedProviderKeys.add(target.providerKey);
-                            }
-                        }
-                        const switchAction = singleProviderPool ? 'retry_same_provider' : 'exclude_and_reroute';
-                        this.logProviderRetrySwitch({
+                        const providerFailurePlan = await resolveRequestExecutorProviderFailurePlan({
+                            error,
+                            retryError,
                             requestId: input.requestId,
-                            attempt,
-                            maxAttempts,
-                            providerKey: target.providerKey,
-                            nextAttempt: attempt + 1,
-                            reason: retryError.reason,
-                            statusCode: retryError.statusCode,
-                            errorCode: retryError.errorCode,
-                            upstreamCode: retryError.upstreamCode,
-                            switchAction
-                        });
-                        this.logStage('provider.retry', input.requestId, {
                             providerKey: target.providerKey,
+                            providerId: handle.providerId,
+                            providerType: handle.providerType,
+                            providerFamily: handle.providerFamily,
+                            providerProtocol,
+                            routeName: pipelineResult.routingDecision?.routeName,
+                            runtimeKey,
+                            target: target,
+                            dependencies: this.deps.getModuleDependencies(),
                             attempt,
-                            nextAttempt: attempt + 1,
-                            excluded: Array.from(excludedProviderKeys),
-                            reason: retryError.reason,
+                            maxAttempts,
+                            stage: 'provider.send',
+                            logicalRequestChainKey,
+                            logicalChainRetryLimitStageRequestId: input.requestId,
+                            routePool: routePoolForAttempt,
+                            runtimeManager: this.deps.runtimeManager,
+                            excludedProviderKeys,
+                            recordAttempt,
+                            logStage: (stage, requestId, details) => this.logStage(stage, requestId, details),
                             routeHint: forcedRouteHint,
-                            switchAction,
-                            ...(typeof retryError.statusCode === 'number' ? { statusCode: retryError.statusCode } : {}),
-                            ...(retryError.errorCode ? { errorCode: retryError.errorCode } : {}),
-                            ...(retryError.upstreamCode ? { upstreamCode: retryError.upstreamCode } : {}),
-                            retryBackoffMs,
-                            ...(promptTooLong ? { contextOverflowRetries, maxContextOverflowRetries: MAX_CONTEXT_OVERFLOW_RETRIES } : {})
+                            promptTooLong,
+                            contextOverflowRetries,
+                            maxContextOverflowRetries: MAX_CONTEXT_OVERFLOW_RETRIES,
+                            isVerify,
+                            isReauth,
+                            allowAntigravityRecovery: true,
+                            antigravityRetrySignal: nextAntigravityRetrySignal,
+                            status,
+                            abortSignal: clientAbortSignal
+                        });
+                        const retryExecutionPlan = providerFailurePlan.retryExecutionPlan;
+                        if (!retryExecutionPlan.shouldRetry || !retryExecutionPlan.retrySwitchPlan || !retryExecutionPlan.backoffScope) {
+                            throw error;
+                        }
+                        antigravityRetrySignal = retryExecutionPlan.antigravityRetrySignal;
+                        if (!providerFailurePlan.retryTelemetryPlan) {
+                            throw error;
+                        }
+                        emitRequestExecutorProviderRetryTelemetry({
+                            requestId: input.requestId,
+                            retryTelemetryPlan: providerFailurePlan.retryTelemetryPlan,
+                            logStage: (stage, requestId, details) => this.logStage(stage, requestId, details),
+                            logProviderRetrySwitch: (switchArgs) => this.logProviderRetrySwitch(switchArgs)
                         });
                         continue;
                     }
@@ -1327,6 +3407,7 @@ export class HubRequestExecutor {
             }
             finally {
                 await this.deps.onRequestEnd?.({ requestId: executorRequestId });
+                releaseLogicalRequestChainIfNeeded();
             }
         }
         catch (error) {
@@ -1335,6 +3416,7 @@ export class HubRequestExecutor {
             if (!recordedAnyAttempt) {
                 recordAttempt({ error: true });
             }
+            releaseLogicalRequestChainIfNeeded();
             throw error;
         }
     }
@@ -1349,7 +3431,35 @@ export const __requestExecutorTestables = {
     readString,
     extractRetryErrorSnapshot,
     truncateReason,
-    detectRetryableEmptyAssistantResponse
+    isHealthNeutralProviderError,
+    isLastAvailableProvider429,
+    shouldApplyProviderTransportBackoff,
+    buildRecoverableErrorBackoffKey,
+    consumeRecoverableErrorBackoffMs,
+    buildProviderTransportBackoffKey,
+    consumeProviderTransportBackoffMs,
+    peekProviderTransportBackoffWaitMs,
+    clearProviderTransportBackoff,
+    detectRetryableEmptyAssistantResponse,
+    deriveLogicalRequestChainKey,
+    resolveSessionStormBackoffScope,
+    isSessionStormBackoffCandidate,
+    consumeSessionStormBackoffMs,
+    peekSessionStormBackoffWaitMs,
+    clearSessionStormBackoff,
+    prepareRequestPayloadRetrySeed,
+    resolveOriginalRequestForResponseConversion,
+    resolveRequestExecutorProviderErrorClassification,
+    resolveRequestExecutorProviderErrorReportPlan,
+    resolveProviderRetryEligibilityPlan,
+    resolveProviderRetryExclusionPlan,
+    resolveExcludedProviderReselectionPlan,
+    resolveProviderRetryExecutionPlan,
+    buildProviderRetryTelemetryPlan,
+    acquireRecoverableRetryWaiterSlotForTests,
+    peekRecoverableRetryWaitersForTests,
+    releaseRecoverableRetryWaiterSlotForTests,
+    resetRequestExecutorInternalStateForTests
 };
 export function createRequestExecutor(deps) {
     return new HubRequestExecutor(deps);