@zhixuan92/multi-model-agent-core 3.6.7 → 3.8.0

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) {
+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,23 +118,22 @@ 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;
-    let lastStageSeen;
     const verboseStreamRaw = verbose
         ? (diagnostics?.verboseStream ?? ((line) => { process.stderr.write(line + '\n'); }))
         : undefined;
     const verboseBatchIdEarly = heartbeatWiring?.batchId;
     const shortBatchEarly = verboseBatchIdEarly ? verboseBatchIdEarly.slice(0, 8) : '????????';
-    const taskEventLogger = diagnostics?.logger;
     const emitTaskEvent = (event, fields) => {
-        if (taskEventLogger && verboseBatchIdEarly !== undefined) {
+        if (bus && verboseBatchIdEarly !== undefined) {
             const cleaned = {};
             for (const [key, value] of Object.entries(fields)) {
                 if (value !== undefined)
                     cleaned[key] = value;
             }
-            taskEventLogger.emit({ event, batchId: verboseBatchIdEarly, taskIndex, ...cleaned });
+            bus.emit({ event, ts: new Date().toISOString(), batchId: verboseBatchIdEarly, taskIndex, ...cleaned });
         }
         if (verboseStreamRaw) {
             verboseStreamRaw(composeVerboseLine({ event, ts: new Date().toISOString(), batch: shortBatchEarly, task: taskIndex, ...toVerboseFields(fields) }));
@@ -141,7 +148,8 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
     const needHeartbeat = onProgress !== undefined ||
         verbose ||
         heartbeatWiring?.recordHeartbeat !== undefined ||
-        diagnostics?.logger !== undefined;
+        diagnostics?.logger !== undefined ||
+        bus !== undefined;
     // Synthesize an onProgress sink when the caller didn't pass one — the
     // heartbeat needs a place to emit heartbeat events so the stage-change
     // detector below fires. Discards events if there is no external consumer.
@@ -149,16 +157,10 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
     const heartbeat = needHeartbeat
         ? new HeartbeatTimer((event) => {
             if (event.kind === 'heartbeat') {
-                // Emit on every heartbeat tick so the operator can confirm
-                // the timer is actually firing. Stage-change lines are richer
-                // but fire only on transitions; plain ticks let you see
-                // per-5s progress inside a long-running stage.
-                if (event.stage !== lastStageSeen) {
-                    if (lastStageSeen !== undefined) {
-                        emitTaskEvent('stage_change', { from: lastStageSeen, to: event.stage });
-                    }
-                    lastStageSeen = event.stage;
-                }
+                // Emit on every heartbeat tick so the operator can confirm the
+                // timer is actually firing. Stage transitions are authoritative
+                // only via explicit emit calls at lifecycle points; the
+                // heartbeat tick no longer infers transitions (P5).
                 const sinceLastMs = Date.now() - prevEventAtMs;
                 emitTaskEvent('heartbeat', {
                     elapsed: event.elapsed,
@@ -205,7 +207,6 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
     const implModel = resolved.provider.config.model;
     const progressCounters = { filesRead: 0, filesWritten: 0, toolCalls: 0 };
     const verboseStream = verboseStreamRaw;
-    emitTaskEvent('worker_start', { worker: resolved.provider.config.model });
     let prevEventAtMs = verbose ? Date.now() : 0;
     // Wrap whenever we have ANY consumer for InternalRunnerEvent (heartbeat,
     // verbose stream, or verbose logger). Previously this only wrapped when
@@ -218,6 +219,13 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
             if (event.kind === 'turn_start' || event.kind === 'text_emission' || event.kind === 'tool_call' || event.kind === 'turn_complete') {
                 markRunnerEvent();
             }
+            if (event.kind === 'worker_start') {
+                emitTaskEvent('worker_start', {
+                    model: event.model,
+                    providerType: event.providerType,
+                    tier: event.tier,
+                });
+            }
             if (event.kind === 'turn_start') {
                 heartbeat?.markEvent('llm');
                 if (verbose)
@@ -333,11 +341,9 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
     const runningCostUSD = () => taskCostUSD();
     const policyEscalated = { spec: false, quality: false, diff: false };
     const emitFallback = (p) => {
-        diagnostics?.logger?.fallback(p);
         emitTaskEvent('fallback', p);
     };
     const emitFallbackUnavailable = (p) => {
-        diagnostics?.logger?.fallbackUnavailable(p);
         emitTaskEvent('fallback_unavailable', p);
     };
     const emitEscalationEvent = (loop, attempt, decision) => {
@@ -345,12 +351,10 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
             batchId: heartbeatWiring?.batchId ?? '', taskIndex, loop, attempt,
             baseTier: resolved.slot, implTier: decision.impl, reviewerTier: decision.reviewer,
         };
-        diagnostics?.logger?.escalation(p);
         emitTaskEvent('escalation', p);
         policyEscalated[loop] = true;
     };
     const emitEscalationUnavailable = (p) => {
-        diagnostics?.logger?.escalationUnavailable(p);
         emitTaskEvent('escalation_unavailable', p);
     };
     // When the review loop aborts mid-flight, preserve any review-status info already set
@@ -366,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,
         };
     }
@@ -400,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' };
@@ -653,9 +657,13 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
     // catch path. Without this, the recorder only fires on 2 of ~5 exit paths.
     let __finalRunResult;
     const __recordOnce = (r) => {
+        // Stamp stallTriggered on every exit path. The watchdog flag is owned
+        // by this scope; surfacing it on the RunResult lets the caller (and
+        // telemetry) distinguish "no progress" aborts from cap exhaustion.
+        const stamped = stallFired ? { ...r, stallTriggered: true } : r;
         if (__finalRunResult === undefined)
-            __finalRunResult = r;
-        return r;
+            __finalRunResult = stamped;
+        return stamped;
     };
     try {
         // The dirty-tree precondition + git baseline only apply to artifact-producing tasks
@@ -699,7 +707,7 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
             isTransportFailure: (r) => TRANSPORT_FAILURES.has(r.status) && r.capExhausted === undefined,
             getStatus: (r) => r.status,
             makeSyntheticFailure: (assigned) => makeSyntheticRunResult(assigned, 'all_tiers_unavailable'),
-            call: (provider) => delegateWithEscalation(withDoneCondition(task), [provider], { explicitlyPinned: false, onProgress: wrappedOnProgress, taskDeadlineMs, abortSignal: stallController.signal }),
+            call: (provider) => delegateWithEscalation(withDoneCondition(task), [provider], { explicitlyPinned: false, onProgress: wrappedOnProgress, taskDeadlineMs, abortSignal: stallController.signal, assignedTier: initialDecision.impl }),
         });
         if (initialImpl.fallbackFired || initialImpl.bothUnavailable) {
             fallbackOverrides.push({
@@ -752,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({
@@ -860,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') {
@@ -918,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 }) });
-            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 });
@@ -1041,6 +1059,20 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                 }
             }
             qualityResult = initialQuality.result;
+            if (reviewPolicy === 'quality_only') {
+                emitTaskEvent('read_only_review.quality', {
+                    route: routeKey,
+                    verdict: qualityResult.status === 'approved' ? 'approved'
+                        : qualityResult.status === 'changes_required' ? 'changes_required'
+                            : qualityResult.status === 'skipped' ? 'skipped'
+                                : 'error',
+                    iterationIndex: 1,
+                    findingsReviewed: qualityResult.findings?.length ?? 0,
+                    findingsFlagged: qualityResult.status === 'changes_required' ? (qualityResult.findings?.length ?? 0) : 0,
+                    durationMs: Date.now() - qualityReviewT0,
+                    costUSD: runningCostUSD() !== null && qualityReviewC0 !== null ? runningCostUSD() - qualityReviewC0 : null,
+                });
+            }
             let prevQualityFindings = [...(qualityResult.findings ?? [])];
             qualityAttemptIndex = 1;
             while (qualityResult.status === 'changes_required') {
@@ -1055,10 +1087,17 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                 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 });
+                if (reviewPolicy === 'quality_only') {
+                    emitTaskEvent('read_only_review.rework', {
+                        route: routeKey,
+                        iterationIndex: qualityAttemptIndex,
+                        triggeringIssues: qualityResult.findings?.length ?? 0,
+                    });
+                }
                 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 }) });
+                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)
@@ -1076,7 +1115,9 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                 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) });
+                const reworkQualityT0 = Date.now();
+                const reworkQualityC0 = runningCostUSD();
+                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 });
@@ -1090,6 +1131,20 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                     }
                 }
                 qualityResult = reviewCall.result;
+                if (reviewPolicy === 'quality_only') {
+                    emitTaskEvent('read_only_review.quality', {
+                        route: routeKey,
+                        verdict: qualityResult.status === 'approved' ? 'approved'
+                            : qualityResult.status === 'changes_required' ? 'changes_required'
+                                : qualityResult.status === 'skipped' ? 'skipped'
+                                    : 'error',
+                        iterationIndex: qualityAttemptIndex + 1,
+                        findingsReviewed: qualityResult.findings?.length ?? 0,
+                        findingsFlagged: qualityResult.status === 'changes_required' ? (qualityResult.findings?.length ?? 0) : 0,
+                        durationMs: Date.now() - reworkQualityT0,
+                        costUSD: runningCostUSD() !== null && reworkQualityC0 !== null ? runningCostUSD() - reworkQualityC0 : null,
+                    });
+                }
                 if (reviewDidNotReject(qualityResult.status))
                     lastNonRejectedImpl = { tier: implementerHistory[implementerHistory.length - 1], result: finalImplResult };
                 qualityAttemptIndex++;
@@ -1121,12 +1176,16 @@ 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'
@@ -1156,6 +1215,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,
@@ -1163,21 +1223,42 @@ 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 === 'approved' ? 'approved'
+                    : qualityResult.status === 'changes_required' ? 'changes_required'
+                        : 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 {