@zhixuan92/multi-model-agent-core 3.7.0 → 3.8.1

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

@@ -23,6 +23,9 @@ import { buildFallbackImplReport, readImplementerFileContents } from './fallback
 import { composeVerboseLine, toVerboseFields } from '../diagnostics/verbose-line.js';
 import { withDoneCondition } from './execute-task.js';
 const exec = promisify(execFile);
+const READ_ONLY_TOOL_NAMES = new Set([
+    'audit', 'review', 'verify', 'investigate', 'debug',
+]);
 export function emptyStats() {
     return {
         implementing: { stage: 'implementing', entered: false, durationMs: null, costUSD: null, agentTier: null, modelFamily: null, model: null },
@@ -87,8 +90,13 @@ export function endVerifyStage(stats, t0, c0, agent, finalCostUSD, outcome, skip
         skipReason,
     };
 }
-export async function executeReviewedLifecycle(task, resolved, config, taskIndex, onProgress, heartbeatWiring, diagnostics, recorder, _route, _client, _triggeringSkill, bus) {
+export async function executeReviewedLifecycle(task, resolved, config, taskIndex, onProgress, heartbeatWiring, diagnostics, recorder, _route, _client, _triggeringSkill, bus, qualityReviewPromptBuilder) {
     const reviewPolicy = task.reviewPolicy ?? 'full';
+    const routeKey = _route ?? '';
+    if (reviewPolicy === 'quality_only' && !READ_ONLY_TOOL_NAMES.has(routeKey)) {
+        throw new Error(`reviewPolicy 'quality_only' is only valid for read-only routes; received '${routeKey}'. ` +
+            `Use 'full', 'spec_only', 'diff_only', or 'off' for artifact-producing routes.`);
+    }
     const otherSlot = resolved.slot === 'standard' ? 'complex' : 'standard';
     let escalationProvider;
     try {
@@ -110,7 +118,8 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
     const { outputTargets } = partitionFilePaths(task.filePaths, task.cwd ?? process.cwd());
     const stageCount = reviewPolicy === 'off' ? 1 :
         reviewPolicy === 'spec_only' ? 3 :
-            5;
+            reviewPolicy === 'quality_only' ? 3 :
+                5;
     const verbose = diagnostics?.verbose ?? false;
     const verboseStreamRaw = verbose
         ? (diagnostics?.verboseStream ?? ((line) => { process.stderr.write(line + '\n'); }))
@@ -361,7 +370,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)`,
-            agents: agentEnvelope(specReviewerHistory[specReviewerHistory.length - 1] ?? 'not_applicable', qualityReviewerHistory[qualityReviewerHistory.length - 1] ?? (reviewPolicy === 'full' ? 'not_applicable' : 'skipped')),
+            agents: agentEnvelope(specReviewerHistory[specReviewerHistory.length - 1] ?? 'not_applicable', qualityReviewerHistory[qualityReviewerHistory.length - 1] ?? ((reviewPolicy === 'full' || reviewPolicy === 'quality_only') ? 'not_applicable' : 'skipped')),
             stageStats: stats,
         };
     }
@@ -395,7 +404,7 @@ 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')),
+        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' };
@@ -751,7 +760,7 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
             ? [...(implResult.filesRead ?? []), ...implResult.filesWritten].some(f => task.filePaths.some(fp => f === fp || f.endsWith('/' + fp) || f.endsWith(fp)))
             : true;
         const filePathsSkipped = !filePathsInteracted;
-        if (implResult.filesWritten.length === 0) {
+        if (implResult.filesWritten.length === 0 && reviewPolicy !== 'quality_only') {
             if (reviewPolicy === 'off') {
                 emitTaskEvent('stage_change', { from: 'verifying', to: 'terminal' });
                 const terminal = resolveOffTerminal({
@@ -859,7 +868,7 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
         };
         let fileContents = await readImplementerFileContents(implResult.filesWritten, task.cwd);
         const effectiveImplReport = implReport ?? buildFallbackImplReport(implResult);
-        const evidence = isArtifactProducing
+        const evidence = (isArtifactProducing && reviewPolicy !== 'quality_only')
             ? await buildEvidence({ cwd, baselineHead, commits, verification, reviewPolicy })
             : { block: '', diffTruncated: false, fullDiff: '' };
         if (reviewPolicy === 'diff_only') {
@@ -917,116 +926,126 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
         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 specReviewT0 = Date.now();
-        const specReviewC0 = runningCostUSD();
-        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, taskDeadlineMs, abortSignal: stallController.signal, assignedTier: decision.impl }) });
-            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 __recordOnce(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 });
+        let specReviewT0 = 0;
+        let specReviewC0 = null;
+        if (reviewPolicy !== 'quality_only') {
+            heartbeat?.transition({ stage: 'spec_review', stageIndex: 2, reviewRound: 1, attemptCap: maxSpecRows });
+            const initialReviewerTier = pickReviewer({ loop: 'spec', attemptIndex: 0, baseTier: resolved.slot });
+            specReviewT0 = Date.now();
+            specReviewC0 = runningCostUSD();
+            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(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 });
+                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 = reviewCall.result;
+            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);
-            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 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, taskDeadlineMs, abortSignal: stallController.signal, assignedTier: decision.impl }) });
+                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 __recordOnce(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 ?? [])];
+            }
+        }
+        else {
+            specResult = { status: 'skipped', report: undefined, findings: [], reason: 'all_tiers_unavailable' };
+            specStatus = 'not_applicable';
+            specReport = undefined;
+            specReviewReason = 'skipped: reviewPolicy is quality_only';
         }
-        let qualityResult = { status: 'skipped', report: undefined, findings: [], errorReason: reviewPolicy === 'full' ? 'all_tiers_unavailable' : 'skipped: reviewPolicy is spec_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;
-        if (reviewPolicy === 'full') {
+        if (reviewPolicy === 'full' || reviewPolicy === 'quality_only') {
             qualityUnavailable = new Map();
             const qualityReviewerTier = pickReviewer({ loop: 'quality', attemptIndex: 0, baseTier: resolved.slot });
             heartbeat?.transition({ stage: 'quality_review', stageIndex: 4, reviewRound: 1, attemptCap: maxQualityRows });
             qualityReviewT0 = Date.now();
             qualityReviewC0 = runningCostUSD();
-            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) });
+            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, qualityReviewPromptBuilder, finalImplResult.output) });
             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 });
@@ -1040,65 +1059,92 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                 }
             }
             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) {
-                    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');
-                }
-                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, taskDeadlineMs, abortSignal: stallController.signal, assignedTier: decision.impl }) });
-                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 (reviewDidNotReject(qualityResult.status))
+                lastNonRejectedImpl = { tier: implementerHistory[implementerHistory.length - 1], result: finalImplResult };
+            if (reviewPolicy === 'quality_only') {
+                // Annotation model: emit one quality event per pass with severity-correction
+                // and mean-confidence summary fields. Then we are done — no rework loop.
+                const annotated = qualityResult.annotatedFindings ?? [];
+                const severityCorrections = annotated.filter(f => f.reviewerSeverity !== undefined).length;
+                const meanConfidence = annotated.length > 0
+                    ? Math.round((annotated.reduce((s, f) => s + f.reviewerConfidence, 0) / annotated.length) * 100) / 100
+                    : null;
+                emitTaskEvent('read_only_review.quality', {
+                    route: routeKey,
+                    verdict: qualityResult.status === 'annotated' ? 'annotated'
+                        : qualityResult.status === 'skipped' ? 'skipped'
+                            : 'error',
+                    iterationIndex: 1,
+                    findingsReviewed: annotated.length,
+                    findingsFlagged: severityCorrections,
+                    severityCorrections,
+                    meanConfidence,
+                    durationMs: Date.now() - qualityReviewT0,
+                    costUSD: runningCostUSD() !== null && qualityReviewC0 !== null ? runningCostUSD() - qualityReviewC0 : null,
+                });
+            }
+            else {
+                // Artifact-route gating model — keep the rework loop.
+                let prevQualityFindings = [...(qualityResult.findings ?? [])];
+                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) {
+                        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');
+                    }
+                    const decision = pickEscalation({ loop: 'quality', attemptIndex: qualityAttemptIndex, baseTier: resolved.slot });
                     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));
-                }
-                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 });
+                        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, taskDeadlineMs, abortSignal: stallController.signal, assignedTier: decision.impl }) });
+                    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 __recordOnce(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, qualityReviewPromptBuilder, finalImplResult.output) });
+                    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 = [...(qualityResult.findings ?? [])].sort().join('\0');
+                    const prevFindings = [...prevQualityFindings].sort().join('\0');
+                    if (currentFindings === prevFindings && currentFindings !== '')
+                        break;
+                    prevQualityFindings = [...(qualityResult.findings ?? [])];
                 }
-                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 = [...(qualityResult.findings ?? [])].sort().join('\0');
-                const prevFindings = [...prevQualityFindings].sort().join('\0');
-                if (currentFindings === prevFindings && currentFindings !== '')
-                    break;
-                prevQualityFindings = [...(qualityResult.findings ?? [])];
             }
         }
         const finalReport = specReport ?? finalImplReport;
@@ -1120,17 +1166,22 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                 message: 'Implementation diff exceeded the reviewer evidence byte cap and was truncated.',
             });
         }
-        const specAggregateStatus = (['approved', 'changes_required', 'skipped', 'error', 'api_error', 'network_error', 'timeout'].includes(specStatus) ? specStatus : 'error');
-        endReviewStage(stats, 'spec_review', specReviewT0, specReviewC0, implementerAgentInfo, runningCostUSD(), specStatus === 'approved' ? 'approved'
-            : specStatus === 'changes_required' ? 'changes_required'
-                : specStatus === 'skipped' ? 'skipped'
-                    : specStatus === 'not_applicable' ? 'not_applicable'
-                        : 'error', specAttemptIndex - 1);
+        const specAggregateStatus = reviewPolicy === 'quality_only'
+            ? 'skipped'
+            : (['approved', 'changes_required', 'skipped', 'error', 'api_error', 'network_error', 'timeout'].includes(specStatus) ? specStatus : 'error');
+        if (reviewPolicy !== 'quality_only') {
+            endReviewStage(stats, 'spec_review', specReviewT0, specReviewC0, implementerAgentInfo, runningCostUSD(), specStatus === 'approved' ? 'approved'
+                : specStatus === 'changes_required' ? 'changes_required'
+                    : specStatus === 'skipped' ? 'skipped'
+                        : specStatus === 'not_applicable' ? 'not_applicable'
+                            : 'error', specAttemptIndex - 1);
+        }
         const qualityAggregateStatus = qualityResult.status;
         endReviewStage(stats, 'quality_review', qualityReviewT0, qualityReviewC0, implementerAgentInfo, runningCostUSD(), qualityResult.status === 'approved' ? 'approved'
             : qualityResult.status === 'changes_required' ? 'changes_required'
-                : qualityResult.status === 'skipped' ? 'skipped'
-                    : 'error', qualityAttemptIndex - 1);
+                : qualityResult.status === 'annotated' ? 'annotated'
+                    : qualityResult.status === 'skipped' ? 'skipped'
+                        : 'error', qualityAttemptIndex - 1);
         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.
@@ -1155,6 +1206,7 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
             specReviewStatus: specEnvelopeStatus,
             qualityReviewStatus: qualityEnvelopeStatus,
             stageStats: stats,
+            reviewRounds: reviewRounds(),
             specReviewReason: 'errorReason' in specResult ? specResult.errorReason : undefined,
             qualityReviewReason: 'errorReason' in qualityResult ? qualityResult.errorReason : undefined,
             structuredReport: aggregated,
@@ -1162,21 +1214,41 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
             specReviewReport: specReport,
             qualityReviewReport: qualityResult.report,
             filePathsSkipped,
-            agents: agentEnvelope(specReviewerHistory[specReviewerHistory.length - 1] ?? 'not_applicable', qualityReviewerHistory[qualityReviewerHistory.length - 1] ?? (reviewPolicy === 'full' ? 'not_applicable' : 'skipped')),
+            agents: agentEnvelope(specReviewerHistory[specReviewerHistory.length - 1] ?? 'not_applicable', qualityReviewerHistory[qualityReviewerHistory.length - 1] ?? ((reviewPolicy === 'full' || reviewPolicy === 'quality_only') ? 'not_applicable' : 'skipped')),
             models: {
                 implementer: implModel,
-                specReviewer: reviewModel,
-                qualityReviewer: reviewPolicy === 'full' ? reviewModel : null,
+                specReviewer: reviewPolicy !== 'quality_only' ? reviewModel : null,
+                qualityReviewer: (reviewPolicy === 'full' || reviewPolicy === 'quality_only') ? reviewModel : null,
             },
             fileArtifactsMissing,
             commits,
             commitError,
             verification,
         };
+        if (reviewPolicy === 'quality_only') {
+            emitTaskEvent('read_only_review.terminal', {
+                route: routeKey,
+                roundsUsed: qualityAttemptIndex,
+                finalQualityVerdict: qualityResult.status === 'annotated' ? 'annotated'
+                    : qualityResult.status === 'skipped' ? 'skipped'
+                        : 'error',
+                costUSD: taskCostUSD(),
+                durationMs: Date.now() - taskStartMs,
+            });
+        }
         return __recordOnce(runResult);
     }
     catch (err) {
         const errorRunResult = withVerification(workerErrorResult(err));
+        if (reviewPolicy === 'quality_only') {
+            emitTaskEvent('read_only_review.terminal', {
+                route: routeKey,
+                roundsUsed: qualityAttemptIndex,
+                finalQualityVerdict: 'error',
+                costUSD: taskCostUSD(),
+                durationMs: Date.now() - taskStartMs,
+            });
+        }
         return __recordOnce(errorRunResult);
     }
     finally {