@zhixuan92/multi-model-agent-core 3.2.0 → 3.4.0

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

@@ -1,16 +1,24 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
 import { computeCostUSD, computeSavedCostUSD } from '../types.js';
 import { createProvider } from '../provider.js';
 import { delegateWithEscalation } from '../delegate-with-escalation.js';
 import { HeartbeatTimer } from '../heartbeat.js';
 import { runSpecReview } from '../review/spec-reviewer.js';
 import { runQualityReview } from '../review/quality-reviewer.js';
+import { runDiffReview } from '../review/diff-review.js';
 import { aggregateResult } from '../review/aggregate-result.js';
+import { buildEvidence } from '../review/evidence.js';
 import { parseStructuredReport } from '../reporting/structured-report.js';
-import { autoCommitFiles } from '../auto-commit.js';
+import { runCommitStage, readbackCommit } from './commit-stage.js';
+import { runVerifyStage } from './verify-stage.js';
+import { runMetadataRepairTurn } from './metadata-repair.js';
 import { partitionFilePaths, checkOutputTargets } from '../file-artifact-check.js';
 import { extractWorkerStatus } from './worker-status.js';
 import { buildFallbackImplReport, readImplementerFileContents } from './fallback-report.js';
+import { composeVerboseLine } from '../diagnostics/verbose-line.js';
 import { withDoneCondition } from './execute-task.js';
+const exec = promisify(execFile);
 export async function executeReviewedLifecycle(task, resolved, config, taskIndex, onProgress, heartbeatWiring, diagnostics) {
     const reviewPolicy = task.reviewPolicy ?? 'full';
     const otherSlot = resolved.slot === 'standard' ? 'complex' : 'standard';
@@ -34,6 +42,20 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
         : undefined;
     const verboseBatchIdEarly = heartbeatWiring?.batchId;
     const shortBatchEarly = verboseBatchIdEarly ? verboseBatchIdEarly.slice(0, 8) : '????????';
+    const taskEventLogger = diagnostics?.logger;
+    const emitTaskEvent = (event, fields) => {
+        if (taskEventLogger && verboseBatchIdEarly !== undefined) {
+            const cleaned = {};
+            for (const [key, value] of Object.entries(fields)) {
+                if (value !== undefined)
+                    cleaned[key] = value;
+            }
+            taskEventLogger.emit({ event, batchId: verboseBatchIdEarly, taskIndex, ...cleaned });
+        }
+        if (verboseStreamRaw) {
+            verboseStreamRaw(composeVerboseLine({ event, ts: new Date().toISOString(), batch: shortBatchEarly, task: taskIndex, ...fields }));
+        }
+    };
     // Start the heartbeat whenever there's a downstream consumer:
     // - onProgress (external progress callback from the runTasks caller)
     // - verbose (stderr stream needs the heartbeat's tool_call / turn_complete relay)
@@ -50,23 +72,30 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
     const synthOnProgress = onProgress ?? (() => { });
     const heartbeat = needHeartbeat
         ? new HeartbeatTimer((event) => {
-            if (verboseStreamRaw && event.kind === 'heartbeat') {
+            if (event.kind === 'heartbeat') {
                 // Emit on every heartbeat tick so the operator can confirm
                 // the timer is actually firing. Stage-change lines are richer
                 // but fire only on transitions; plain ticks let you see
                 // per-5s progress inside a long-running stage.
                 if (event.stage !== lastStageSeen) {
                     if (lastStageSeen !== undefined) {
-                        verboseStreamRaw(`[mmagent verbose] batch=${shortBatchEarly} task=${taskIndex} stage ${lastStageSeen} → ${event.stage}`);
+                        emitTaskEvent('stage_change', { from: lastStageSeen, to: event.stage });
                     }
                     lastStageSeen = event.stage;
                 }
-                const costStr = event.costUSD !== null ? ` cost=$${event.costUSD.toFixed(4)}` : '';
-                const roundStr = event.reviewRound !== undefined && event.maxReviewRounds !== undefined
-                    ? ` round=${event.reviewRound}/${event.maxReviewRounds}`
-                    : '';
                 const sinceLastMs = Date.now() - prevEventAtMs;
-                verboseStreamRaw(`[mmagent verbose] batch=${shortBatchEarly} task=${taskIndex} heartbeat ${event.elapsed} stage=${event.stage}${roundStr} tools=${event.progress.toolCalls} read=${event.progress.filesRead} wrote=${event.progress.filesWritten} text=${textEmissionChars}c${costStr} idle=${sinceLastMs}ms`);
+                emitTaskEvent('heartbeat', {
+                    elapsed: event.elapsed,
+                    stage: event.stage,
+                    round: event.reviewRound,
+                    cap: event.maxReviewRounds,
+                    tools: event.progress.toolCalls,
+                    read: event.progress.filesRead,
+                    wrote: event.progress.filesWritten,
+                    text: textEmissionChars,
+                    cost: event.costUSD,
+                    idle_ms: sinceLastMs,
+                });
             }
             synthOnProgress(taskIndex, event);
         }, {
@@ -77,19 +106,16 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
         })
         : undefined;
     heartbeat?.start(stageCount);
-    if (verboseStreamRaw) {
-        verboseStreamRaw(`[mmagent verbose] batch=${shortBatchEarly} task=${taskIndex} heartbeat ` +
-            (heartbeat ? `started (stageCount=${stageCount}, 5s tick)` : 'DISABLED (no consumer)'));
-    }
+    emitTaskEvent('heartbeat_timer', {
+        state: heartbeat ? 'started' : 'disabled',
+        stage_count: stageCount,
+        tick_ms: heartbeat ? 5000 : undefined,
+        reason: heartbeat ? undefined : 'no_consumer',
+    });
     const implModel = resolved.provider.config.model;
     const progressCounters = { filesRead: 0, filesWritten: 0, toolCalls: 0 };
-    const verboseLogger = verbose && diagnostics?.logger ? diagnostics.logger : undefined;
-    const verboseBatchId = verboseBatchIdEarly;
     const verboseStream = verboseStreamRaw;
-    const shortBatch = shortBatchEarly;
-    if (verboseStream) {
-        verboseStream(`[mmagent verbose] batch=${shortBatch} task=${taskIndex} start worker=${resolved.provider.config.model}`);
-    }
+    emitTaskEvent('worker_start', { worker: resolved.provider.config.model });
     let prevEventAtMs = verbose ? Date.now() : 0;
     // Wrap whenever we have ANY consumer for InternalRunnerEvent (heartbeat,
     // verbose stream, or verbose logger). Previously this only wrapped when
@@ -99,22 +125,32 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
     const wrappedOnProgress = needHeartbeat
         ? (event) => {
             if (event.kind === 'turn_start') {
+                heartbeat?.markEvent('llm');
                 if (verbose)
                     prevEventAtMs = Date.now();
-                if (verboseStream) {
-                    verboseStream(`[mmagent verbose] batch=${shortBatch} task=${taskIndex} turn_start turn=${event.turn} provider=${event.provider}`);
+                if (verbose) {
+                    emitTaskEvent('turn_start', {
+                        turn: event.turn,
+                        provider: event.provider,
+                    });
                 }
             }
             if (event.kind === 'text_emission') {
+                heartbeat?.markEvent('text');
                 textEmissionChars += event.chars;
-                if (verboseStream && event.chars > 0) {
+                if (verbose && event.chars > 0) {
                     const preview = event.preview.length > 60
                         ? event.preview.slice(0, 57) + '...'
                         : event.preview;
-                    verboseStream(`[mmagent verbose] batch=${shortBatch} task=${taskIndex} text +${event.chars}c (total ${textEmissionChars}) preview="${preview.replace(/\n/g, '\\n')}"`);
+                    emitTaskEvent('text_emission', {
+                        chars: event.chars,
+                        total: textEmissionChars,
+                        preview,
+                    });
                 }
             }
             if (event.kind === 'tool_call') {
+                heartbeat?.markEvent('tool');
                 progressCounters.toolCalls++;
                 const name = event.toolSummary.split('(')[0];
                 if (name === 'readFile' || name === 'grep' || name === 'glob' || name === 'listFiles') {
@@ -128,19 +164,15 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                 const sincePrevMs = verbose ? now - prevEventAtMs : 0;
                 if (verbose)
                     prevEventAtMs = now;
-                if (verboseLogger && verboseBatchId) {
-                    verboseLogger.toolCall({
-                        batchId: verboseBatchId,
-                        taskIndex,
+                if (verbose) {
+                    emitTaskEvent('tool_call', {
                         tool: event.toolSummary,
-                        durationMs: sincePrevMs,
+                        duration_ms: sincePrevMs,
                     });
                 }
-                if (verboseStream) {
-                    verboseStream(`[mmagent verbose] batch=${shortBatch} task=${taskIndex} tool=${event.toolSummary} +${sincePrevMs}ms`);
-                }
             }
             if (event.kind === 'turn_complete') {
+                heartbeat?.markEvent('llm');
                 const costUSD = computeCostUSD(event.cumulativeInputTokens, event.cumulativeOutputTokens, resolved.provider.config);
                 const savedCostUSD = computeSavedCostUSD(costUSD, event.cumulativeInputTokens, event.cumulativeOutputTokens, task.parentModel);
                 heartbeat?.updateCost(costUSD, savedCostUSD);
@@ -148,45 +180,329 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                 const turnDurMs = verbose ? nowTurn - prevEventAtMs : 0;
                 if (verbose)
                     prevEventAtMs = nowTurn;
-                if (verboseLogger && verboseBatchId) {
-                    verboseLogger.llmTurn({
-                        batchId: verboseBatchId,
-                        taskIndex,
-                        turnIndex: progressCounters.toolCalls,
+                if (verbose) {
+                    emitTaskEvent('turn_complete', {
+                        input_tokens: event.cumulativeInputTokens,
+                        output_tokens: event.cumulativeOutputTokens,
+                        cost: costUSD,
+                        duration_ms: turnDurMs,
                         provider: resolved.provider.config.model,
-                        inputTokens: event.cumulativeInputTokens,
-                        outputTokens: event.cumulativeOutputTokens,
-                        costUSD,
                     });
                 }
-                if (verboseStream) {
-                    const costStr = costUSD !== null ? ` $${costUSD.toFixed(4)}` : '';
-                    verboseStream(`[mmagent verbose] batch=${shortBatch} task=${taskIndex} ` +
-                        `turn in=${event.cumulativeInputTokens} out=${event.cumulativeOutputTokens}${costStr} ` +
-                        `+${turnDurMs}ms (${resolved.provider.config.model})`);
-                }
             }
         }
         : undefined;
-    // Track auto-commit state across all rounds
-    let commitSha;
+    const cwd = task.cwd ?? process.cwd();
+    const taskStartMs = Date.now();
+    const commits = [];
     let commitError;
+    let specRework = 0;
+    let qualityRework = 0;
+    let metadataRepair = 0;
+    const maxReviewRounds = task.maxReviewRounds ?? 3;
+    const maxCostUSD = task.maxCostUSD;
+    const reviewRounds = () => ({ spec: specRework, quality: qualityRework, metadata: metadataRepair, cap: maxReviewRounds });
+    const taskCostUSD = () => (heartbeat ? heartbeat.getHeartbeatTickInfo().costUSD : null);
+    // When the review loop aborts mid-flight, preserve any review-status info already set
+    // on the base result (set by callers via abortReviewLoop({ ...res, specReviewStatus, ... })).
+    // Defaults to 'changes_required' for whichever loop tripped — that's the only state the
+    // loop ever fires from, by construction.
+    const abortReviewLoop = (base, terminationReason, message, aborting) => ({
+        ...base,
+        status: 'incomplete',
+        workerStatus: 'review_loop_aborted',
+        terminationReason,
+        reviewRounds: reviewRounds(),
+        error: message,
+        specReviewStatus: aborting === 'spec' ? 'changes_required' : (base.specReviewStatus ?? 'approved'),
+        qualityReviewStatus: aborting === 'quality' ? 'changes_required' : (base.qualityReviewStatus ?? 'skipped'),
+    });
+    const defaultVerification = { status: 'skipped', steps: [], totalDurationMs: 0, skipReason: 'no_command' };
+    let latestVerification = defaultVerification;
+    async function runVerificationStage() {
+        emitTaskEvent('stage_change', { from: 'committing', to: 'verifying' });
+        heartbeat?.transition({
+            stage: 'verifying',
+            stageIndex: 4,
+            reviewRound: undefined,
+            maxReviewRounds: task.maxReviewRounds ?? 5,
+        });
+        const verification = await runVerifyStage({
+            cwd,
+            verifyCommand: task.verifyCommand,
+            taskTimeoutMs: task.timeoutMs ?? config.defaults.timeoutMs ?? 1_800_000,
+            taskStartMs,
+        });
+        latestVerification = verification;
+        for (const step of verification.steps) {
+            emitTaskEvent('verify_step', {
+                command: step.command,
+                status: step.status,
+                exit_code: step.exitCode,
+                signal: step.signal,
+                duration_ms: step.durationMs,
+                error_message: step.errorMessage ?? undefined,
+            });
+        }
+        if (verification.status === 'skipped') {
+            emitTaskEvent('verify_skipped', { reason: verification.skipReason ?? 'no_command', stage: 'verifying' });
+        }
+        return verification;
+    }
+    function signalize(result) {
+        const cause = typeof result.terminationReason === 'object' ? result.terminationReason.cause : result.terminationReason;
+        const capExhausted = result.capExhausted
+            ?? (result.status === 'cost_exceeded' || cause === 'cost_exceeded' || cause === 'cost_ceiling' ? 'cost'
+                : result.status === 'timeout' || cause === 'timeout' ? 'wall_clock'
+                    : result.status === 'incomplete' && result.turns > 1 ? 'turn'
+                        : undefined);
+        const lifecycleClarificationRequested = result.lifecycleClarificationRequested
+            ?? (result.status === 'brief_too_vague' || cause === 'brief_too_vague' ? true : undefined);
+        return {
+            ...result,
+            ...(capExhausted !== undefined && { capExhausted }),
+            ...(lifecycleClarificationRequested !== undefined && { lifecycleClarificationRequested }),
+        };
+    }
+    function workerErrorResult(err) {
+        const workerError = err instanceof Error ? err : new Error(String(err));
+        return signalize({
+            output: '',
+            status: 'error',
+            usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0, costUSD: null },
+            turns: 0,
+            filesRead: [],
+            filesWritten: [],
+            toolCalls: [],
+            outputIsDiagnostic: true,
+            escalationLog: [],
+            error: workerError.message,
+            errorCode: 'runner_crash',
+            structuredError: { code: 'runner_crash', message: workerError.message },
+            workerStatus: 'failed',
+            workerError,
+        });
+    }
+    function withVerification(result, verification = latestVerification) {
+        return signalize({ ...result, verification });
+    }
+    function verificationErrorResult(base, verification) {
+        if (verification.status !== 'error')
+            return null;
+        const failedIndex = verification.steps.findIndex((step) => step.status !== 'passed');
+        const failedStep = failedIndex >= 0 ? verification.steps[failedIndex] : undefined;
+        return withVerification({
+            ...base,
+            status: 'error',
+            workerStatus: 'done_with_concerns',
+            error: failedStep?.errorMessage ?? 'verify command error',
+            errorCode: 'verify_command_error',
+            commits,
+            commitError,
+            verification,
+        }, verification);
+    }
+    function resolveOffTerminal(base, verification) {
+        const concerns = [...(base.concerns ?? [])];
+        let workerStatus = workerStatusForTerminal(base.workerStatus);
+        if (verification.status === 'failed') {
+            concerns.push({
+                source: 'verification',
+                severity: 'high',
+                message: 'Verification failed after implementation.',
+            });
+            workerStatus = 'done_with_concerns';
+        }
+        if (verification.status === 'error') {
+            const failedIndex = verification.steps.findIndex((step) => step.status !== 'passed');
+            const failedStep = failedIndex >= 0 ? verification.steps[failedIndex] : undefined;
+            return withVerification({
+                ...base,
+                status: 'error',
+                workerStatus: 'failed',
+                error: failedStep?.errorMessage ?? 'verify command error',
+                errorCode: 'verify_command_error',
+                commits,
+                commitError,
+                verification,
+            }, verification);
+        }
+        return withVerification({
+            ...base,
+            status: base.status === 'ok' ? 'ok' : base.status,
+            workerStatus,
+            concerns,
+            commits,
+            commitError,
+            verification,
+        }, verification);
+    }
+    function resolveDiffOnlyTerminal(base, verdict, verification, diffTruncated) {
+        const concerns = [...(base.concerns ?? [])];
+        if (verdict.kind === 'reject') {
+            return withVerification({
+                ...base,
+                status: 'error',
+                workerStatus: 'failed',
+                error: verdict.message || 'diff review rejected implementation',
+                errorCode: 'diff_review_rejected',
+                structuredError: {
+                    code: 'diff_review_rejected',
+                    message: verdict.message || 'diff review rejected implementation',
+                },
+                concerns,
+                commits,
+                commitError,
+                verification,
+            }, verification);
+        }
+        concerns.push(...verdict.concerns);
+        if (verification.status === 'failed') {
+            concerns.push({
+                source: 'verification',
+                severity: 'high',
+                message: 'Verification failed after implementation.',
+            });
+        }
+        if (diffTruncated) {
+            concerns.push({
+                source: 'diff_truncated',
+                severity: 'medium',
+                message: 'Implementation diff exceeded the reviewer evidence byte cap and was truncated.',
+            });
+        }
+        const hasConcerns = concerns.length > 0 || verification.status === 'failed';
+        return withVerification({
+            ...base,
+            status: base.status === 'ok' ? 'ok' : base.status,
+            workerStatus: hasConcerns ? 'done_with_concerns' : workerStatusForTerminal(base.workerStatus),
+            concerns,
+            commits,
+            commitError,
+            verification,
+        }, verification);
+    }
+    function workerStatusForTerminal(status) {
+        return status === 'needs_context' || status === 'blocked' || status === 'failed' || status === 'done_with_concerns'
+            ? status
+            : 'done';
+    }
+    async function recordWorkerCommits(from, to = 'HEAD') {
+        const { stdout: revs } = await exec('git', ['rev-list', '--reverse', `${from}..${to}`], { cwd });
+        for (const sha of revs.trim().split('\n').filter(Boolean)) {
+            const c = await readbackCommit(sha, cwd);
+            commits.push(c);
+        }
+    }
+    async function repairCommitMetadata(initialDiagnostic) {
+        let metadataAttempts = 0;
+        let lastZodError = initialDiagnostic || 'no commit block emitted';
+        let validCommit = null;
+        while (metadataAttempts < 2 && !validCommit) {
+            const preStatus = (await exec('git', ['status', '--porcelain=v1', '-z'], { cwd })).stdout;
+            const repaired = await runMetadataRepairTurn({ task, zodError: lastZodError, cwd, providerSlot: resolved.slot, provider: resolved.provider });
+            const postStatus = (await exec('git', ['status', '--porcelain=v1', '-z'], { cwd })).stdout;
+            metadataAttempts += 1;
+            if (preStatus !== postStatus) {
+                commitError = 'commit_metadata_repair_modified_files';
+                return null;
+            }
+            if (repaired.commit)
+                validCommit = repaired.commit;
+            else
+                lastZodError = repaired.commitDiagnostic ?? 'no commit block emitted';
+        }
+        if (!validCommit)
+            commitError = `commit_metadata_invalid: ${lastZodError}`;
+        return validCommit;
+    }
+    async function captureCommitsAfterImplementation(implResult, implReport, baselineHead) {
+        const porcelain = (await exec('git', ['status', '--porcelain=v1'], { cwd })).stdout;
+        const headNow = (await exec('git', ['rev-parse', 'HEAD'], { cwd })).stdout.trim();
+        const headMoved = headNow !== baselineHead;
+        const treeDirty = porcelain.length > 0;
+        if (!headMoved && !treeDirty)
+            return;
+        if (headMoved)
+            await recordWorkerCommits(baselineHead, 'HEAD');
+        if (treeDirty) {
+            const validCommit = implReport?.commit ?? await repairCommitMetadata(implReport?.commitDiagnostic ?? 'no commit block emitted');
+            if (!validCommit)
+                return;
+            const c = await runCommitStage({ cwd, filesWritten: implResult.filesWritten, commit: validCommit });
+            commits.push(c);
+        }
+    }
     try {
+        // The dirty-tree precondition + git baseline only apply to artifact-producing tasks
+        // (those with autoCommit === true). Non-artifact presets — audit, review, verify,
+        // debug — neither produce commits nor read git state, so they bypass the check
+        // entirely. Per spec Section A: "Non-artifact tasks (audits, analyses, read-only
+        // investigations) skip stages 3 and 4."
+        const isArtifactProducing = task.autoCommit === true;
+        let baselineHead = '';
+        if (isArtifactProducing) {
+            baselineHead = (await exec('git', ['rev-parse', 'HEAD'], { cwd })).stdout.trim();
+            const baselinePorcelain = (await exec('git', ['status', '--porcelain=v1', '-z'], { cwd })).stdout;
+            if (baselinePorcelain.length !== 0) {
+                return withVerification({
+                    output: `Sub-agent error: task.cwd ${cwd} had pre-existing modifications`,
+                    status: 'error',
+                    usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0, costUSD: null },
+                    turns: 0,
+                    filesRead: [],
+                    filesWritten: [],
+                    toolCalls: [],
+                    outputIsDiagnostic: true,
+                    escalationLog: [],
+                    error: `task.cwd ${cwd} had pre-existing modifications`,
+                    errorCode: 'dirty_worktree',
+                    commits,
+                });
+            }
+        }
         const implResult = await delegateWithEscalation(withDoneCondition(task), [resolved.provider], { explicitlyPinned: false, escalateToProvider: escalationProvider, onProgress: wrappedOnProgress });
         const implReport = implResult.status === 'ok' ? parseStructuredReport(implResult.output) : undefined;
         const workerStatus = extractWorkerStatus(implReport);
-        // Auto-commit: commit the worker's file changes
-        if (task.autoCommit && implResult.status === 'ok' && implResult.filesWritten.length > 0) {
-            const commitResult = autoCommitFiles(implResult.filesWritten, implReport?.summary ?? undefined, task.cwd ?? process.cwd());
-            commitSha = commitResult.sha;
-            commitError = commitResult.error;
+        if (implResult.status === 'ok' && isArtifactProducing) {
+            await captureCommitsAfterImplementation(implResult, implReport, baselineHead);
         }
+        const verification = isArtifactProducing ? await runVerificationStage() : defaultVerification;
+        const verifyError = verificationErrorResult(implResult, verification);
+        if (verifyError)
+            return verifyError;
         const filePathsInteracted = task.filePaths && task.filePaths.length > 0
             ? [...(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) {
             heartbeat?.updateStageCount(1);
+            if (reviewPolicy === 'off') {
+                emitTaskEvent('stage_change', { from: 'verifying', to: 'terminal' });
+                const terminal = resolveOffTerminal({
+                    ...implResult,
+                    workerStatus,
+                    specReviewStatus: 'skipped',
+                    qualityReviewStatus: 'skipped',
+                    specReviewReason: 'skipped: reviewPolicy is off',
+                    qualityReviewReason: 'skipped: reviewPolicy is off',
+                    agents: {
+                        implementer: resolved.slot,
+                        specReviewer: 'skipped',
+                        qualityReviewer: 'skipped',
+                    },
+                    models: {
+                        implementer: implModel,
+                        specReviewer: null,
+                        qualityReviewer: null,
+                    },
+                    implementationReport: implReport,
+                    structuredReport: implReport,
+                    filePathsSkipped,
+                    fileArtifactsMissing: implResult.status === 'ok' ? checkOutputTargets(outputTargets) : undefined,
+                }, verification);
+                return terminal;
+            }
             const effectiveImplReport = implReport ?? buildFallbackImplReport(implResult);
             const earlyFileArtifactsMissing = implResult.status === 'ok' ? checkOutputTargets(outputTargets) : undefined;
             const earlyStatus = implResult.status === 'ok' && earlyFileArtifactsMissing
@@ -207,6 +523,7 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                     validationsRun: effectiveImplReport.validationsRun,
                     deviationsFromBrief: effectiveImplReport.deviationsFromBrief,
                     unresolved: effectiveImplReport.unresolved,
+                    extraSections: effectiveImplReport.extraSections ?? {},
                 },
                 filePathsSkipped,
                 agents: {
@@ -220,8 +537,9 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                     qualityReviewer: null,
                 },
                 fileArtifactsMissing: earlyFileArtifactsMissing,
-                commitSha,
+                commits,
                 commitError,
+                verification,
             };
         }
         if (workerStatus === 'needs_context' || workerStatus === 'blocked') {
@@ -243,12 +561,14 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                     qualityReviewer: null,
                 },
                 fileArtifactsMissing: implResult.status === 'ok' ? checkOutputTargets(outputTargets) : undefined,
-                commitSha,
+                commits,
                 commitError,
+                verification,
             };
         }
         if (reviewPolicy === 'off') {
-            return {
+            emitTaskEvent('stage_change', { from: 'verifying', to: 'terminal' });
+            const terminal = resolveOffTerminal({
                 ...implResult,
                 workerStatus,
                 specReviewStatus: 'skipped',
@@ -267,9 +587,8 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                 },
                 implementationReport: implReport,
                 fileArtifactsMissing: implResult.status === 'ok' ? checkOutputTargets(outputTargets) : undefined,
-                commitSha,
-                commitError,
-            };
+            }, verification);
+            return terminal;
         }
         let otherProvider;
         try {
@@ -294,8 +613,9 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                     qualityReviewer: null,
                 },
                 fileArtifactsMissing: implResult.status === 'ok' ? checkOutputTargets(outputTargets) : undefined,
-                commitSha,
+                commits,
                 commitError,
+                verification,
             };
         }
         const reviewModel = otherProvider.config.model;
@@ -306,23 +626,72 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
         };
         let fileContents = await readImplementerFileContents(implResult.filesWritten, task.cwd);
         const effectiveImplReport = implReport ?? buildFallbackImplReport(implResult);
+        const evidence = isArtifactProducing
+            ? await buildEvidence({ cwd, baselineHead, commits, verification, reviewPolicy })
+            : { block: '', diffTruncated: false, fullDiff: '' };
+        if (reviewPolicy === 'diff_only') {
+            emitTaskEvent('stage_change', { from: 'verifying', to: 'diff_review' });
+            heartbeat?.transition({
+                stage: 'diff_review',
+                stageIndex: 2,
+                reviewRound: 1,
+                maxReviewRounds,
+            });
+            const verdict = await runDiffReview({
+                cwd,
+                diff: evidence.fullDiff,
+                diffTruncated: evidence.diffTruncated,
+                verification,
+                worker: { call: (prompt) => otherProvider.run(prompt) },
+            });
+            emitTaskEvent('review_decision', { stage: 'diff_review', verdict: verdict.kind, round: 1 });
+            return resolveDiffOnlyTerminal({
+                ...implResult,
+                workerStatus,
+                specReviewStatus: 'skipped',
+                qualityReviewStatus: 'skipped',
+                specReviewReason: 'skipped: reviewPolicy is diff_only',
+                qualityReviewReason: 'skipped: reviewPolicy is diff_only',
+                implementationReport: effectiveImplReport,
+                fileArtifactsMissing: implResult.status === 'ok' ? checkOutputTargets(outputTargets) : undefined,
+                agents: {
+                    implementer: resolved.slot,
+                    specReviewer: 'skipped',
+                    qualityReviewer: 'skipped',
+                },
+                models: {
+                    implementer: implModel,
+                    specReviewer: reviewModel,
+                    qualityReviewer: null,
+                },
+            }, verdict, verification, evidence.diffTruncated);
+        }
         heartbeat?.transition({
             stage: 'spec_review', stageIndex: 2,
             reviewRound: 1, maxReviewRounds: task.maxReviewRounds ?? 5,
         });
-        let specResult = await runSpecReview(otherProvider, packet, effectiveImplReport, fileContents, implResult.toolCalls, task.planContext);
+        let specResult = await runSpecReview(otherProvider, packet, effectiveImplReport, fileContents, implResult.toolCalls, task.planContext, evidence.block);
         let finalImplResult = implResult;
         let finalImplReport = effectiveImplReport;
         let specStatus = specResult.status;
         let specReport = specResult.report;
         if (specStatus === 'changes_required') {
             let prevSpecFindings = [];
-            let round = 0;
             while (true) {
-                round++;
+                if (specRework + qualityRework >= maxReviewRounds) {
+                    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');
+                }
+                emitTaskEvent('stage_change', { from: 'spec_review', to: 'spec_rework', round: specRework + 1, cap: maxReviewRounds });
+                specRework++;
+                const round = specRework;
                 heartbeat?.transition({
                     stage: 'spec_rework', stageIndex: 3,
-                    reviewRound: round, maxReviewRounds: task.maxReviewRounds ?? 5,
+                    reviewRound: round, maxReviewRounds,
                 });
                 const feedback = specResult.findings.length > 0
                     ? `\n\n## Spec Review Feedback (round ${round}):\n${specResult.findings.map(f => `- ${f}`).join('\n')}`
@@ -330,15 +699,6 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                 const reworkPrompt = `${task.prompt}${feedback}`;
                 const reworkTask = withDoneCondition({ ...task, prompt: reworkPrompt });
                 const reworkResult = await delegateWithEscalation(reworkTask, [resolved.provider], { explicitlyPinned: true, onProgress: wrappedOnProgress });
-                // Auto-commit rework changes
-                if (task.autoCommit && reworkResult.status === 'ok' && reworkResult.filesWritten.length > 0) {
-                    const reworkReport = parseStructuredReport(reworkResult.output);
-                    const reworkCommit = autoCommitFiles(reworkResult.filesWritten, reworkReport.summary ?? undefined, task.cwd ?? process.cwd());
-                    if (reworkCommit.sha)
-                        commitSha = reworkCommit.sha;
-                    if (reworkCommit.error)
-                        commitError = reworkCommit.error;
-                }
                 finalImplResult = reworkResult;
                 const reworkReport = parseStructuredReport(reworkResult.output);
                 finalImplReport = reworkReport.summary ? reworkReport : buildFallbackImplReport(reworkResult);
@@ -346,9 +706,9 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                 fileContents = reworkContents;
                 heartbeat?.transition({
                     stage: 'spec_review', stageIndex: 2,
-                    reviewRound: round + 1, maxReviewRounds: task.maxReviewRounds ?? 5,
+                    reviewRound: round + 1, maxReviewRounds,
                 });
-                specResult = await runSpecReview(otherProvider, packet, finalImplReport, reworkContents, reworkResult.toolCalls, task.planContext);
+                specResult = await runSpecReview(otherProvider, packet, finalImplReport, reworkContents, reworkResult.toolCalls, task.planContext, evidence.block);
                 specStatus = specResult.status;
                 specReport = specResult.report;
                 if (specStatus === 'approved')
@@ -358,25 +718,32 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                 if (currentFindings === prevFindings && currentFindings !== '')
                     break;
                 prevSpecFindings = specResult.findings;
-                if (round >= (task.maxReviewRounds ?? 5))
-                    break;
             }
         }
         let qualityResult = { status: 'skipped', report: undefined, findings: [] };
         if (reviewPolicy === 'full') {
             heartbeat?.transition({
                 stage: 'quality_review', stageIndex: 4,
-                reviewRound: 1, maxReviewRounds: task.maxReviewRounds ?? 5,
+                reviewRound: 1, maxReviewRounds,
             });
-            qualityResult = await runQualityReview(otherProvider, packet, specReport ?? finalImplReport, fileContents, finalImplResult.toolCalls, finalImplResult.filesWritten);
+            qualityResult = await runQualityReview(otherProvider, packet, specReport ?? finalImplReport, fileContents, finalImplResult.toolCalls, finalImplResult.filesWritten, evidence.block);
             if (qualityResult.status === 'changes_required') {
                 let prevQualityFindings = [];
-                let round = 0;
                 while (true) {
-                    round++;
+                    if (specRework + qualityRework >= maxReviewRounds) {
+                        return abortReviewLoop(finalImplResult, 'round_cap', 'review round cap reached before quality rework', 'quality');
+                    }
+                    const currentCostUSD = taskCostUSD();
+                    if (currentCostUSD !== null && maxCostUSD !== undefined && currentCostUSD >= 0.8 * maxCostUSD) {
+                        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');
+                    }
+                    emitTaskEvent('stage_change', { from: 'quality_review', to: 'quality_rework', round: qualityRework + 1, cap: maxReviewRounds });
+                    qualityRework++;
+                    const round = qualityRework;
                     heartbeat?.transition({
                         stage: 'quality_rework', stageIndex: 5,
-                        reviewRound: round, maxReviewRounds: task.maxReviewRounds ?? 5,
+                        reviewRound: round, maxReviewRounds,
                     });
                     const feedback = qualityResult.findings.length > 0
                         ? `\n\n## Quality Review Feedback (round ${round}):\n${qualityResult.findings.map(f => `- ${f}`).join('\n')}`
@@ -384,24 +751,15 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                     const reworkPrompt = `${task.prompt}${feedback}`;
                     const reworkTask = withDoneCondition({ ...task, prompt: reworkPrompt });
                     const reworkResult = await delegateWithEscalation(reworkTask, [resolved.provider], { explicitlyPinned: true, onProgress: wrappedOnProgress });
-                    // Auto-commit rework changes
-                    if (task.autoCommit && reworkResult.status === 'ok' && reworkResult.filesWritten.length > 0) {
-                        const reworkReport = parseStructuredReport(reworkResult.output);
-                        const reworkCommit = autoCommitFiles(reworkResult.filesWritten, reworkReport.summary ?? undefined, task.cwd ?? process.cwd());
-                        if (reworkCommit.sha)
-                            commitSha = reworkCommit.sha;
-                        if (reworkCommit.error)
-                            commitError = reworkCommit.error;
-                    }
                     finalImplResult = reworkResult;
                     const reworkReport = parseStructuredReport(reworkResult.output);
                     finalImplReport = reworkReport.summary ? reworkReport : buildFallbackImplReport(reworkResult);
                     const reworkContents = await readImplementerFileContents(reworkResult.filesWritten, task.cwd);
                     heartbeat?.transition({
                         stage: 'quality_review', stageIndex: 4,
-                        reviewRound: round + 1, maxReviewRounds: task.maxReviewRounds ?? 5,
+                        reviewRound: round + 1, maxReviewRounds,
                     });
-                    qualityResult = await runQualityReview(otherProvider, packet, finalImplReport, reworkContents, reworkResult.toolCalls, reworkResult.filesWritten);
+                    qualityResult = await runQualityReview(otherProvider, packet, finalImplReport, reworkContents, reworkResult.toolCalls, reworkResult.filesWritten, evidence.block);
                     if (qualityResult.status === 'approved')
                         break;
                     const currentFindings = [...qualityResult.findings].sort().join('\0');
@@ -409,12 +767,28 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                     if (currentFindings === prevFindings && currentFindings !== '')
                         break;
                     prevQualityFindings = qualityResult.findings;
-                    if (round >= (task.maxReviewRounds ?? 5))
-                        break;
                 }
             }
         }
         const finalReport = specReport ?? finalImplReport;
+        const concerns = [...(finalImplResult.concerns ?? [])];
+        let finalWorkerStatus = workerStatus;
+        if (verification.status === 'failed') {
+            concerns.push({
+                source: 'verification',
+                severity: 'high',
+                message: 'Verification failed after implementation.',
+            });
+            if (finalWorkerStatus === 'done')
+                finalWorkerStatus = 'done_with_concerns';
+        }
+        if (evidence.diffTruncated) {
+            concerns.push({
+                source: 'diff_truncated',
+                severity: 'medium',
+                message: 'Implementation diff exceeded the reviewer evidence byte cap and was truncated.',
+            });
+        }
         const aggregated = aggregateResult(finalReport, specReport, qualityResult.report, specStatus, qualityResult.status);
         // 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.
@@ -432,7 +806,8 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
         return {
             ...finalImplResult,
             status: finalStatus,
-            workerStatus,
+            workerStatus: finalWorkerStatus,
+            concerns,
             specReviewStatus: specStatus,
             qualityReviewStatus: qualityResult.status,
             specReviewReason: specResult.errorReason,
@@ -453,10 +828,14 @@ export async function executeReviewedLifecycle(task, resolved, config, taskIndex
                 qualityReviewer: reviewPolicy === 'full' ? reviewModel : null,
             },
             fileArtifactsMissing,
-            commitSha,
+            commits,
             commitError,
+            verification,
         };
     }
+    catch (err) {
+        return withVerification(workerErrorResult(err));
+    }
     finally {
         heartbeat?.stop();
     }