@zhixuan92/multi-model-agent-core 3.3.0 → 3.5.0

package/dist/run-tasks/reviewed-lifecycle.js

@@ -3,8 +3,11 @@ import { promisify } from 'node:util';
 import { computeCostUSD, computeSavedCostUSD } from '../types.js';
 import { createProvider } from '../provider.js';
 import { delegateWithEscalation } from '../delegate-with-escalation.js';
+import { pickEscalation, pickReviewer, maxRowsFor, } from '../escalation/policy.js';
+import { runWithFallback, makeSyntheticRunResult, TRANSPORT_FAILURES, isReviewTransportFailure, } from '../escalation/fallback.js';
 import { HeartbeatTimer } from '../heartbeat.js';
 import { runSpecReview } from '../review/spec-reviewer.js';
+import { makeSkippedReviewResult } from '../review/skipped-result.js';
 import { runQualityReview } from '../review/quality-reviewer.js';
 import { runDiffReview } from '../review/diff-review.js';
 import { aggregateResult } from '../review/aggregate-result.js';
@@ -22,16 +25,24 @@ const exec = promisify(execFile);
 export async function executeReviewedLifecycle(task, resolved, config, taskIndex, onProgress, heartbeatWiring, diagnostics) {
     const reviewPolicy = task.reviewPolicy ?? 'full';
     const otherSlot = resolved.slot === 'standard' ? 'complex' : 'standard';
-    // Partition filePaths into output targets before the worker runs.
-    // Output targets are paths that do not yet exist on disk.
-    const { outputTargets } = partitionFilePaths(task.filePaths, task.cwd ?? process.cwd());
     let escalationProvider;
     try {
         escalationProvider = createProvider(otherSlot, config);
     }
     catch {
-        // Other slot not configured — auto-escalation not available
+        escalationProvider = undefined;
+    }
+    const providers = {
+        [resolved.slot]: resolved.provider,
+    };
+    if (escalationProvider)
+        providers[otherSlot] = escalationProvider;
+    function providerFor(tier) {
+        return providers[tier];
     }
+    // Partition filePaths into output targets before the worker runs.
+    // Output targets are paths that do not yet exist on disk.
+    const { outputTargets } = partitionFilePaths(task.filePaths, task.cwd ?? process.cwd());
     const stageCount = reviewPolicy === 'off' ? 1 :
         reviewPolicy === 'spec_only' ? 3 :
             5;
@@ -42,6 +53,20 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
         : undefined;
     const verboseBatchIdEarly = heartbeatWiring?.batchId;
     const shortBatchEarly = verboseBatchIdEarly ? verboseBatchIdEarly.slice(0, 8) : '????????';
+    const taskEventLogger = diagnostics?.logger;
+    const emitTaskEvent = (event, fields) => {
+        if (taskEventLogger && verboseBatchIdEarly !== undefined) {
+            const cleaned = {};
+            for (const [key, value] of Object.entries(fields)) {
+                if (value !== undefined)
+                    cleaned[key] = value;
+            }
+            taskEventLogger.emit({ event, batchId: verboseBatchIdEarly, taskIndex, ...cleaned });
+        }
+        if (verboseStreamRaw) {
+            verboseStreamRaw(composeVerboseLine({ event, ts: new Date().toISOString(), batch: shortBatchEarly, task: taskIndex, ...fields }));
+        }
+    };
     // Start the heartbeat whenever there's a downstream consumer:
     // - onProgress (external progress callback from the runTasks caller)
     // - verbose (stderr stream needs the heartbeat's tool_call / turn_complete relay)
@@ -58,41 +83,30 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
     const synthOnProgress = onProgress ?? (() => { });
     const heartbeat = needHeartbeat
         ? new HeartbeatTimer((event) => {
-            if (verboseStreamRaw && event.kind === 'heartbeat') {
+            if (event.kind === 'heartbeat') {
                 // Emit on every heartbeat tick so the operator can confirm
                 // the timer is actually firing. Stage-change lines are richer
                 // but fire only on transitions; plain ticks let you see
                 // per-5s progress inside a long-running stage.
                 if (event.stage !== lastStageSeen) {
                     if (lastStageSeen !== undefined) {
-                        verboseStreamRaw(composeVerboseLine({
-                            event: 'stage_change',
-                            ts: new Date().toISOString(),
-                            batch: shortBatchEarly,
-                            task: taskIndex,
-                            from: lastStageSeen,
-                            to: event.stage,
-                        }));
+                        emitTaskEvent('stage_change', { from: lastStageSeen, to: event.stage });
                     }
                     lastStageSeen = event.stage;
                 }
                 const sinceLastMs = Date.now() - prevEventAtMs;
-                verboseStreamRaw(composeVerboseLine({
-                    event: 'heartbeat',
-                    ts: new Date().toISOString(),
-                    batch: shortBatchEarly,
-                    task: taskIndex,
+                emitTaskEvent('heartbeat', {
                     elapsed: event.elapsed,
                     stage: event.stage,
                     round: event.reviewRound,
-                    cap: event.maxReviewRounds,
+                    cap: event.attemptCap,
                     tools: event.progress.toolCalls,
                     read: event.progress.filesRead,
                     wrote: event.progress.filesWritten,
                     text: textEmissionChars,
                     cost: event.costUSD,
                     idle_ms: sinceLastMs,
-                }));
+                });
             }
             synthOnProgress(taskIndex, event);
         }, {
@@ -103,33 +117,16 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
         })
         : undefined;
     heartbeat?.start(stageCount);
-    if (verboseStreamRaw) {
-        verboseStreamRaw(composeVerboseLine({
-            event: 'heartbeat_timer',
-            ts: new Date().toISOString(),
-            batch: shortBatchEarly,
-            task: taskIndex,
-            state: heartbeat ? 'started' : 'disabled',
-            stage_count: stageCount,
-            tick_ms: heartbeat ? 5000 : undefined,
-            reason: heartbeat ? undefined : 'no_consumer',
-        }));
-    }
+    emitTaskEvent('heartbeat_timer', {
+        state: heartbeat ? 'started' : 'disabled',
+        stage_count: stageCount,
+        tick_ms: heartbeat ? 5000 : undefined,
+        reason: heartbeat ? undefined : 'no_consumer',
+    });
     const implModel = resolved.provider.config.model;
     const progressCounters = { filesRead: 0, filesWritten: 0, toolCalls: 0 };
-    const verboseLogger = verbose && diagnostics?.logger ? diagnostics.logger : undefined;
-    const verboseBatchId = verboseBatchIdEarly;
     const verboseStream = verboseStreamRaw;
-    const shortBatch = shortBatchEarly;
-    if (verboseStream) {
-        verboseStream(composeVerboseLine({
-            event: 'worker_start',
-            ts: new Date().toISOString(),
-            batch: shortBatch,
-            task: taskIndex,
-            worker: resolved.provider.config.model,
-        }));
-    }
+    emitTaskEvent('worker_start', { worker: resolved.provider.config.model });
     let prevEventAtMs = verbose ? Date.now() : 0;
     // Wrap whenever we have ANY consumer for InternalRunnerEvent (heartbeat,
     // verbose stream, or verbose logger). Previously this only wrapped when
@@ -142,33 +139,25 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                 heartbeat?.markEvent('llm');
                 if (verbose)
                     prevEventAtMs = Date.now();
-                if (verboseStream) {
-                    verboseStream(composeVerboseLine({
-                        event: 'turn_start',
-                        ts: new Date().toISOString(),
-                        batch: shortBatch,
-                        task: taskIndex,
+                if (verbose) {
+                    emitTaskEvent('turn_start', {
                         turn: event.turn,
                         provider: event.provider,
-                    }));
+                    });
                 }
             }
             if (event.kind === 'text_emission') {
                 heartbeat?.markEvent('text');
                 textEmissionChars += event.chars;
-                if (verboseStream && event.chars > 0) {
+                if (verbose && event.chars > 0) {
                     const preview = event.preview.length > 60
                         ? event.preview.slice(0, 57) + '...'
                         : event.preview;
-                    verboseStream(composeVerboseLine({
-                        event: 'text_emission',
-                        ts: new Date().toISOString(),
-                        batch: shortBatch,
-                        task: taskIndex,
+                    emitTaskEvent('text_emission', {
                         chars: event.chars,
                         total: textEmissionChars,
                         preview,
-                    }));
+                    });
                 }
             }
             if (event.kind === 'tool_call') {
@@ -186,23 +175,11 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                 const sincePrevMs = verbose ? now - prevEventAtMs : 0;
                 if (verbose)
                     prevEventAtMs = now;
-                if (verboseLogger && verboseBatchId) {
-                    verboseLogger.toolCall({
-                        batchId: verboseBatchId,
-                        taskIndex,
-                        tool: event.toolSummary,
-                        durationMs: sincePrevMs,
-                    });
-                }
-                if (verboseStream) {
-                    verboseStream(composeVerboseLine({
-                        event: 'tool_call',
-                        ts: new Date().toISOString(),
-                        batch: shortBatch,
-                        task: taskIndex,
+                if (verbose) {
+                    emitTaskEvent('tool_call', {
                         tool: event.toolSummary,
                         duration_ms: sincePrevMs,
-                    }));
+                    });
                 }
             }
             if (event.kind === 'turn_complete') {
@@ -214,29 +191,14 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                 const turnDurMs = verbose ? nowTurn - prevEventAtMs : 0;
                 if (verbose)
                     prevEventAtMs = nowTurn;
-                if (verboseLogger && verboseBatchId) {
-                    verboseLogger.llmTurn({
-                        batchId: verboseBatchId,
-                        taskIndex,
-                        turnIndex: progressCounters.toolCalls,
-                        provider: resolved.provider.config.model,
-                        inputTokens: event.cumulativeInputTokens,
-                        outputTokens: event.cumulativeOutputTokens,
-                        costUSD,
-                    });
-                }
-                if (verboseStream) {
-                    verboseStream(composeVerboseLine({
-                        event: 'turn_complete',
-                        ts: new Date().toISOString(),
-                        batch: shortBatch,
-                        task: taskIndex,
+                if (verbose) {
+                    emitTaskEvent('turn_complete', {
                         input_tokens: event.cumulativeInputTokens,
                         output_tokens: event.cumulativeOutputTokens,
                         cost: costUSD,
                         duration_ms: turnDurMs,
                         provider: resolved.provider.config.model,
-                    }));
+                    });
                 }
             }
         }
@@ -245,17 +207,76 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
     const taskStartMs = Date.now();
     const commits = [];
     let commitError;
-    let specRework = 0;
-    let qualityRework = 0;
+    let specAttemptIndex = 0;
+    let qualityAttemptIndex = 0;
+    const maxSpecRows = maxRowsFor('spec');
+    const maxQualityRows = maxRowsFor('quality');
+    const specUnavailable = new Map();
+    let qualityUnavailable = new Map();
     let metadataRepair = 0;
-    const maxReviewRounds = task.maxReviewRounds ?? 3;
     const maxCostUSD = task.maxCostUSD;
-    const reviewRounds = () => ({ spec: specRework, quality: qualityRework, metadata: metadataRepair, cap: maxReviewRounds });
+    const implementerHistory = [];
+    const specReviewerHistory = [];
+    const qualityReviewerHistory = [];
+    const fallbackOverrides = [];
+    let latestAttemptedImpl;
+    let lastNonRejectedImpl;
+    const reviewRounds = () => ({ spec: specAttemptIndex, quality: qualityAttemptIndex, metadata: metadataRepair, cap: Math.max(maxSpecRows, maxQualityRows) });
     const taskCostUSD = () => (heartbeat ? heartbeat.getHeartbeatTickInfo().costUSD : null);
+    const policyEscalated = { spec: false, quality: false, diff: false };
+    const emitFallback = (p) => {
+        diagnostics?.logger?.fallback(p);
+        emitTaskEvent('fallback', p);
+    };
+    const emitFallbackUnavailable = (p) => {
+        diagnostics?.logger?.fallbackUnavailable(p);
+        emitTaskEvent('fallback_unavailable', p);
+    };
+    const emitEscalationEvent = (loop, attempt, decision) => {
+        const p = {
+            batchId: heartbeatWiring?.batchId ?? '', taskIndex, loop, attempt,
+            baseTier: resolved.slot, implTier: decision.impl, reviewerTier: decision.reviewer,
+        };
+        diagnostics?.logger?.escalation(p);
+        emitTaskEvent('escalation', p);
+        policyEscalated[loop] = true;
+    };
+    const emitEscalationUnavailable = (p) => {
+        diagnostics?.logger?.escalationUnavailable(p);
+        emitTaskEvent('escalation_unavailable', p);
+    };
     // When the review loop aborts mid-flight, preserve any review-status info already set
     // on the base result (set by callers via abortReviewLoop({ ...res, specReviewStatus, ... })).
     // Defaults to 'changes_required' for whichever loop tripped — that's the only state the
     // loop ever fires from, by construction.
+    function adaptForAllTiersUnavailable(base, loop, attempt) {
+        const ship = lastNonRejectedImpl?.result ?? base;
+        return {
+            ...ship,
+            status: 'incomplete',
+            workerStatus: 'blocked',
+            terminationReason: 'all_tiers_unavailable',
+            reviewRounds: reviewRounds(),
+            error: `runWithFallback: both tiers unavailable (loop=${loop}, attempt=${attempt}, role=implementer)`,
+            agents: agentEnvelope(specReviewerHistory[specReviewerHistory.length - 1] ?? 'not_applicable', qualityReviewerHistory[qualityReviewerHistory.length - 1] ?? (reviewPolicy === 'full' ? 'not_applicable' : 'skipped')),
+        };
+    }
+    function reviewDidNotReject(status) {
+        return status === 'approved' || status === 'skipped';
+    }
+    const agentEnvelope = (specReviewer, qualityReviewer) => {
+        const selectedImpl = latestAttemptedImpl ?? lastNonRejectedImpl;
+        const implementer = selectedImpl?.tier ?? resolved.slot;
+        return {
+            implementer,
+            ...(implementerHistory.length > 1 || implementerHistory.some(t => t !== implementer) ? { implementerHistory } : {}),
+            specReviewer,
+            ...(specReviewerHistory.length > 0 && (specReviewerHistory.length > 1 || specReviewerHistory.some(t => t === 'skipped')) ? { specReviewerHistory } : {}),
+            qualityReviewer,
+            ...(qualityReviewerHistory.length > 0 && (qualityReviewerHistory.length > 1 || qualityReviewerHistory.some(t => t === 'skipped')) ? { qualityReviewerHistory } : {}),
+            ...(fallbackOverrides.length > 0 ? { fallbackOverrides } : {}),
+        };
+    };
     const abortReviewLoop = (base, terminationReason, message, aborting) => ({
         ...base,
         status: 'incomplete',
@@ -265,27 +286,16 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
         error: message,
         specReviewStatus: aborting === 'spec' ? 'changes_required' : (base.specReviewStatus ?? 'approved'),
         qualityReviewStatus: aborting === 'quality' ? 'changes_required' : (base.qualityReviewStatus ?? 'skipped'),
+        agents: agentEnvelope(specReviewerHistory[specReviewerHistory.length - 1] ?? 'not_applicable', qualityReviewerHistory[qualityReviewerHistory.length - 1] ?? (reviewPolicy === 'full' ? 'not_applicable' : 'skipped')),
     });
     const defaultVerification = { status: 'skipped', steps: [], totalDurationMs: 0, skipReason: 'no_command' };
     let latestVerification = defaultVerification;
-    const emitVerbose = (event, fields) => {
-        if (!verboseStream)
-            return;
-        verboseStream(composeVerboseLine({
-            event,
-            ts: new Date().toISOString(),
-            batch: shortBatch,
-            task: taskIndex,
-            ...fields,
-        }));
-    };
     async function runVerificationStage() {
-        emitVerbose('stage_change', { from: 'committing', to: 'verifying' });
+        emitTaskEvent('stage_change', { from: 'committing', to: 'verifying' });
         heartbeat?.transition({
             stage: 'verifying',
             stageIndex: 4,
             reviewRound: undefined,
-            maxReviewRounds: task.maxReviewRounds ?? 5,
         });
         const verification = await runVerifyStage({
             cwd,
@@ -295,7 +305,7 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
         });
         latestVerification = verification;
         for (const step of verification.steps) {
-            emitVerbose('verify_step', {
+            emitTaskEvent('verify_step', {
                 command: step.command,
                 status: step.status,
                 exit_code: step.exitCode,
@@ -305,12 +315,46 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
             });
         }
         if (verification.status === 'skipped') {
-            emitVerbose('verify_skipped', { reason: verification.skipReason ?? 'no_command', stage: 'verifying' });
+            emitTaskEvent('verify_skipped', { reason: verification.skipReason ?? 'no_command', stage: 'verifying' });
         }
         return verification;
     }
+    function signalize(result) {
+        const cause = typeof result.terminationReason === 'object' ? result.terminationReason.cause : result.terminationReason;
+        const capExhausted = result.capExhausted
+            ?? (result.status === 'cost_exceeded' || cause === 'cost_exceeded' || cause === 'cost_ceiling' ? 'cost'
+                : result.status === 'timeout' || cause === 'timeout' ? 'wall_clock'
+                    : result.status === 'incomplete' && result.turns > 1 ? 'turn'
+                        : undefined);
+        const lifecycleClarificationRequested = result.lifecycleClarificationRequested
+            ?? (result.status === 'brief_too_vague' || cause === 'brief_too_vague' ? true : undefined);
+        return {
+            ...result,
+            ...(capExhausted !== undefined && { capExhausted }),
+            ...(lifecycleClarificationRequested !== undefined && { lifecycleClarificationRequested }),
+        };
+    }
+    function workerErrorResult(err) {
+        const workerError = err instanceof Error ? err : new Error(String(err));
+        return signalize({
+            output: '',
+            status: 'error',
+            usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0, costUSD: null },
+            turns: 0,
+            filesRead: [],
+            filesWritten: [],
+            toolCalls: [],
+            outputIsDiagnostic: true,
+            escalationLog: [],
+            error: workerError.message,
+            errorCode: 'runner_crash',
+            structuredError: { code: 'runner_crash', message: workerError.message },
+            workerStatus: 'failed',
+            workerError,
+        });
+    }
     function withVerification(result, verification = latestVerification) {
-        return { ...result, verification };
+        return signalize({ ...result, verification });
     }
     function verificationErrorResult(base, verification) {
         if (verification.status !== 'error')
@@ -365,6 +409,15 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
     }
     function resolveDiffOnlyTerminal(base, verdict, verification, diffTruncated) {
         const concerns = [...(base.concerns ?? [])];
+        if ('status' in verdict && verdict.status === 'skipped') {
+            return withVerification({
+                ...base,
+                workerStatus: workerStatusForTerminal(base.workerStatus),
+                commits,
+                commitError,
+                verification,
+            }, verification);
+        }
         if (verdict.kind === 'reject') {
             return withVerification({
                 ...base,
@@ -382,6 +435,18 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                 verification,
             }, verification);
         }
+        if (verdict.kind === 'transport_failure') {
+            return withVerification({
+                ...base,
+                status: verdict.status,
+                workerStatus: 'failed',
+                error: verdict.reason ?? `diff review transport failure: ${verdict.status}`,
+                concerns: [...concerns, ...verdict.concerns],
+                commits,
+                commitError,
+                verification,
+            }, verification);
+        }
         concerns.push(...verdict.concerns);
         if (verification.status === 'failed') {
             concerns.push({
@@ -487,7 +552,57 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                 });
             }
         }
-        const implResult = await delegateWithEscalation(withDoneCondition(task), [resolved.provider], { explicitlyPinned: false, escalateToProvider: escalationProvider, onProgress: wrappedOnProgress });
+        const initialDecision = pickEscalation({
+            loop: 'spec',
+            attemptIndex: 0,
+            baseTier: resolved.slot,
+        });
+        const initialImpl = await runWithFallback({
+            assigned: initialDecision.impl,
+            providerFor,
+            unavailableTiers: specUnavailable,
+            isTransportFailure: (r) => TRANSPORT_FAILURES.has(r.status) && r.capExhausted === undefined,
+            getStatus: (r) => r.status,
+            makeSyntheticFailure: (assigned) => makeSyntheticRunResult(assigned, 'all_tiers_unavailable'),
+            call: (provider) => delegateWithEscalation(withDoneCondition(task), [provider], { explicitlyPinned: false, onProgress: wrappedOnProgress }),
+        });
+        if (initialImpl.fallbackFired || initialImpl.bothUnavailable) {
+            fallbackOverrides.push({
+                role: 'implementer',
+                loop: 'spec',
+                attempt: 0,
+                assigned: initialDecision.impl,
+                used: initialImpl.usedTier,
+                reason: (initialImpl.fallbackReason ?? initialImpl.unavailableReason),
+                triggeringStatus: initialImpl.fallbackTriggeringStatus,
+                bothUnavailable: initialImpl.bothUnavailable,
+            });
+        }
+        if (initialImpl.fallbackFired) {
+            emitFallback({
+                batchId: heartbeatWiring?.batchId ?? '', taskIndex,
+                loop: 'spec', attempt: 0, role: 'implementer',
+                assignedTier: initialDecision.impl,
+                usedTier: initialImpl.usedTier,
+                reason: initialImpl.fallbackReason,
+                triggeringStatus: initialImpl.fallbackTriggeringStatus,
+                violatesSeparation: false,
+            });
+        }
+        if (initialImpl.bothUnavailable) {
+            emitFallbackUnavailable({
+                batchId: heartbeatWiring?.batchId ?? '', taskIndex,
+                loop: 'spec', attempt: 0, role: 'implementer',
+                assignedTier: initialDecision.impl,
+                reason: initialImpl.unavailableReason,
+            });
+            return adaptForAllTiersUnavailable(initialImpl.result, 'spec', 0);
+        }
+        const implResult = initialImpl.result;
+        latestAttemptedImpl = { tier: initialImpl.usedTier, result: implResult };
+        lastNonRejectedImpl = { tier: initialImpl.usedTier, result: implResult };
+        implementerHistory.push(initialImpl.usedTier);
+        specAttemptIndex = 1;
         const implReport = implResult.status === 'ok' ? parseStructuredReport(implResult.output) : undefined;
         const workerStatus = extractWorkerStatus(implReport);
         if (implResult.status === 'ok' && isArtifactProducing) {
@@ -503,6 +618,28 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
         const filePathsSkipped = !filePathsInteracted;
         if (implResult.filesWritten.length === 0) {
             heartbeat?.updateStageCount(1);
+            if (reviewPolicy === 'off') {
+                emitTaskEvent('stage_change', { from: 'verifying', to: 'terminal' });
+                const terminal = resolveOffTerminal({
+                    ...implResult,
+                    workerStatus,
+                    specReviewStatus: 'skipped',
+                    qualityReviewStatus: 'skipped',
+                    specReviewReason: 'skipped: reviewPolicy is off',
+                    qualityReviewReason: 'skipped: reviewPolicy is off',
+                    agents: agentEnvelope('skipped', 'skipped'),
+                    models: {
+                        implementer: implModel,
+                        specReviewer: null,
+                        qualityReviewer: null,
+                    },
+                    implementationReport: implReport,
+                    structuredReport: implReport,
+                    filePathsSkipped,
+                    fileArtifactsMissing: implResult.status === 'ok' ? checkOutputTargets(outputTargets) : undefined,
+                }, verification);
+                return terminal;
+            }
             const effectiveImplReport = implReport ?? buildFallbackImplReport(implResult);
             const earlyFileArtifactsMissing = implResult.status === 'ok' ? checkOutputTargets(outputTargets) : undefined;
             const earlyStatus = implResult.status === 'ok' && earlyFileArtifactsMissing
@@ -523,13 +660,10 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                     validationsRun: effectiveImplReport.validationsRun,
                     deviationsFromBrief: effectiveImplReport.deviationsFromBrief,
                     unresolved: effectiveImplReport.unresolved,
+                    extraSections: effectiveImplReport.extraSections ?? {},
                 },
                 filePathsSkipped,
-                agents: {
-                    implementer: resolved.slot,
-                    specReviewer: 'not_applicable',
-                    qualityReviewer: 'not_applicable',
-                },
+                agents: agentEnvelope('not_applicable', 'not_applicable'),
                 models: {
                     implementer: implModel,
                     specReviewer: null,
@@ -549,11 +683,7 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                 qualityReviewStatus: 'skipped',
                 specReviewReason: 'skipped: worker reported ' + workerStatus,
                 qualityReviewReason: 'skipped: worker reported ' + workerStatus,
-                agents: {
-                    implementer: resolved.slot,
-                    specReviewer: 'skipped',
-                    qualityReviewer: 'skipped',
-                },
+                agents: agentEnvelope('skipped', 'skipped'),
                 models: {
                     implementer: implModel,
                     specReviewer: null,
@@ -566,7 +696,7 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
             };
         }
         if (reviewPolicy === 'off') {
-            emitVerbose('stage_change', { from: 'verifying', to: 'terminal' });
+            emitTaskEvent('stage_change', { from: 'verifying', to: 'terminal' });
             const terminal = resolveOffTerminal({
                 ...implResult,
                 workerStatus,
@@ -574,11 +704,7 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                 qualityReviewStatus: 'skipped',
                 specReviewReason: 'skipped: reviewPolicy is off',
                 qualityReviewReason: 'skipped: reviewPolicy is off',
-                agents: {
-                    implementer: resolved.slot,
-                    specReviewer: 'skipped',
-                    qualityReviewer: 'skipped',
-                },
+                agents: agentEnvelope('skipped', 'skipped'),
                 models: {
                     implementer: implModel,
                     specReviewer: null,
@@ -589,35 +715,7 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
             }, verification);
             return terminal;
         }
-        let otherProvider;
-        try {
-            otherProvider = createProvider(otherSlot, config);
-        }
-        catch {
-            return {
-                ...implResult,
-                workerStatus,
-                specReviewStatus: 'skipped',
-                qualityReviewStatus: 'skipped',
-                specReviewReason: 'skipped: no review agent configured',
-                qualityReviewReason: 'skipped: no review agent configured',
-                agents: {
-                    implementer: resolved.slot,
-                    specReviewer: 'skipped',
-                    qualityReviewer: 'skipped',
-                },
-                models: {
-                    implementer: implModel,
-                    specReviewer: null,
-                    qualityReviewer: null,
-                },
-                fileArtifactsMissing: implResult.status === 'ok' ? checkOutputTargets(outputTargets) : undefined,
-                commits,
-                commitError,
-                verification,
-            };
-        }
-        const reviewModel = otherProvider.config.model;
+        const reviewModel = providerFor(pickReviewer({ loop: 'spec', attemptIndex: 0, baseTier: resolved.slot }))?.config.model ?? null;
         const packet = {
             prompt: task.prompt,
             scope: task.filePaths ?? [],
@@ -629,21 +727,28 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
             ? await buildEvidence({ cwd, baselineHead, commits, verification, reviewPolicy })
             : { block: '', diffTruncated: false, fullDiff: '' };
         if (reviewPolicy === 'diff_only') {
-            emitVerbose('stage_change', { from: 'verifying', to: 'diff_review' });
-            heartbeat?.transition({
-                stage: 'diff_review',
-                stageIndex: 2,
-                reviewRound: 1,
-                maxReviewRounds,
-            });
-            const verdict = await runDiffReview({
-                cwd,
-                diff: evidence.fullDiff,
-                diffTruncated: evidence.diffTruncated,
-                verification,
-                worker: { call: (prompt) => otherProvider.run(prompt) },
+            const diffUnavailable = new Map();
+            const diffReviewerTier = pickReviewer({ loop: 'spec', attemptIndex: 0, baseTier: resolved.slot });
+            emitTaskEvent('stage_change', { from: 'verifying', to: 'diff_review' });
+            heartbeat?.transition({ stage: 'diff_review', stageIndex: 2, reviewRound: 1, attemptCap: 1 });
+            const diffCall = await runWithFallback({
+                assigned: diffReviewerTier,
+                providerFor,
+                unavailableTiers: diffUnavailable,
+                isTransportFailure: (r) => isReviewTransportFailure(r),
+                getStatus: (r) => r.status,
+                makeSyntheticFailure: () => makeSkippedReviewResult('all_tiers_unavailable'),
+                call: (provider) => runDiffReview({ cwd, diff: evidence.fullDiff, diffTruncated: evidence.diffTruncated, verification, worker: { call: (prompt) => provider.run(prompt) } }),
             });
-            emitVerbose('review_decision', { stage: 'diff_review', verdict: verdict.kind, round: 1 });
+            if (diffCall.fallbackFired) {
+                emitFallback({ batchId: heartbeatWiring?.batchId ?? '', taskIndex, loop: 'diff', attempt: 0, role: 'diffReviewer', assignedTier: diffReviewerTier, usedTier: diffCall.usedTier, reason: diffCall.fallbackReason, triggeringStatus: diffCall.fallbackTriggeringStatus, violatesSeparation: diffCall.usedTier === implementerHistory[implementerHistory.length - 1] });
+                fallbackOverrides.push({ role: 'diffReviewer', loop: 'diff', attempt: 0, assigned: diffReviewerTier, used: diffCall.usedTier, reason: diffCall.fallbackReason, triggeringStatus: diffCall.fallbackTriggeringStatus, bothUnavailable: diffCall.bothUnavailable });
+            }
+            if (diffCall.bothUnavailable) {
+                emitFallbackUnavailable({ batchId: heartbeatWiring?.batchId ?? '', taskIndex, loop: 'diff', attempt: 0, role: 'diffReviewer', assignedTier: diffReviewerTier, reason: diffCall.unavailableReason });
+            }
+            const verdict = diffCall.bothUnavailable || isReviewTransportFailure(diffCall.result) ? makeSkippedReviewResult('all_tiers_unavailable') : diffCall.result;
+            emitTaskEvent('review_decision', { stage: 'diff_review', verdict: 'kind' in verdict ? verdict.kind : 'skipped', round: 1 });
             return resolveDiffOnlyTerminal({
                 ...implResult,
                 workerStatus,
@@ -653,120 +758,188 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                 qualityReviewReason: 'skipped: reviewPolicy is diff_only',
                 implementationReport: effectiveImplReport,
                 fileArtifactsMissing: implResult.status === 'ok' ? checkOutputTargets(outputTargets) : undefined,
-                agents: {
-                    implementer: resolved.slot,
-                    specReviewer: 'skipped',
-                    qualityReviewer: 'skipped',
-                },
-                models: {
-                    implementer: implModel,
-                    specReviewer: reviewModel,
-                    qualityReviewer: null,
-                },
+                agents: agentEnvelope('skipped', 'skipped'),
+                models: { implementer: implModel, specReviewer: reviewModel, qualityReviewer: null },
             }, verdict, verification, evidence.diffTruncated);
         }
-        heartbeat?.transition({
-            stage: 'spec_review', stageIndex: 2,
-            reviewRound: 1, maxReviewRounds: task.maxReviewRounds ?? 5,
-        });
-        let specResult = await runSpecReview(otherProvider, packet, effectiveImplReport, fileContents, implResult.toolCalls, task.planContext, evidence.block);
         let finalImplResult = implResult;
         let finalImplReport = effectiveImplReport;
-        let specStatus = specResult.status;
-        let specReport = specResult.report;
-        if (specStatus === 'changes_required') {
-            let prevSpecFindings = [];
-            while (true) {
-                if (specRework + qualityRework >= maxReviewRounds) {
-                    return abortReviewLoop(finalImplResult, 'round_cap', 'review round cap reached before spec rework', 'spec');
+        let specResult;
+        let specStatus;
+        let specReport;
+        let specReviewReason;
+        heartbeat?.transition({ stage: 'spec_review', stageIndex: 2, reviewRound: 1, attemptCap: maxSpecRows });
+        const initialReviewerTier = pickReviewer({ loop: 'spec', attemptIndex: 0, baseTier: resolved.slot });
+        const initialSpecReview = await runWithFallback({
+            assigned: initialReviewerTier,
+            providerFor,
+            unavailableTiers: specUnavailable,
+            isTransportFailure: (r) => isReviewTransportFailure(r),
+            getStatus: (r) => r.status,
+            makeSyntheticFailure: () => makeSkippedReviewResult('all_tiers_unavailable'),
+            call: (provider) => runSpecReview(provider, packet, effectiveImplReport, fileContents, implResult.toolCalls, task.planContext, evidence.block),
+        });
+        if (initialSpecReview.bothUnavailable) {
+            emitFallbackUnavailable({ batchId: heartbeatWiring?.batchId ?? '', taskIndex, loop: 'spec', attempt: 0, role: 'specReviewer', assignedTier: initialReviewerTier, reason: initialSpecReview.unavailableReason });
+            fallbackOverrides.push({ role: 'specReviewer', loop: 'spec', attempt: 0, assigned: initialReviewerTier, used: initialSpecReview.usedTier, reason: initialSpecReview.unavailableReason, triggeringStatus: initialSpecReview.fallbackTriggeringStatus, bothUnavailable: true });
+            specReviewerHistory.push('skipped');
+        }
+        else {
+            specReviewerHistory.push(initialSpecReview.usedTier);
+            if (initialSpecReview.fallbackFired) {
+                emitFallback({ batchId: heartbeatWiring?.batchId ?? '', taskIndex, loop: 'spec', attempt: 0, role: 'specReviewer', assignedTier: initialReviewerTier, usedTier: initialSpecReview.usedTier, reason: initialSpecReview.fallbackReason, triggeringStatus: initialSpecReview.fallbackTriggeringStatus, violatesSeparation: initialSpecReview.usedTier === implementerHistory[implementerHistory.length - 1] });
+                fallbackOverrides.push({ role: 'specReviewer', loop: 'spec', attempt: 0, assigned: initialReviewerTier, used: initialSpecReview.usedTier, reason: initialSpecReview.fallbackReason, triggeringStatus: initialSpecReview.fallbackTriggeringStatus, bothUnavailable: false });
+            }
+        }
+        specResult = initialSpecReview.bothUnavailable
+            ? makeSkippedReviewResult('all_tiers_unavailable')
+            : initialSpecReview.result;
+        specStatus = specResult.status;
+        specReport = 'report' in specResult ? specResult.report : undefined;
+        specReviewReason = specStatus === 'skipped' ? 'all_tiers_unavailable' : ('errorReason' in specResult ? specResult.errorReason : undefined);
+        let prevSpecFindings = [...(specResult.findings ?? [])];
+        while (specStatus === 'changes_required') {
+            if (specAttemptIndex >= maxSpecRows)
+                return abortReviewLoop(finalImplResult, 'round_cap', 'review round cap reached before spec rework', 'spec');
+            const currentCostUSD = taskCostUSD();
+            if (currentCostUSD !== null && maxCostUSD !== undefined && currentCostUSD >= 0.8 * maxCostUSD) {
+                emitTaskEvent('cost_check', { stage: 'spec_rework', tripped: true, cost_used_usd: currentCostUSD, cost_cap_usd: maxCostUSD, cost_available: true });
+                return abortReviewLoop(finalImplResult, 'cost_ceiling', 'cost ceiling reached before spec rework', 'spec');
+            }
+            const decision = pickEscalation({ loop: 'spec', attemptIndex: specAttemptIndex, baseTier: resolved.slot });
+            if (decision.isEscalated)
+                emitEscalationEvent('spec', specAttemptIndex, decision);
+            emitTaskEvent('stage_change', { from: 'spec_review', to: 'spec_rework', attempt: specAttemptIndex, attemptCap: maxSpecRows, implTier: decision.impl, reviewerTier: decision.reviewer, escalated: decision.isEscalated });
+            heartbeat?.transition({ stage: 'spec_rework', stageIndex: 3, reviewRound: specAttemptIndex, attemptCap: maxSpecRows });
+            const feedback = specResult.findings.length > 0 ? `\n\n## Spec Review Feedback (round ${specAttemptIndex}):\n${specResult.findings.map(f => `- ${f}`).join('\n')}` : '';
+            const reworkTask = withDoneCondition({ ...task, prompt: `${task.prompt}${feedback}` });
+            const reworkCall = await runWithFallback({ assigned: decision.impl, providerFor, unavailableTiers: specUnavailable, isTransportFailure: (r) => TRANSPORT_FAILURES.has(r.status) && r.capExhausted === undefined, getStatus: (r) => r.status, makeSyntheticFailure: (assigned) => makeSyntheticRunResult(assigned, 'all_tiers_unavailable'), call: (provider) => delegateWithEscalation(reworkTask, [provider], { explicitlyPinned: true, onProgress: wrappedOnProgress }) });
+            if (reworkCall.fallbackFired || reworkCall.bothUnavailable)
+                fallbackOverrides.push({ role: 'implementer', loop: 'spec', attempt: specAttemptIndex, assigned: decision.impl, used: reworkCall.usedTier, reason: (reworkCall.fallbackReason ?? reworkCall.unavailableReason), triggeringStatus: reworkCall.fallbackTriggeringStatus, bothUnavailable: reworkCall.bothUnavailable });
+            if (reworkCall.fallbackFired) {
+                emitFallback({ batchId: heartbeatWiring?.batchId ?? '', taskIndex, loop: 'spec', attempt: specAttemptIndex, role: 'implementer', assignedTier: decision.impl, usedTier: reworkCall.usedTier, reason: reworkCall.fallbackReason, triggeringStatus: reworkCall.fallbackTriggeringStatus, violatesSeparation: false });
+                if (decision.isEscalated && reworkCall.fallbackReason === 'not_configured')
+                    emitEscalationUnavailable({ batchId: heartbeatWiring?.batchId ?? '', taskIndex, loop: 'spec', attempt: specAttemptIndex, role: 'implementer', wantedTier: decision.impl, reason: reworkCall.fallbackReason });
+            }
+            if (reworkCall.bothUnavailable) {
+                emitFallbackUnavailable({ batchId: heartbeatWiring?.batchId ?? '', taskIndex, loop: 'spec', attempt: specAttemptIndex, role: 'implementer', assignedTier: decision.impl, reason: reworkCall.unavailableReason });
+                if (decision.isEscalated)
+                    emitEscalationUnavailable({ batchId: heartbeatWiring?.batchId ?? '', taskIndex, loop: 'spec', attempt: specAttemptIndex, role: 'implementer', wantedTier: decision.impl, reason: reworkCall.unavailableReason });
+                return adaptForAllTiersUnavailable(reworkCall.result, 'spec', specAttemptIndex);
+            }
+            finalImplResult = reworkCall.result;
+            latestAttemptedImpl = { tier: reworkCall.usedTier, result: finalImplResult };
+            implementerHistory.push(reworkCall.usedTier);
+            const reworkReport = parseStructuredReport(finalImplResult.output);
+            finalImplReport = reworkReport.summary ? reworkReport : buildFallbackImplReport(finalImplResult);
+            fileContents = await readImplementerFileContents(finalImplResult.filesWritten, task.cwd);
+            heartbeat?.transition({ stage: 'spec_review', stageIndex: 2, reviewRound: specAttemptIndex + 1, attemptCap: maxSpecRows });
+            const reviewCall = await runWithFallback({ assigned: decision.reviewer, providerFor, unavailableTiers: specUnavailable, isTransportFailure: (r) => isReviewTransportFailure(r), getStatus: (r) => r.status, makeSyntheticFailure: () => makeSkippedReviewResult('all_tiers_unavailable'), call: (provider) => runSpecReview(provider, packet, finalImplReport, fileContents, finalImplResult.toolCalls, task.planContext, evidence.block) });
+            if (reviewCall.bothUnavailable) {
+                emitFallbackUnavailable({ batchId: heartbeatWiring?.batchId ?? '', taskIndex, loop: 'spec', attempt: specAttemptIndex, role: 'specReviewer', assignedTier: decision.reviewer, reason: reviewCall.unavailableReason });
+                fallbackOverrides.push({ role: 'specReviewer', loop: 'spec', attempt: specAttemptIndex, assigned: decision.reviewer, used: reviewCall.usedTier, reason: reviewCall.unavailableReason, triggeringStatus: reviewCall.fallbackTriggeringStatus, bothUnavailable: true });
+                specReviewerHistory.push('skipped');
+            }
+            else {
+                specReviewerHistory.push(reviewCall.usedTier);
+                if (reviewCall.fallbackFired) {
+                    emitFallback({ batchId: heartbeatWiring?.batchId ?? '', taskIndex, loop: 'spec', attempt: specAttemptIndex, role: 'specReviewer', assignedTier: decision.reviewer, usedTier: reviewCall.usedTier, reason: reviewCall.fallbackReason, triggeringStatus: reviewCall.fallbackTriggeringStatus, violatesSeparation: reviewCall.usedTier === implementerHistory[implementerHistory.length - 1] });
+                    fallbackOverrides.push({ role: 'specReviewer', loop: 'spec', attempt: specAttemptIndex, assigned: decision.reviewer, used: reviewCall.usedTier, reason: reviewCall.fallbackReason, triggeringStatus: reviewCall.fallbackTriggeringStatus, bothUnavailable: false });
+                }
+            }
+            specResult = reviewCall.result;
+            specStatus = specResult.status;
+            specReport = 'report' in specResult ? specResult.report : undefined;
+            specReviewReason = specStatus === 'skipped' ? 'all_tiers_unavailable' : ('errorReason' in specResult ? specResult.errorReason : undefined);
+            if (reviewDidNotReject(specStatus))
+                lastNonRejectedImpl = { tier: implementerHistory[implementerHistory.length - 1], result: finalImplResult };
+            specAttemptIndex++;
+            if (specStatus === 'approved' || specStatus === 'skipped')
+                break;
+            const currentFindings = [...(specResult.findings ?? [])].sort().join('\0');
+            const prevFindings = [...prevSpecFindings].sort().join('\0');
+            if (currentFindings === prevFindings && currentFindings !== '')
+                break;
+            prevSpecFindings = [...(specResult.findings ?? [])];
+        }
+        let qualityResult = { status: 'skipped', report: undefined, findings: [], errorReason: reviewPolicy === 'full' ? 'all_tiers_unavailable' : 'skipped: reviewPolicy is spec_only' };
+        if (reviewPolicy === 'full') {
+            qualityUnavailable = new Map();
+            const qualityReviewerTier = pickReviewer({ loop: 'quality', attemptIndex: 0, baseTier: resolved.slot });
+            heartbeat?.transition({ stage: 'quality_review', stageIndex: 4, reviewRound: 1, attemptCap: maxQualityRows });
+            const initialQuality = await runWithFallback({ assigned: qualityReviewerTier, providerFor, unavailableTiers: qualityUnavailable, isTransportFailure: (r) => isReviewTransportFailure(r), getStatus: (r) => r.status, makeSyntheticFailure: () => makeSkippedReviewResult('all_tiers_unavailable'), call: (provider) => runQualityReview(provider, packet, specReport ?? finalImplReport, fileContents, finalImplResult.toolCalls, finalImplResult.filesWritten, evidence.block) });
+            if (initialQuality.bothUnavailable) {
+                emitFallbackUnavailable({ batchId: heartbeatWiring?.batchId ?? '', taskIndex, loop: 'quality', attempt: 0, role: 'qualityReviewer', assignedTier: qualityReviewerTier, reason: initialQuality.unavailableReason });
+                fallbackOverrides.push({ role: 'qualityReviewer', loop: 'quality', attempt: 0, assigned: qualityReviewerTier, used: initialQuality.usedTier, reason: initialQuality.unavailableReason, triggeringStatus: initialQuality.fallbackTriggeringStatus, bothUnavailable: true });
+                qualityReviewerHistory.push('skipped');
+            }
+            else {
+                qualityReviewerHistory.push(initialQuality.usedTier);
+                if (initialQuality.fallbackFired) {
+                    emitFallback({ batchId: heartbeatWiring?.batchId ?? '', taskIndex, loop: 'quality', attempt: 0, role: 'qualityReviewer', assignedTier: qualityReviewerTier, usedTier: initialQuality.usedTier, reason: initialQuality.fallbackReason, triggeringStatus: initialQuality.fallbackTriggeringStatus, violatesSeparation: initialQuality.usedTier === implementerHistory[implementerHistory.length - 1] });
+                    fallbackOverrides.push({ role: 'qualityReviewer', loop: 'quality', attempt: 0, assigned: qualityReviewerTier, used: initialQuality.usedTier, reason: initialQuality.fallbackReason, triggeringStatus: initialQuality.fallbackTriggeringStatus, bothUnavailable: false });
                 }
+            }
+            qualityResult = initialQuality.result;
+            let prevQualityFindings = [...(qualityResult.findings ?? [])];
+            qualityAttemptIndex = 1;
+            while (qualityResult.status === 'changes_required') {
+                if (qualityAttemptIndex >= maxQualityRows)
+                    return abortReviewLoop(finalImplResult, 'round_cap', 'review round cap reached before quality rework', 'quality');
                 const currentCostUSD = taskCostUSD();
                 if (currentCostUSD !== null && maxCostUSD !== undefined && currentCostUSD >= 0.8 * maxCostUSD) {
-                    emitVerbose('cost_check', { stage: 'spec_rework', tripped: true, cost_used_usd: currentCostUSD, cost_cap_usd: maxCostUSD, cost_available: true });
-                    return abortReviewLoop(finalImplResult, 'cost_ceiling', 'cost ceiling reached before spec rework', 'spec');
+                    emitTaskEvent('cost_check', { stage: 'quality_rework', tripped: true, cost_used_usd: currentCostUSD, cost_cap_usd: maxCostUSD, cost_available: true });
+                    return abortReviewLoop(finalImplResult, 'cost_ceiling', 'cost ceiling reached before quality rework', 'quality');
                 }
-                emitVerbose('stage_change', { from: 'spec_review', to: 'spec_rework', round: specRework + 1, cap: maxReviewRounds });
-                specRework++;
-                const round = specRework;
-                heartbeat?.transition({
-                    stage: 'spec_rework', stageIndex: 3,
-                    reviewRound: round, maxReviewRounds,
-                });
-                const feedback = specResult.findings.length > 0
-                    ? `\n\n## Spec Review Feedback (round ${round}):\n${specResult.findings.map(f => `- ${f}`).join('\n')}`
-                    : '';
-                const reworkPrompt = `${task.prompt}${feedback}`;
-                const reworkTask = withDoneCondition({ ...task, prompt: reworkPrompt });
-                const reworkResult = await delegateWithEscalation(reworkTask, [resolved.provider], { explicitlyPinned: true, onProgress: wrappedOnProgress });
-                finalImplResult = reworkResult;
-                const reworkReport = parseStructuredReport(reworkResult.output);
-                finalImplReport = reworkReport.summary ? reworkReport : buildFallbackImplReport(reworkResult);
-                const reworkContents = await readImplementerFileContents(reworkResult.filesWritten, task.cwd);
-                fileContents = reworkContents;
-                heartbeat?.transition({
-                    stage: 'spec_review', stageIndex: 2,
-                    reviewRound: round + 1, maxReviewRounds,
-                });
-                specResult = await runSpecReview(otherProvider, packet, finalImplReport, reworkContents, reworkResult.toolCalls, task.planContext, evidence.block);
-                specStatus = specResult.status;
-                specReport = specResult.report;
-                if (specStatus === 'approved')
+                const decision = pickEscalation({ loop: 'quality', attemptIndex: qualityAttemptIndex, baseTier: resolved.slot });
+                if (decision.isEscalated)
+                    emitEscalationEvent('quality', qualityAttemptIndex, decision);
+                emitTaskEvent('stage_change', { from: 'quality_review', to: 'quality_rework', attempt: qualityAttemptIndex, attemptCap: maxQualityRows, implTier: decision.impl, reviewerTier: decision.reviewer, escalated: decision.isEscalated });
+                heartbeat?.transition({ stage: 'quality_rework', stageIndex: 5, reviewRound: qualityAttemptIndex, attemptCap: maxQualityRows });
+                const feedback = qualityResult.findings.length > 0 ? `\n\n## Quality Review Feedback (round ${qualityAttemptIndex}):\n${qualityResult.findings.map(f => `- ${f}`).join('\n')}` : '';
+                const reworkTask = withDoneCondition({ ...task, prompt: `${task.prompt}${feedback}` });
+                const reworkCall = await runWithFallback({ assigned: decision.impl, providerFor, unavailableTiers: qualityUnavailable, isTransportFailure: (r) => TRANSPORT_FAILURES.has(r.status) && r.capExhausted === undefined, getStatus: (r) => r.status, makeSyntheticFailure: (assigned) => makeSyntheticRunResult(assigned, 'all_tiers_unavailable'), call: (provider) => delegateWithEscalation(reworkTask, [provider], { explicitlyPinned: true, onProgress: wrappedOnProgress }) });
+                if (reworkCall.fallbackFired || reworkCall.bothUnavailable)
+                    fallbackOverrides.push({ role: 'implementer', loop: 'quality', attempt: qualityAttemptIndex, assigned: decision.impl, used: reworkCall.usedTier, reason: (reworkCall.fallbackReason ?? reworkCall.unavailableReason), triggeringStatus: reworkCall.fallbackTriggeringStatus, bothUnavailable: reworkCall.bothUnavailable });
+                if (reworkCall.fallbackFired)
+                    emitFallback({ batchId: heartbeatWiring?.batchId ?? '', taskIndex, loop: 'quality', attempt: qualityAttemptIndex, role: 'implementer', assignedTier: decision.impl, usedTier: reworkCall.usedTier, reason: reworkCall.fallbackReason, triggeringStatus: reworkCall.fallbackTriggeringStatus, violatesSeparation: false });
+                if (reworkCall.bothUnavailable) {
+                    emitFallbackUnavailable({ batchId: heartbeatWiring?.batchId ?? '', taskIndex, loop: 'quality', attempt: qualityAttemptIndex, role: 'implementer', assignedTier: decision.impl, reason: reworkCall.unavailableReason });
+                    if (decision.isEscalated)
+                        emitEscalationUnavailable({ batchId: heartbeatWiring?.batchId ?? '', taskIndex, loop: 'quality', attempt: qualityAttemptIndex, role: 'implementer', wantedTier: decision.impl, reason: reworkCall.unavailableReason });
+                    return adaptForAllTiersUnavailable(reworkCall.result, 'quality', qualityAttemptIndex);
+                }
+                finalImplResult = reworkCall.result;
+                latestAttemptedImpl = { tier: reworkCall.usedTier, result: finalImplResult };
+                implementerHistory.push(reworkCall.usedTier);
+                const reworkReport = parseStructuredReport(finalImplResult.output);
+                finalImplReport = reworkReport.summary ? reworkReport : buildFallbackImplReport(finalImplResult);
+                fileContents = await readImplementerFileContents(finalImplResult.filesWritten, task.cwd);
+                heartbeat?.transition({ stage: 'quality_review', stageIndex: 4, reviewRound: qualityAttemptIndex + 1, attemptCap: maxQualityRows });
+                const reviewCall = await runWithFallback({ assigned: decision.reviewer, providerFor, unavailableTiers: qualityUnavailable, isTransportFailure: (r) => isReviewTransportFailure(r), getStatus: (r) => r.status, makeSyntheticFailure: () => makeSkippedReviewResult('all_tiers_unavailable'), call: (provider) => runQualityReview(provider, packet, finalImplReport, fileContents, finalImplResult.toolCalls, finalImplResult.filesWritten, evidence.block) });
+                if (reviewCall.bothUnavailable) {
+                    emitFallbackUnavailable({ batchId: heartbeatWiring?.batchId ?? '', taskIndex, loop: 'quality', attempt: qualityAttemptIndex, role: 'qualityReviewer', assignedTier: decision.reviewer, reason: reviewCall.unavailableReason });
+                    fallbackOverrides.push({ role: 'qualityReviewer', loop: 'quality', attempt: qualityAttemptIndex, assigned: decision.reviewer, used: reviewCall.usedTier, reason: reviewCall.unavailableReason, triggeringStatus: reviewCall.fallbackTriggeringStatus, bothUnavailable: true });
+                    qualityReviewerHistory.push('skipped');
+                }
+                else {
+                    qualityReviewerHistory.push(reviewCall.usedTier);
+                    if (reviewCall.fallbackFired) {
+                        emitFallback({ batchId: heartbeatWiring?.batchId ?? '', taskIndex, loop: 'quality', attempt: qualityAttemptIndex, role: 'qualityReviewer', assignedTier: decision.reviewer, usedTier: reviewCall.usedTier, reason: reviewCall.fallbackReason, triggeringStatus: reviewCall.fallbackTriggeringStatus, violatesSeparation: reviewCall.usedTier === implementerHistory[implementerHistory.length - 1] });
+                        fallbackOverrides.push({ role: 'qualityReviewer', loop: 'quality', attempt: qualityAttemptIndex, assigned: decision.reviewer, used: reviewCall.usedTier, reason: reviewCall.fallbackReason, triggeringStatus: reviewCall.fallbackTriggeringStatus, bothUnavailable: false });
+                    }
+                }
+                qualityResult = reviewCall.result;
+                if (reviewDidNotReject(qualityResult.status))
+                    lastNonRejectedImpl = { tier: implementerHistory[implementerHistory.length - 1], result: finalImplResult };
+                qualityAttemptIndex++;
+                if (qualityResult.status === 'approved' || qualityResult.status === 'skipped')
                     break;
-                const currentFindings = [...specResult.findings].sort().join('\0');
-                const prevFindings = prevSpecFindings.sort().join('\0');
+                const currentFindings = [...(qualityResult.findings ?? [])].sort().join('\0');
+                const prevFindings = [...prevQualityFindings].sort().join('\0');
                 if (currentFindings === prevFindings && currentFindings !== '')
                     break;
-                prevSpecFindings = specResult.findings;
-            }
-        }
-        let qualityResult = { status: 'skipped', report: undefined, findings: [] };
-        if (reviewPolicy === 'full') {
-            heartbeat?.transition({
-                stage: 'quality_review', stageIndex: 4,
-                reviewRound: 1, maxReviewRounds,
-            });
-            qualityResult = await runQualityReview(otherProvider, packet, specReport ?? finalImplReport, fileContents, finalImplResult.toolCalls, finalImplResult.filesWritten, evidence.block);
-            if (qualityResult.status === 'changes_required') {
-                let prevQualityFindings = [];
-                while (true) {
-                    if (specRework + qualityRework >= maxReviewRounds) {
-                        return abortReviewLoop(finalImplResult, 'round_cap', 'review round cap reached before quality rework', 'quality');
-                    }
-                    const currentCostUSD = taskCostUSD();
-                    if (currentCostUSD !== null && maxCostUSD !== undefined && currentCostUSD >= 0.8 * maxCostUSD) {
-                        emitVerbose('cost_check', { stage: 'quality_rework', tripped: true, cost_used_usd: currentCostUSD, cost_cap_usd: maxCostUSD, cost_available: true });
-                        return abortReviewLoop(finalImplResult, 'cost_ceiling', 'cost ceiling reached before quality rework', 'quality');
-                    }
-                    emitVerbose('stage_change', { from: 'quality_review', to: 'quality_rework', round: qualityRework + 1, cap: maxReviewRounds });
-                    qualityRework++;
-                    const round = qualityRework;
-                    heartbeat?.transition({
-                        stage: 'quality_rework', stageIndex: 5,
-                        reviewRound: round, maxReviewRounds,
-                    });
-                    const feedback = qualityResult.findings.length > 0
-                        ? `\n\n## Quality Review Feedback (round ${round}):\n${qualityResult.findings.map(f => `- ${f}`).join('\n')}`
-                        : '';
-                    const reworkPrompt = `${task.prompt}${feedback}`;
-                    const reworkTask = withDoneCondition({ ...task, prompt: reworkPrompt });
-                    const reworkResult = await delegateWithEscalation(reworkTask, [resolved.provider], { explicitlyPinned: true, onProgress: wrappedOnProgress });
-                    finalImplResult = reworkResult;
-                    const reworkReport = parseStructuredReport(reworkResult.output);
-                    finalImplReport = reworkReport.summary ? reworkReport : buildFallbackImplReport(reworkResult);
-                    const reworkContents = await readImplementerFileContents(reworkResult.filesWritten, task.cwd);
-                    heartbeat?.transition({
-                        stage: 'quality_review', stageIndex: 4,
-                        reviewRound: round + 1, maxReviewRounds,
-                    });
-                    qualityResult = await runQualityReview(otherProvider, packet, finalImplReport, reworkContents, reworkResult.toolCalls, reworkResult.filesWritten, evidence.block);
-                    if (qualityResult.status === 'approved')
-                        break;
-                    const currentFindings = [...qualityResult.findings].sort().join('\0');
-                    const prevFindings = prevQualityFindings.sort().join('\0');
-                    if (currentFindings === prevFindings && currentFindings !== '')
-                        break;
-                    prevQualityFindings = qualityResult.findings;
-                }
+                prevQualityFindings = [...(qualityResult.findings ?? [])];
             }
         }
         const finalReport = specReport ?? finalImplReport;
@@ -788,7 +961,9 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                 message: 'Implementation diff exceeded the reviewer evidence byte cap and was truncated.',
             });
         }
-        const aggregated = aggregateResult(finalReport, specReport, qualityResult.report, specStatus, qualityResult.status);
+        const specAggregateStatus = (['approved', 'changes_required', 'skipped', 'error', 'api_error', 'network_error', 'timeout'].includes(specStatus) ? specStatus : 'error');
+        const qualityAggregateStatus = qualityResult.status;
+        const aggregated = aggregateResult(finalReport, specReport, qualityResult.report, specAggregateStatus, qualityAggregateStatus);
         // File artifact verification: check whether output targets exist on disk after all work.
         // Only applies when status is ok; non-ok statuses skip verification entirely.
         const fileArtifactsMissing = finalImplResult.status === 'ok' && outputTargets.length > 0
@@ -802,25 +977,23 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
             : finalImplResult.status === 'ok' && fileArtifactsMissing
                 ? 'incomplete'
                 : finalImplResult.status;
+        const specEnvelopeStatus = (specStatus === 'api_error' || specStatus === 'network_error' || specStatus === 'timeout' ? 'error' : specStatus);
+        const qualityEnvelopeStatus = qualityResult.status === 'api_error' || qualityResult.status === 'network_error' || qualityResult.status === 'timeout' ? 'error' : qualityResult.status;
         return {
             ...finalImplResult,
             status: finalStatus,
             workerStatus: finalWorkerStatus,
             concerns,
-            specReviewStatus: specStatus,
-            qualityReviewStatus: qualityResult.status,
-            specReviewReason: specResult.errorReason,
-            qualityReviewReason: qualityResult.errorReason,
+            specReviewStatus: specEnvelopeStatus,
+            qualityReviewStatus: qualityEnvelopeStatus,
+            specReviewReason: 'errorReason' in specResult ? specResult.errorReason : undefined,
+            qualityReviewReason: 'errorReason' in qualityResult ? qualityResult.errorReason : undefined,
             structuredReport: aggregated,
             implementationReport: finalImplReport,
             specReviewReport: specReport,
             qualityReviewReport: qualityResult.report,
             filePathsSkipped,
-            agents: {
-                implementer: resolved.slot,
-                specReviewer: otherSlot,
-                qualityReviewer: reviewPolicy === 'full' ? otherSlot : 'skipped',
-            },
+            agents: agentEnvelope(specReviewerHistory[specReviewerHistory.length - 1] ?? 'not_applicable', qualityReviewerHistory[qualityReviewerHistory.length - 1] ?? (reviewPolicy === 'full' ? 'not_applicable' : 'skipped')),
             models: {
                 implementer: implModel,
                 specReviewer: reviewModel,
@@ -832,6 +1005,9 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
             verification,
         };
     }
+    catch (err) {
+        return withVerification(workerErrorResult(err));
+    }
     finally {
         heartbeat?.stop();
     }