@zhixuan92/multi-model-agent-core 3.12.0 → 3.12.2

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

@@ -1,6 +1,5 @@
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
-import { computeCostUSD } from '../types.js';
 import { createProvider } from '../provider.js';
 import { delegateWithEscalation } from '../delegate-with-escalation.js';
 import { pickEscalation, pickReviewer, maxRowsFor, } from '../escalation/policy.js';
@@ -9,6 +8,7 @@ import { findModelCapabilities, findModelProfile } from '../routing/model-profil
 import { canonicalIdentity } from '../routing/canonical-model-identity.js';
 import { HeartbeatTimer } from '../heartbeat.js';
 import { newStageIdleTracker, snapshotIdle } from './stage-idle-tracker.js';
+import { priceTokens, subtractTokens, resolveRateCard } from '../cost/compute.js';
 import { DEFAULT_TASK_TIMEOUT_MS, DEFAULT_STALL_TIMEOUT_MS, MAX_TIME_PRESTOP_RATIO } from '../config/schema.js';
 import { runSpecReview } from '../review/spec-reviewer.js';
 import { makeSkippedReviewResult } from '../review/skipped-result.js';
@@ -33,14 +33,14 @@ const READ_ONLY_TOOL_NAMES = new Set([
 const _emptyMetrics = { inputTokens: null, outputTokens: null, cachedTokens: null, reasoningTokens: null, turnCount: null, toolCallCount: null, filesReadCount: null, filesWrittenCount: null };
 export function emptyStats() {
     return {
-        implementing: { stage: 'implementing', entered: false, durationMs: null, costUSD: null, agentTier: null, modelFamily: null, model: null, maxIdleMs: null, totalIdleMs: null, activityEvents: null, ..._emptyMetrics },
-        spec_rework: { stage: 'spec_rework', entered: false, durationMs: null, costUSD: null, agentTier: null, modelFamily: null, model: null, maxIdleMs: null, totalIdleMs: null, activityEvents: null, ..._emptyMetrics },
-        quality_rework: { stage: 'quality_rework', entered: false, durationMs: null, costUSD: null, agentTier: null, modelFamily: null, model: null, maxIdleMs: null, totalIdleMs: null, activityEvents: null, ..._emptyMetrics },
-        committing: { stage: 'committing', entered: false, durationMs: null, costUSD: null, agentTier: null, modelFamily: null, model: null, maxIdleMs: null, totalIdleMs: null, activityEvents: null, ..._emptyMetrics },
-        verifying: { stage: 'verifying', entered: false, durationMs: null, costUSD: null, agentTier: null, modelFamily: null, model: null, maxIdleMs: null, totalIdleMs: null, activityEvents: null, outcome: null, skipReason: null, ..._emptyMetrics },
-        spec_review: { stage: 'spec_review', entered: false, durationMs: null, costUSD: null, agentTier: null, modelFamily: null, model: null, maxIdleMs: null, totalIdleMs: null, activityEvents: null, verdict: null, roundsUsed: null, ..._emptyMetrics },
-        quality_review: { stage: 'quality_review', entered: false, durationMs: null, costUSD: null, agentTier: null, modelFamily: null, model: null, maxIdleMs: null, totalIdleMs: null, activityEvents: null, verdict: null, roundsUsed: null, ..._emptyMetrics },
-        diff_review: { stage: 'diff_review', entered: false, durationMs: null, costUSD: null, agentTier: null, modelFamily: null, model: null, maxIdleMs: null, totalIdleMs: null, activityEvents: null, verdict: null, roundsUsed: null, ..._emptyMetrics },
+        implementing: { stage: 'implementing', entered: false, durationMs: null, costUSD: null, agentTier: null, modelFamily: null, model: null, maxIdleMs: 0, totalIdleMs: 0, activityEvents: 0, ..._emptyMetrics },
+        spec_rework: { stage: 'spec_rework', entered: false, durationMs: null, costUSD: null, agentTier: null, modelFamily: null, model: null, maxIdleMs: 0, totalIdleMs: 0, activityEvents: 0, ..._emptyMetrics },
+        quality_rework: { stage: 'quality_rework', entered: false, durationMs: null, costUSD: null, agentTier: null, modelFamily: null, model: null, maxIdleMs: 0, totalIdleMs: 0, activityEvents: 0, ..._emptyMetrics },
+        committing: { stage: 'committing', entered: false, durationMs: null, costUSD: null, agentTier: null, modelFamily: null, model: null, maxIdleMs: 0, totalIdleMs: 0, activityEvents: 0, ..._emptyMetrics },
+        verifying: { stage: 'verifying', entered: false, durationMs: null, costUSD: null, agentTier: null, modelFamily: null, model: null, maxIdleMs: 0, totalIdleMs: 0, activityEvents: 0, outcome: null, skipReason: null, ..._emptyMetrics },
+        spec_review: { stage: 'spec_review', entered: false, durationMs: null, costUSD: null, agentTier: null, modelFamily: null, model: null, maxIdleMs: 0, totalIdleMs: 0, activityEvents: 0, verdict: null, roundsUsed: null, ..._emptyMetrics },
+        quality_review: { stage: 'quality_review', entered: false, durationMs: null, costUSD: null, agentTier: null, modelFamily: null, model: null, maxIdleMs: 0, totalIdleMs: 0, activityEvents: 0, verdict: null, roundsUsed: null, ..._emptyMetrics },
+        diff_review: { stage: 'diff_review', entered: false, durationMs: null, costUSD: null, agentTier: null, modelFamily: null, model: null, maxIdleMs: 0, totalIdleMs: 0, activityEvents: 0, verdict: null, roundsUsed: null, ..._emptyMetrics },
     };
 }
 function modelFamily(model) {
@@ -59,9 +59,9 @@ export function endBaseStage(stats, name, t0, c0, agent, finalCostUSD, idle, met
         agentTier: agent.tier,
         modelFamily: modelFamily(agent.model),
         model: agent.model,
-        maxIdleMs: idle?.maxIdleMs ?? null,
-        totalIdleMs: idle?.totalIdleMs ?? null,
-        activityEvents: idle?.activityEvents ?? null,
+        maxIdleMs: idle?.maxIdleMs ?? 0,
+        totalIdleMs: idle?.totalIdleMs ?? 0,
+        activityEvents: idle?.activityEvents ?? 0,
         inputTokens: metrics?.inputTokens ?? null,
         outputTokens: metrics?.outputTokens ?? null,
         cachedTokens: metrics?.cachedTokens ?? null,
@@ -83,14 +83,17 @@ metrics) {
         stage: name,
         entered: true,
         durationMs: metrics?.durationMs !== undefined ? metrics.durationMs : Date.now() - t0,
-        costUSD: metrics?.costUSD !== undefined ? metrics.costUSD
+        // Item 7: != null (covers both undefined AND null) — null means
+        // "pricing unavailable, fall through to runningCostUSD computation"
+        // rather than masking unknown as the literal 0.
+        costUSD: metrics?.costUSD != null ? metrics.costUSD
             : finalCostUSD !== null && c0 !== null ? finalCostUSD - c0 : null,
         agentTier: agent.tier,
         modelFamily: modelFamily(agent.model),
         model: agent.model,
-        maxIdleMs: idle?.maxIdleMs ?? null,
-        totalIdleMs: idle?.totalIdleMs ?? null,
-        activityEvents: idle?.activityEvents ?? null,
+        maxIdleMs: idle?.maxIdleMs ?? 0,
+        totalIdleMs: idle?.totalIdleMs ?? 0,
+        activityEvents: idle?.activityEvents ?? 0,
         inputTokens: metrics?.inputTokens ?? null,
         outputTokens: metrics?.outputTokens ?? null,
         cachedTokens: metrics?.cachedTokens ?? null,
@@ -164,9 +167,9 @@ export function endVerifyStage(stats, t0, c0, agent, finalCostUSD, idle, outcome
         agentTier: agent.tier,
         modelFamily: modelFamily(agent.model),
         model: agent.model,
-        maxIdleMs: idle?.maxIdleMs ?? null,
-        totalIdleMs: idle?.totalIdleMs ?? null,
-        activityEvents: idle?.activityEvents ?? null,
+        maxIdleMs: idle?.maxIdleMs ?? 0,
+        totalIdleMs: idle?.totalIdleMs ?? 0,
+        activityEvents: idle?.activityEvents ?? 0,
         inputTokens: null,
         outputTokens: null,
         cachedTokens: null,
@@ -448,10 +451,32 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
         if (event.kind === 'turn_complete') {
             heartbeat?.markEvent('llm');
             const providerConfig = _activeRunnerProviderConfig ?? resolved.provider.config;
-            const costUSD = computeCostUSD(event.cumulativeInputTokens, event.cumulativeOutputTokens, providerConfig);
-            _currentRunnerCostUSD = costUSD ?? 0;
+            // §3.5 point 2: per-turn delta tracking from cumulative usage
+            const cur = {
+                inputTokens: event.cumulativeInputTokens,
+                outputTokens: event.cumulativeOutputTokens,
+                cachedReadTokens: event.cumulativeCachedReadTokens ?? 0,
+                cachedCreationTokens: event.cumulativeCachedCreationTokens ?? 0,
+                reasoningTokens: event.cumulativeReasoningTokens ?? 0,
+            };
+            const turnTokens = subtractTokens(cur, _lastCumulative);
+            _lastCumulative = cur;
+            const card = resolveRateCard(providerConfig.model, {
+                ...(providerConfig.inputCostPerMTok !== undefined && { inputCostPerMTok: providerConfig.inputCostPerMTok }),
+                ...(providerConfig.outputCostPerMTok !== undefined && { outputCostPerMTok: providerConfig.outputCostPerMTok }),
+            });
+            const turnCost = card ? priceTokens(turnTokens, card) : null;
+            if (turnCost !== null) {
+                _currentRunnerCostUSD = (_currentRunnerCostUSD ?? 0) + turnCost;
+            }
+            else {
+                _rateCardUnresolved = true;
+            }
             const cumulativeCostUSD = (_completedRunnerCostUSD ?? 0) + _currentRunnerCostUSD;
             heartbeat?.updateCost(cumulativeCostUSD, null);
+            if (_rateCardUnresolved) {
+                heartbeat?.markRateCardUnresolved();
+            }
             const nowTurn = Date.now();
             const turnDurMs = nowTurn - prevEventAtMs;
             prevEventAtMs = nowTurn;
@@ -459,7 +484,7 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                 emitTaskEvent('turn_complete', {
                     input_tokens: event.cumulativeInputTokens,
                     output_tokens: event.cumulativeOutputTokens,
-                    cost: costUSD,
+                    cost: turnCost,
                     duration_ms: turnDurMs,
                     provider: providerConfig.model,
                 });
@@ -514,6 +539,24 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
     const fallbackOverrides = [];
     let latestAttemptedImpl;
     let lastNonRejectedImpl;
+    // Review-stage timing variables hoisted so deferred-finalizer closures
+    // (defined below) can reference them from all early-exit paths.
+    let specReviewT0 = 0;
+    let specReviewC0 = null;
+    let specReviewDurationMs = 0;
+    let qualityReviewT0 = 0;
+    let qualityReviewC0 = null;
+    let qualityReviewDurationMs = 0;
+    // Accumulated metrics from spec/quality review results — threaded to
+    // the deferred finalizers so early-exit paths carry the same token/turn
+    // counts the normal post-loop path always had.
+    let specReviewMetrics = {};
+    let qualityReviewMetrics = {};
+    // Hoisted so deferred-finalizer closures (defined below) can reference
+    // these from all early-exit paths. Reassigned after the corresponding
+    // review stage runs.
+    let specStatus = 'error';
+    let qualityResult = { status: 'skipped', report: undefined, findings: [], errorReason: (reviewPolicy === 'full' || reviewPolicy === 'quality_only') ? 'all_tiers_unavailable' : 'skipped: reviewPolicy is spec_only' };
     const reviewRounds = () => ({ spec: specAttemptIndex, quality: qualityAttemptIndex, metadata: metadataRepair, cap: Math.max(maxSpecRows, maxQualityRows) });
     const taskCostUSD = () => (heartbeat ? heartbeat.getHeartbeatTickInfo().costUSD : null);
     // Per-stage stats tracking
@@ -535,6 +578,46 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
         const model = provider?.config.model ?? config.agents[tier]?.model ?? resolvedModel;
         return { tier, family: modelFamily(model), model };
     };
+    // Deferred finalizers for spec_review and quality_review. Called from
+    // the normal post-loop path AND from every early-exit path
+    // (round_cap, cost_ceiling, time_ceiling, all_tiers_unavailable).
+    // Idempotent on re-call; no-op when the stage was never started.
+    let specReviewFinalized = false;
+    let qualityReviewFinalized = false;
+    const finalizeSpecReviewStage = () => {
+        if (specReviewFinalized)
+            return;
+        if (specReviewT0 === 0)
+            return; // never started
+        specReviewFinalized = true;
+        const lastReviewer = specReviewerHistory[specReviewerHistory.length - 1];
+        const reviewerAgent = (lastReviewer === undefined || lastReviewer === 'skipped')
+            ? implementerAgentInfo
+            : reviewerAgentInfoFor(lastReviewer);
+        endReviewStage(stats, 'spec_review', specReviewT0, specReviewC0, reviewerAgent, runningCostUSD(), snapshotIdle(stageIdle), specStatus === 'approved' ? 'approved'
+            : specStatus === 'changes_required' ? 'changes_required'
+                : specStatus === 'skipped' ? 'skipped'
+                    : specStatus === 'not_applicable' ? 'not_applicable'
+                        : 'error', specAttemptIndex, { ...specReviewMetrics, durationMs: specReviewDurationMs });
+    };
+    const finalizeQualityReviewStage = () => {
+        if (qualityReviewFinalized)
+            return;
+        if (qualityReviewT0 === 0)
+            return;
+        if (reviewPolicy !== 'full' && reviewPolicy !== 'quality_only')
+            return;
+        qualityReviewFinalized = true;
+        const lastReviewer = qualityReviewerHistory[qualityReviewerHistory.length - 1];
+        const reviewerAgent = (lastReviewer === undefined || lastReviewer === 'skipped')
+            ? implementerAgentInfo
+            : reviewerAgentInfoFor(lastReviewer);
+        endReviewStage(stats, 'quality_review', qualityReviewT0, qualityReviewC0, reviewerAgent, runningCostUSD(), snapshotIdle(stageIdle), qualityResult.status === 'approved' ? 'approved'
+            : qualityResult.status === 'changes_required' ? 'changes_required'
+                : qualityResult.status === 'annotated' ? 'annotated'
+                    : qualityResult.status === 'skipped' ? 'skipped'
+                        : 'error', qualityAttemptIndex, { ...qualityReviewMetrics, durationMs: qualityReviewDurationMs });
+    };
     // §3.9: runningCostUSD must be cumulative and monotonic across explicit
     // runner boundaries. Runner progress reports per-runner cumulative token
     // counts, so lifecycle cost is completed runners + current runner partial.
@@ -545,6 +628,13 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
     let _currentRunnerCostUSD = 0;
     let _activeRunnerProviderConfig = null;
     let _prevRunningCost = null;
+    // Per-turn delta tracking state (§3.5 point 2). Reset at each
+    // provider.run() boundary via `runAccounted`.
+    let _lastCumulative = {
+        inputTokens: 0, outputTokens: 0,
+        cachedReadTokens: 0, cachedCreationTokens: 0, reasoningTokens: 0,
+    };
+    let _rateCardUnresolved = false;
     const runningCostUSD = () => {
         const current = _completedRunnerCostUSD !== null || _currentRunnerCostUSD !== 0
             ? (_completedRunnerCostUSD ?? 0) + _currentRunnerCostUSD
@@ -563,6 +653,11 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
         }
         _activeRunnerProviderConfig = provider.config;
         _currentRunnerCostUSD = 0;
+        _lastCumulative = {
+            inputTokens: 0, outputTokens: 0,
+            cachedReadTokens: 0, cachedCreationTokens: 0, reasoningTokens: 0,
+        };
+        _rateCardUnresolved = false;
         try {
             const result = await call();
             const actualCost = result?.usage?.costUSD
@@ -599,7 +694,7 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
     // 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, resolvedModel, salvageSource) {
+    function adaptForAllTiersUnavailable(base, loop, attempt, resolvedModel, salvageSource, unavailableReason) {
         const stageName = loop === 'spec' && attempt === 0 ? 'implementing'
             : loop === 'spec' ? 'spec_rework'
                 : 'quality_rework';
@@ -623,9 +718,9 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                 agentTier: implementerAgentInfo.tier,
                 modelFamily: modelFamily(implementerAgentInfo.model),
                 model: implementerAgentInfo.model,
-                maxIdleMs: null,
-                totalIdleMs: null,
-                activityEvents: null,
+                maxIdleMs: 0,
+                totalIdleMs: 0,
+                activityEvents: 0,
                 inputTokens: salvageSource?.usage?.inputTokens ?? null,
                 outputTokens: salvageSource?.usage?.outputTokens ?? null,
                 cachedTokens: salvageSource?.usage?.cachedTokens ?? null,
@@ -636,6 +731,8 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                 filesWrittenCount: (salvageSource?.filesWritten?.length) || null,
             };
         }
+        finalizeSpecReviewStage();
+        finalizeQualityReviewStage();
         const ship = salvageSource ?? lastNonRejectedImpl?.result ?? base;
         return {
             ...ship,
@@ -644,6 +741,7 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
             terminationReason: 'all_tiers_unavailable',
             reviewRounds: reviewRounds(),
             error: `runWithFallback: both tiers unavailable (loop=${loop}, attempt=${attempt}, role=implementer)`,
+            errorCode: unavailableReason === 'reviewer_separation_unsatisfiable' ? 'reviewer_separation_unsatisfiable' : ship.errorCode,
             agents: agentEnvelope(specReviewerHistory[specReviewerHistory.length - 1] ?? 'not_applicable', qualityReviewerHistory[qualityReviewerHistory.length - 1] ?? ((reviewPolicy === 'full' || reviewPolicy === 'quality_only') ? 'not_applicable' : 'skipped')),
             stageStats: stats,
             models: {
@@ -676,28 +774,32 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
             ...(fallbackOverrides.length > 0 ? { fallbackOverrides } : {}),
         };
     };
-    const abortReviewLoop = (base, terminationReason, message, aborting, wallClockMs) => ({
-        ...base,
-        status: 'incomplete',
-        workerStatus: 'review_loop_aborted',
-        terminationReason: terminationReason === 'round_cap'
-            ? 'round_cap'
-            : {
-                cause: terminationReason === 'cost_ceiling' ? 'cost_exceeded' : 'time_ceiling',
-                turnsUsed: base.turns,
-                hasFileArtifacts: (base.filesWritten ?? []).length > 0,
-                usedShell: (base.toolCalls ?? []).some(c => c.startsWith('shell') || c.startsWith('runShell')),
-                workerSelfAssessment: 'review_loop_aborted',
-                wasPromoted: false,
-                ...(wallClockMs !== undefined ? { wallClockMs } : {}),
-            },
-        reviewRounds: reviewRounds(),
-        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' || reviewPolicy === 'quality_only') ? 'not_applicable' : 'skipped')),
-        stageStats: stats,
-    });
+    const abortReviewLoop = (base, terminationReason, message, aborting, wallClockMs) => {
+        finalizeSpecReviewStage();
+        finalizeQualityReviewStage();
+        return {
+            ...base,
+            status: 'incomplete',
+            workerStatus: 'review_loop_aborted',
+            terminationReason: terminationReason === 'round_cap'
+                ? 'round_cap'
+                : {
+                    cause: terminationReason === 'cost_ceiling' ? 'cost_exceeded' : 'time_ceiling',
+                    turnsUsed: base.turns,
+                    hasFileArtifacts: (base.filesWritten ?? []).length > 0,
+                    usedShell: (base.toolCalls ?? []).some(c => c.startsWith('shell') || c.startsWith('runShell')),
+                    workerSelfAssessment: 'review_loop_aborted',
+                    wasPromoted: false,
+                    ...(wallClockMs !== undefined ? { wallClockMs } : {}),
+                },
+            reviewRounds: reviewRounds(),
+            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' || reviewPolicy === 'quality_only') ? 'not_applicable' : 'skipped')),
+            stageStats: stats,
+        };
+    };
     const defaultVerification = { status: 'skipped', steps: [], totalDurationMs: 0, skipReason: 'no_command' };
     let latestVerification = defaultVerification;
     async function runVerificationStage() {
@@ -763,6 +865,11 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
             structuredError: { code: 'runner_crash', message: workerError.message },
             workerStatus: 'failed',
             workerError,
+            models: {
+                implementer: implModel,
+                specReviewer: null,
+                qualityReviewer: null,
+            },
         });
     }
     function withVerification(result, verification = latestVerification) {
@@ -820,6 +927,17 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
             stageStats: stats,
         }, verification);
     }
+    function diffReviewErrorTerminationReason(base) {
+        return {
+            cause: 'error',
+            turnsUsed: base.turns,
+            hasFileArtifacts: (base.filesWritten ?? []).length > 0,
+            usedShell: (base.toolCalls ?? []).some(c => c.startsWith('shell') || c.startsWith('runShell')),
+            workerSelfAssessment: 'failed',
+            wasPromoted: false,
+            ...(base.terminationReason && typeof base.terminationReason === 'object' && base.terminationReason.wallClockMs !== undefined ? { wallClockMs: base.terminationReason.wallClockMs } : {}),
+        };
+    }
     function resolveDiffOnlyTerminal(base, verdict, verification, diffTruncated) {
         const concerns = [...(base.concerns ?? [])];
         if ('status' in verdict && verdict.status === 'skipped') {
@@ -842,6 +960,7 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                     code: 'diff_review_rejected',
                     message: verdict.message || 'diff review rejected implementation',
                 },
+                terminationReason: diffReviewErrorTerminationReason(base),
                 concerns,
                 commits,
                 commitError,
@@ -854,6 +973,12 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                 status: verdict.status,
                 workerStatus: 'failed',
                 error: verdict.reason ?? `diff review transport failure: ${verdict.status}`,
+                errorCode: verdict.status,
+                structuredError: {
+                    code: verdict.status,
+                    message: verdict.reason ?? `diff review transport failure: ${verdict.status}`,
+                },
+                terminationReason: diffReviewErrorTerminationReason(base),
                 concerns: [...concerns, ...verdict.concerns],
                 commits,
                 commitError,
@@ -927,19 +1052,23 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
         const treeDirty = porcelain.length > 0;
         if (!headMoved && !treeDirty)
             return;
+        // Emit committing stage for both worker-committed (headMoved) and
+        // pending-commit (treeDirty) paths. Workers that auto-commit during
+        // turns leave a clean tree but moved HEAD — they must still produce
+        // a committing stage so telemetry includes filesCommittedCount.
+        transitionStage('verifying', 'committing', { stage: 'committing', stageIndex: 7 }, null);
+        const commitT0 = Date.now();
+        const commitC0 = runningCostUSD();
         if (headMoved)
             await recordWorkerCommits(baselineHead, 'HEAD');
         if (treeDirty) {
             const validCommit = implReport?.commit ?? await repairCommitMetadata(implReport?.commitDiagnostic ?? 'no commit block emitted');
-            if (!validCommit)
-                return;
-            transitionStage('verifying', 'committing', { stage: 'committing', stageIndex: 7 }, null);
-            const commitT0 = Date.now();
-            const commitC0 = runningCostUSD();
-            const c = await runCommitStage({ cwd, filesWritten: implResult.filesWritten, commit: validCommit });
-            commits.push(c);
-            endBaseStage(stats, 'committing', commitT0, commitC0, implementerAgentInfo, runningCostUSD(), snapshotIdle(stageIdle));
+            if (validCommit) {
+                const c = await runCommitStage({ cwd, filesWritten: implResult.filesWritten, commit: validCommit });
+                commits.push(c);
+            }
         }
+        endBaseStage(stats, 'committing', commitT0, commitC0, implementerAgentInfo, runningCostUSD(), snapshotIdle(stageIdle));
     }
     // Tracks the final RunResult across every exit path so the `finally` block
     // below fires `recorder.recordTaskCompleted` exactly once regardless of which
@@ -1037,9 +1166,9 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                 assignedTier: initialDecision.impl,
                 reason: initialImpl.unavailableReason,
             });
-            return __recordOnce(adaptForAllTiersUnavailable(initialImpl.result, 'spec', 0, resolvedModel, initialImpl.salvageResult));
+            return __recordOnce(adaptForAllTiersUnavailable(initialImpl.result, 'spec', 0, resolvedModel, initialImpl.salvageResult, initialImpl.unavailableReason));
         }
-        const implResult = initialImpl.result;
+        let implResult = initialImpl.result;
         latestAttemptedImpl = { tier: initialImpl.usedTier, result: implResult };
         lastNonRejectedImpl = { tier: initialImpl.usedTier, result: implResult };
         implementerHistory.push(initialImpl.usedTier);
@@ -1055,8 +1184,29 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
             costUSD: implResult.usage?.costUSD ?? undefined,
         });
         specAttemptIndex = 1;
-        const implReport = implResult.status === 'ok' ? parseStructuredReport(implResult.output) : undefined;
+        const implReport = parseStructuredReport(implResult.output);
         const workerStatus = extractWorkerStatus(implReport);
+        // Item 9: surface silent-incomplete via errorCode — the delegation layer
+        // cascades result.status as a fallback errorCode (e.g., 'incomplete'),
+        // which is not an informative error code. Replace it when the runner
+        // produced no parseable summary — the operator can now filter on
+        // 'incomplete_no_summary' instead of guessing.
+        //
+        // parseStructuredReport always returns a report object and has a
+        // last-resort fallback that treats the first paragraph as an implicit
+        // summary, so implReport.summary alone is not a reliable signal. Treat
+        // the run as having a structured summary only when a real ## Summary
+        // section exists and parses to non-placeholder content.
+        const hasSummaryHeader = /\n##\s+summary\s*\n/i.test(implResult.output) || /^##\s+summary\s*\n/im.test(implResult.output);
+        const summaryText = (hasSummaryHeader ? implReport.summary : null)?.trim().toLowerCase() ?? '';
+        const hasStructuredSummary = hasSummaryHeader && summaryText !== ''
+            && !['none', '(none)', 'n/a', 'na', 'todo', 'tbd'].includes(summaryText);
+        if (implResult.status === 'incomplete' && !hasStructuredSummary) {
+            const cascadedFallback = implResult.errorCode === implResult.status;
+            if (!implResult.errorCode || cascadedFallback) {
+                implResult = { ...implResult, errorCode: 'incomplete_no_summary' };
+            }
+        }
         if (implResult.status === 'ok' && isArtifactProducing) {
             await captureCommitsAfterImplementation(implResult, implReport, baselineHead);
         }
@@ -1195,6 +1345,7 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                 getStatus: (r) => r.status,
                 makeSyntheticFailure: () => makeSkippedReviewResult('all_tiers_unavailable'),
                 forbiddenIdentities: implementerIdentity ? [implementerIdentity] : undefined,
+                forbiddenTiers: [resolved.slot],
                 call: (provider) => runAccounted(provider, () => runDiffReview({ cwd, diff: evidence.fullDiff, diffTruncated: evidence.diffTruncated, verification, worker: { call: (prompt, opts) => provider.run(prompt, { cwd: opts?.cwd ?? cwd, abortSignal: opts?.abortSignal, timeoutMs: opts?.timeoutMs }) }, taskDeadlineMs, abortSignal: stallController.signal })),
             });
             if (diffCall.fallbackFired) {
@@ -1203,8 +1354,17 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
             }
             if (diffCall.bothUnavailable) {
                 emitFallbackUnavailable({ batchId: heartbeatWiring?.batchId ?? '', taskIndex, loop: 'diff', attempt: 0, role: 'diffReviewer', assignedTier: diffReviewerTier, reason: diffCall.unavailableReason });
+                if (diffCall.unavailableReason === 'reviewer_separation_unsatisfiable') {
+                    return __recordOnce(adaptForAllTiersUnavailable({ ...implResult, errorCode: 'reviewer_separation_unsatisfiable', diffReviewStatus: 'error' }, 'spec', 0, resolvedModel, implResult, diffCall.unavailableReason));
+                }
             }
-            const verdict = diffCall.bothUnavailable || isReviewTransportFailure(diffCall.result) ? makeSkippedReviewResult('all_tiers_unavailable') : diffCall.result;
+            const verdict = diffCall.bothUnavailable ? makeSkippedReviewResult('all_tiers_unavailable') : diffCall.result;
+            const diffEnvelopeStatus = 'kind' in verdict
+                ? (verdict.kind === 'approve' ? 'approved'
+                    : verdict.kind === 'concerns' ? 'approved'
+                        : verdict.kind === 'reject' ? 'changes_required'
+                            : 'error')
+                : 'skipped';
             emitTaskEvent('review_decision', {
                 stage: 'diff_review',
                 verdict: 'kind' in verdict
@@ -1220,7 +1380,7 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
             // distinct from spec/quality verdicts. Map to the telemetry verdict enum here.
             'kind' in verdict
                 ? (verdict.kind === 'approve' ? 'approved'
-                    : verdict.kind === 'concerns' ? 'concerns'
+                    : verdict.kind === 'concerns' ? 'approved'
                         : verdict.kind === 'reject' ? 'changes_required'
                             : 'error')
                 : 'skipped', 0);
@@ -1231,6 +1391,7 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                 qualityReviewStatus: 'skipped',
                 specReviewReason: 'skipped: reviewPolicy is diff_only',
                 qualityReviewReason: 'skipped: reviewPolicy is diff_only',
+                diffReviewStatus: diffEnvelopeStatus,
                 implementationReport: effectiveImplReport,
                 fileArtifactsMissing: implResult.status === 'ok' ? checkOutputTargets(outputTargets) : undefined,
                 agents: agentEnvelope('skipped', 'skipped'),
@@ -1240,19 +1401,8 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
         let finalImplResult = implResult;
         let finalImplReport = effectiveImplReport;
         let specResult;
-        let specStatus;
         let specReport;
         let specReviewReason;
-        let specReviewT0 = 0;
-        let specReviewC0 = null;
-        // Delta-only timing: accumulate per-call wall durations across the
-        // initial spec_review + every spec_rework round's re-review. This
-        // replaces the `Date.now() - specReviewT0` fallback at endReviewStage,
-        // which over-counts because endReviewStage runs AFTER spec_rework,
-        // quality_review, AND quality_rework all complete. No absolute
-        // timestamps go on the wire — Date.now() is used only as a local
-        // delta source. Privacy.md guarantees ms-deltas only.
-        let specReviewDurationMs = 0;
         if (reviewPolicy !== 'quality_only') {
             transitionStage('verifying', 'spec_review', { stage: 'spec_review', stageIndex: 2, reviewRound: 1, attemptCap: maxSpecRows }, null);
             const initialReviewerTier = pickReviewer({ loop: 'spec', attemptIndex: 0, baseTier: resolved.slot });
@@ -1267,6 +1417,7 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                 getStatus: (r) => r.status,
                 makeSyntheticFailure: () => makeSkippedReviewResult('all_tiers_unavailable'),
                 forbiddenIdentities: implementerIdentity ? [implementerIdentity] : undefined,
+                forbiddenTiers: [resolved.slot],
                 call: (provider) => runAccounted(provider, () => runSpecReview(provider, packet, effectiveImplReport, fileContents, implResult.toolCalls, task.planContext, evidence.block, taskDeadlineMs, stallController.signal, wrappedOnProgress, cwd)),
             });
             specReviewDurationMs += Date.now() - initialSpecReviewIterStart;
@@ -1274,6 +1425,15 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                 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');
+                if (initialSpecReview.unavailableReason === 'reviewer_separation_unsatisfiable') {
+                    const unavailableBase = {
+                        ...implResult,
+                        specReviewStatus: 'error',
+                        specReviewReason: 'reviewer separation unsatisfiable',
+                        errorCode: 'reviewer_separation_unsatisfiable',
+                    };
+                    return __recordOnce(adaptForAllTiersUnavailable(unavailableBase, 'spec', 0, resolvedModel, implResult, initialSpecReview.unavailableReason));
+                }
             }
             else {
                 specReviewerHistory.push(initialSpecReview.usedTier);
@@ -1322,7 +1482,7 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                     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 __recordOnce(adaptForAllTiersUnavailable(reworkCall.result, 'spec', specAttemptIndex, resolvedModel, reworkCall.salvageResult));
+                    return __recordOnce(adaptForAllTiersUnavailable(reworkCall.result, 'spec', specAttemptIndex, resolvedModel, reworkCall.salvageResult, reworkCall.unavailableReason));
                 }
                 finalImplResult = reworkCall.result;
                 latestAttemptedImpl = { tier: reworkCall.usedTier, result: finalImplResult };
@@ -1334,12 +1494,21 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                 commitReworkStage(stats, 'spec_rework', specReworkAcc, implementerAgentInfo);
                 transitionStage('spec_rework', 'spec_review', { stage: 'spec_review', stageIndex: 2, reviewRound: specAttemptIndex + 1, attemptCap: maxSpecRows }, null);
                 const reReviewIterStart = Date.now();
-                const reviewCall = await runWithFallback({ assigned: decision.reviewer, providerFor, unavailableTiers: specUnavailable, isTransportFailure: (r) => isReviewTransportFailure(r), getStatus: (r) => r.status, makeSyntheticFailure: () => makeSkippedReviewResult('all_tiers_unavailable'), forbiddenIdentities: implementerIdentity ? [implementerIdentity] : undefined, call: (provider) => runAccounted(provider, () => runSpecReview(provider, packet, finalImplReport, fileContents, finalImplResult.toolCalls, task.planContext, evidence.block, taskDeadlineMs, stallController.signal, wrappedOnProgress, cwd)) });
+                const reviewCall = await runWithFallback({ assigned: decision.reviewer, providerFor, unavailableTiers: specUnavailable, isTransportFailure: (r) => isReviewTransportFailure(r), getStatus: (r) => r.status, makeSyntheticFailure: () => makeSkippedReviewResult('all_tiers_unavailable'), forbiddenIdentities: implementerIdentity ? [implementerIdentity] : undefined, forbiddenTiers: [resolved.slot], call: (provider) => runAccounted(provider, () => runSpecReview(provider, packet, finalImplReport, fileContents, finalImplResult.toolCalls, task.planContext, evidence.block, taskDeadlineMs, stallController.signal, wrappedOnProgress, cwd)) });
                 specReviewDurationMs += Date.now() - reReviewIterStart;
                 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');
+                    if (reviewCall.unavailableReason === 'reviewer_separation_unsatisfiable') {
+                        const unavailableBase = {
+                            ...finalImplResult,
+                            specReviewStatus: 'error',
+                            specReviewReason: 'reviewer separation unsatisfiable',
+                            errorCode: 'reviewer_separation_unsatisfiable',
+                        };
+                        return __recordOnce(adaptForAllTiersUnavailable(unavailableBase, 'spec', specAttemptIndex, resolvedModel, finalImplResult, reviewCall.unavailableReason));
+                    }
                 }
                 else {
                     specReviewerHistory.push(reviewCall.usedTier);
@@ -1370,17 +1539,6 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
             specReport = undefined;
             specReviewReason = 'skipped: reviewPolicy is quality_only';
         }
-        let qualityResult = { status: 'skipped', report: undefined, findings: [], errorReason: (reviewPolicy === 'full' || reviewPolicy === 'quality_only') ? 'all_tiers_unavailable' : 'skipped: reviewPolicy is spec_only' };
-        // Hoisted so endReviewStage (called after this block) can read them on the
-        // success path. When the quality review is skipped (`reviewPolicy !== 'full'`),
-        // the values stay at 0/null and the corresponding stage entry remains in its
-        // `entered: false` default — endReviewStage is never called.
-        let qualityReviewT0 = 0;
-        let qualityReviewC0 = null;
-        // Same delta-only timing pattern as spec_review — accumulate per-call
-        // wall durations across initial + each rework round's re-review. No
-        // raw timestamps cross the wire.
-        let qualityReviewDurationMs = 0;
         if (reviewPolicy === 'full' || reviewPolicy === 'quality_only') {
             qualityUnavailable = new Map();
             const qualityReviewerTier = pickReviewer({ loop: 'quality', attemptIndex: 0, baseTier: resolved.slot });
@@ -1388,12 +1546,21 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
             qualityReviewT0 = Date.now();
             qualityReviewC0 = runningCostUSD();
             const initialQualityIterStart = Date.now();
-            const initialQuality = await runWithFallback({ assigned: qualityReviewerTier, providerFor, unavailableTiers: qualityUnavailable, isTransportFailure: (r) => isReviewTransportFailure(r), getStatus: (r) => r.status, makeSyntheticFailure: () => makeSkippedReviewResult('all_tiers_unavailable'), forbiddenIdentities: implementerIdentity ? [implementerIdentity] : undefined, call: (provider) => runAccounted(provider, () => runQualityReview(provider, packet, specReport ?? finalImplReport, fileContents, finalImplResult.toolCalls, finalImplResult.filesWritten, evidence.block, qualityReviewPromptBuilder, finalImplResult.output, taskDeadlineMs, stallController.signal, wrappedOnProgress, cwd)) });
+            const initialQuality = await runWithFallback({ assigned: qualityReviewerTier, providerFor, unavailableTiers: qualityUnavailable, isTransportFailure: (r) => isReviewTransportFailure(r), getStatus: (r) => r.status, makeSyntheticFailure: () => makeSkippedReviewResult('all_tiers_unavailable'), forbiddenIdentities: implementerIdentity ? [implementerIdentity] : undefined, forbiddenTiers: [resolved.slot], call: (provider) => runAccounted(provider, () => runQualityReview(provider, packet, specReport ?? finalImplReport, fileContents, finalImplResult.toolCalls, finalImplResult.filesWritten, evidence.block, qualityReviewPromptBuilder, finalImplResult.output, taskDeadlineMs, stallController.signal, wrappedOnProgress, cwd)) });
             qualityReviewDurationMs += Date.now() - initialQualityIterStart;
             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');
+                if (initialQuality.unavailableReason === 'reviewer_separation_unsatisfiable') {
+                    const unavailableBase = {
+                        ...finalImplResult,
+                        qualityReviewStatus: 'error',
+                        qualityReviewReason: 'reviewer separation unsatisfiable',
+                        errorCode: 'reviewer_separation_unsatisfiable',
+                    };
+                    return __recordOnce(adaptForAllTiersUnavailable(unavailableBase, 'quality', 0, resolvedModel, finalImplResult, initialQuality.unavailableReason));
+                }
             }
             else {
                 qualityReviewerHistory.push(initialQuality.usedTier);
@@ -1480,7 +1647,7 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                         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 __recordOnce(adaptForAllTiersUnavailable(reworkCall.result, 'quality', qualityAttemptIndex, resolvedModel, reworkCall.salvageResult));
+                        return __recordOnce(adaptForAllTiersUnavailable(reworkCall.result, 'quality', qualityAttemptIndex, resolvedModel, reworkCall.salvageResult, reworkCall.unavailableReason));
                     }
                     finalImplResult = reworkCall.result;
                     latestAttemptedImpl = { tier: reworkCall.usedTier, result: finalImplResult };
@@ -1492,12 +1659,21 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                     commitReworkStage(stats, 'quality_rework', qualityReworkAcc, implementerAgentInfo);
                     transitionStage('quality_rework', 'quality_review', { stage: 'quality_review', stageIndex: 4, reviewRound: qualityAttemptIndex + 1, attemptCap: maxQualityRows }, null);
                     const qReReviewIterStart = Date.now();
-                    const reviewCall = await runWithFallback({ assigned: decision.reviewer, providerFor, unavailableTiers: qualityUnavailable, isTransportFailure: (r) => isReviewTransportFailure(r), getStatus: (r) => r.status, makeSyntheticFailure: () => makeSkippedReviewResult('all_tiers_unavailable'), forbiddenIdentities: implementerIdentity ? [implementerIdentity] : undefined, call: (provider) => runAccounted(provider, () => runQualityReview(provider, packet, finalImplReport, fileContents, finalImplResult.toolCalls, finalImplResult.filesWritten, evidence.block, qualityReviewPromptBuilder, finalImplResult.output, taskDeadlineMs, stallController.signal, wrappedOnProgress, cwd)) });
+                    const reviewCall = await runWithFallback({ assigned: decision.reviewer, providerFor, unavailableTiers: qualityUnavailable, isTransportFailure: (r) => isReviewTransportFailure(r), getStatus: (r) => r.status, makeSyntheticFailure: () => makeSkippedReviewResult('all_tiers_unavailable'), forbiddenIdentities: implementerIdentity ? [implementerIdentity] : undefined, forbiddenTiers: [resolved.slot], call: (provider) => runAccounted(provider, () => runQualityReview(provider, packet, finalImplReport, fileContents, finalImplResult.toolCalls, finalImplResult.filesWritten, evidence.block, qualityReviewPromptBuilder, finalImplResult.output, taskDeadlineMs, stallController.signal, wrappedOnProgress, cwd)) });
                     qualityReviewDurationMs += Date.now() - qReReviewIterStart;
                     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');
+                        if (reviewCall.unavailableReason === 'reviewer_separation_unsatisfiable') {
+                            const unavailableBase = {
+                                ...finalImplResult,
+                                qualityReviewStatus: 'error',
+                                qualityReviewReason: 'reviewer separation unsatisfiable',
+                                errorCode: 'reviewer_separation_unsatisfiable',
+                            };
+                            return __recordOnce(adaptForAllTiersUnavailable(unavailableBase, 'quality', qualityAttemptIndex, resolvedModel, finalImplResult, reviewCall.unavailableReason));
+                        }
                     }
                     else {
                         qualityReviewerHistory.push(reviewCall.usedTier);
@@ -1559,21 +1735,11 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
         // override. endReviewStage uses the override when present and falls
         // back to `Date.now() - t0` otherwise (which over-counts review-block
         // span across rework + later stages).
-        const specMetrics = { ...(specResult.metrics ?? {}), durationMs: specReviewDurationMs };
-        const qualityMetrics = { ...(qualityResult.metrics ?? {}), durationMs: qualityReviewDurationMs };
-        if (reviewPolicy !== 'quality_only') {
-            endReviewStage(stats, 'spec_review', specReviewT0, specReviewC0, specReviewAgent, runningCostUSD(), snapshotIdle(stageIdle), specStatus === 'approved' ? 'approved'
-                : specStatus === 'changes_required' ? 'changes_required'
-                    : specStatus === 'skipped' ? 'skipped'
-                        : specStatus === 'not_applicable' ? 'not_applicable'
-                            : 'error', specAttemptIndex, specMetrics);
-        }
+        specReviewMetrics = (specResult.metrics ?? {});
+        qualityReviewMetrics = (qualityResult.metrics ?? {});
+        finalizeSpecReviewStage();
+        finalizeQualityReviewStage();
         const qualityAggregateStatus = qualityResult.status;
-        endReviewStage(stats, 'quality_review', qualityReviewT0, qualityReviewC0, qualityReviewAgent, runningCostUSD(), snapshotIdle(stageIdle), qualityResult.status === 'approved' ? 'approved'
-            : qualityResult.status === 'changes_required' ? 'changes_required'
-                : qualityResult.status === 'annotated' ? 'annotated'
-                    : qualityResult.status === 'skipped' ? 'skipped'
-                        : 'error', qualityAttemptIndex, qualityMetrics);
         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.
@@ -1655,6 +1821,8 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                     client: _client ?? 'claude-code',
                     triggeringSkill: _triggeringSkill ?? 'direct',
                     parentModel: task.parentModel ?? null,
+                    reviewPolicy,
+                    verifyCommandPresent: !!(task.verifyCommand && task.verifyCommand.length > 0),
                 });
             }
             catch { /* silent */ }