codex-orchestrator 2.0.10 → 2.0.12

package/dist/src/v2/direct-delivery.js

@@ -1,53 +1,33 @@
 import { createHash } from 'node:crypto';
+import { validateCandidateBinding } from './candidate.js';
 import { canonicalJson } from './containment.js';
-import { hashClosureRequest, validateCodeReviewDefects } from './code-review-report.js';
+import { validateCodeReviewDefects } from './code-review-report.js';
 const SHA256 = /^[0-9a-f]{64}$/u;
-const MAX_ITEMS = 256;
-export const MAX_DIRECT_REVIEW_REPORT_REPAIRS = 4;
-export function directReviewTargetFingerprint(input) {
-    const changedFiles = sortedUniqueStrings(input.changedFiles, 'direct review changed files');
-    assertSha256(input.routeDecisionSha256, 'direct review route decision hash');
+export function directReviewCandidateTargetFingerprint(input) {
+    const binding = validateCandidateBinding(input.binding, 'direct review candidate binding');
+    assertSha256(input.deliveryAuthoritySha256, 'direct review delivery authority hash');
     assertSha256(input.workflowGenerationHash, 'direct review workflow generation hash');
     if (!Number.isSafeInteger(input.cycle) || input.cycle < 1)
         throw new Error('direct review cycle is invalid');
-    return createHash('sha256').update(`codex-orchestrator-direct-review-target-v1\0${canonicalJson({
-        snapshot: input.snapshot,
-        changedFiles,
-        routeDecisionSha256: input.routeDecisionSha256,
+    return createHash('sha256').update(`codex-orchestrator-direct-review-target-v2\0${canonicalJson({
+        bindingId: binding.bindingId,
+        expectedHeadSha: binding.expectedHeadSha,
+        candidateCommitSha: binding.candidateCommitSha,
+        candidateTreeSha: binding.candidateTreeSha,
+        canonicalChangedFiles: binding.canonicalChangedFiles,
+        sourceWorktreeIdentity: binding.sourceWorktreeIdentity,
+        deliveryAuthoritySha256: input.deliveryAuthoritySha256,
         workflowGenerationHash: input.workflowGenerationHash,
         cycle: input.cycle,
         frozenCriteria: input.frozenCriteria,
     })}`).digest('hex');
 }
-export function prepareDirectReviewInvocation(state, invocation) {
-    if (state.status !== 'active' || state.invocation || state.stage === null || state.stage.endsWith('-repair')) {
-        throw new Error('direct review is not ready to prepare an invocation');
-    }
-    if (invocation.targetRevision !== state.targetRevision || invocation.targetFingerprint !== state.targetFingerprint) {
-        throw new Error('direct review invocation target mismatch');
-    }
-    return {
-        ...structuredClone(state),
-        invocation: { ...structuredClone(invocation), status: 'prepared', pid: null, processGroupId: null },
-    };
-}
-export function launchDirectReviewInvocation(state, input) {
-    if (!state.invocation || state.invocation.status !== 'prepared' || state.invocation.attemptId !== input.attemptId
-        || !Number.isSafeInteger(input.pid) || input.pid < 1 || !Number.isSafeInteger(input.processGroupId) || input.processGroupId < 1) {
-        throw new Error('direct review prepared invocation mismatch');
-    }
-    return {
-        ...structuredClone(state),
-        invocation: { ...structuredClone(state.invocation), status: 'launched', pid: input.pid, processGroupId: input.processGroupId },
-    };
-}
-export function acceptApprovedDirectReview(state, report, artifactSha256) {
+export function acceptApprovedDirectReview(state, report, artifactSha256, candidateTreeSha, mode) {
     assertSha256(artifactSha256, 'direct review accepted report hash');
-    if (state.status !== 'active' || !state.invocation || state.stage === null || report.verdict !== 'approved'
+    assertGitSha(candidateTreeSha, 'direct review approved candidate tree');
+    if (state.status !== 'active' || state.stage === null || report.verdict !== 'approved'
         || report.targetRevision !== state.targetRevision || report.targetFingerprint !== state.targetFingerprint
-        || report.operation !== state.invocation.operation || report.mode !== state.invocation.mode
-        || report.reviewerSessionId !== state.invocation.reviewerSessionId
-        || report.closureRequestSha256 !== state.invocation.closureRequestSha256) {
+        || report.operation !== 'code-review' || report.reviewerSessionId !== state.review.reviewerSessionId) {
         throw new Error('accepted direct review report correlation mismatch');
     }
     const defects = mergeDefectLedger(state, report);
@@ -55,49 +35,74 @@ export function acceptApprovedDirectReview(state, report, artifactSha256) {
         && defect.status !== 'verified' && defect.status !== 'superseded')) {
         throw new Error('approved direct review merge has unresolved defects');
     }
+    const impactedCoverage = new Set([
+        ...state.review.defects
+            .filter((defect) => defect.status === 'fixed' && defect.statusTargetRevision === state.targetRevision)
+            .flatMap((defect) => defect.affectedTargets),
+        ...state.repairFindings
+            .filter((finding) => finding.status === 'fixed')
+            .flatMap((finding) => finding.affectedContracts),
+    ].filter((target) => target.startsWith('contract:')).map((target) => target.slice('contract:'.length)));
+    const mergedCoverage = [...new Set([
+            ...state.review.coverage.filter((coverage) => !impactedCoverage.has(coverage)),
+            ...report.coverage,
+        ])].sort();
     const clearTrack = {
         ...structuredClone(state.review),
         disposition: 'clear',
-        coverage: [...report.coverage],
-        defects,
-        affectedDefectIds: [],
+        coverage: mergedCoverage,
+        defects: defects.filter((defect) => defect.status !== 'verified' && defect.status !== 'superseded'),
         acceptedReportSha256: artifactSha256,
     };
-    const { invocation: _invocation, ...withoutInvocation } = structuredClone(state);
     const outcomes = new Map(report.repairFindingOutcomes.map((outcome) => [outcome.id, outcome.status]));
     return {
-        ...withoutInvocation,
+        ...structuredClone(state),
         status: 'clear',
+        previousTarget: mode === 'targeted' ? structuredClone(state.previousTarget) : null,
         review: clearTrack,
         repairFindings: state.repairFindings.map((finding) => {
             const outcome = outcomes.get(finding.id);
             return outcome ? { ...structuredClone(finding), status: outcome } : structuredClone(finding);
-        }),
+        }).filter((finding) => finding.status !== 'verified'),
     };
 }
-export function acceptNeedsWorkDirectReview(state, report, artifactSha256) {
+export function acceptNeedsWorkDirectReview(state, report, artifactSha256, candidateTreeSha) {
     assertSha256(artifactSha256, 'direct review accepted report hash');
+    assertGitSha(candidateTreeSha, 'direct review candidate tree');
     const reopenedFinding = report.repairFindingOutcomes.some((outcome) => outcome.status === 'reopened');
-    if (state.status !== 'active' || !state.invocation || state.stage === null || report.verdict !== 'needs-work'
+    if (state.status !== 'active' || state.stage === null || report.verdict !== 'needs-work'
         || report.targetRevision !== state.targetRevision || report.targetFingerprint !== state.targetFingerprint
-        || report.operation !== state.invocation.operation || report.mode !== state.invocation.mode
-        || report.reviewerSessionId !== state.invocation.reviewerSessionId
-        || report.closureRequestSha256 !== state.invocation.closureRequestSha256
+        || report.operation !== 'code-review' || report.reviewerSessionId !== state.review.reviewerSessionId
         || (!report.defects.some((defect) => defect.status === 'open' || defect.status === 'reopened') && !reopenedFinding)) {
         throw new Error('needs-work direct review report correlation mismatch');
     }
-    const { invocation: _invocation, ...withoutInvocation } = structuredClone(state);
     const outcomes = new Map(report.repairFindingOutcomes.map((outcome) => [outcome.id, outcome.status]));
+    const blockedContracts = new Set([
+        ...report.defects
+            .filter((defect) => defect.status === 'open' || defect.status === 'reopened')
+            .flatMap((defect) => defect.affectedTargets),
+        ...state.repairFindings
+            .filter((finding) => outcomes.get(finding.id) === 'reopened')
+            .flatMap((finding) => finding.affectedContracts),
+    ].filter((target) => target.startsWith('contract:')).map((target) => target.slice('contract:'.length)));
+    const mergedCoverage = [...new Set([
+            ...state.review.coverage,
+            ...report.coverage,
+        ])].filter((coverage) => !blockedContracts.has(coverage)).sort();
     return {
-        ...withoutInvocation,
+        ...structuredClone(state),
         status: 'active',
         stage: 'review-repair',
+        previousTarget: {
+            targetRevision: state.targetRevision,
+            targetFingerprint: state.targetFingerprint,
+            candidateTreeSha,
+        },
         review: {
             ...structuredClone(state.review),
             disposition: 'active',
-            coverage: [...report.coverage],
+            coverage: mergedCoverage,
             defects: mergeDefectLedger(state, report),
-            affectedDefectIds: [],
             acceptedReportSha256: artifactSha256,
         },
         repairFindings: state.repairFindings.map((finding) => {
@@ -108,26 +113,20 @@ export function acceptNeedsWorkDirectReview(state, report, artifactSha256) {
 }
 function mergeDefectLedger(state, report) {
     const current = state.review.defects;
-    if (report.mode === 'full') {
-        if (current.length !== 0)
-            throw new Error('Full review cannot replace an existing defect ledger');
+    if (current.length === 0)
         return structuredClone(report.defects);
-    }
     const reported = new Map(report.defects.map((defect) => [defect.id, defect]));
-    const affected = new Set(state.review.affectedDefectIds);
     const merged = current.map((existing) => {
         const next = reported.get(existing.id);
         if (!next) {
-            if (!affected.has(existing.id))
-                return structuredClone(existing);
-            return { ...structuredClone(existing), status: 'reopened', statusTargetRevision: state.targetRevision, supersededBy: null };
+            if (existing.status === 'fixed')
+                throw new Error('review omitted an impacted defect ID');
+            return structuredClone(existing);
         }
         reported.delete(existing.id);
-        if (!affected.has(existing.id))
-            return structuredClone(existing);
-        if (affected.has(existing.id) && existing.status === 'fixed'
+        if (existing.status === 'fixed'
             && !['verified', 'reopened', 'superseded'].includes(next.status)) {
-            throw new Error('Closure defect transition is invalid');
+            throw new Error('full review defect transition is invalid');
         }
         return {
             ...structuredClone(next),
@@ -141,19 +140,30 @@ function mergeDefectLedger(state, report) {
     for (const added of reported.values()) {
         if (added.status !== 'open' || added.introducedTargetRevision !== state.targetRevision
             || added.statusTargetRevision !== state.targetRevision)
-            throw new Error('Closure introduced defect is invalid');
+            throw new Error('full review introduced defect is invalid');
         merged.push(structuredClone(added));
     }
     return merged.sort((left, right) => left.id.localeCompare(right.id));
 }
-export function beginDirectReviewRepair(state, findings) {
-    if (state.status !== 'clear' || state.review.disposition !== 'clear' || state.invocation || findings.length === 0) {
+export function beginDirectReviewRepair(state, findings, candidateTreeSha) {
+    if (findings.length === 0 || (state.status !== 'clear'
+        && !(state.status === 'active' && state.stage === 'review-repair'))) {
         throw new Error('direct review is not clear for repair');
     }
+    if (state.status === 'active') {
+        return { ...structuredClone(state), repairFindings: mergeRepairFindings(state.repairFindings, findings) };
+    }
+    if (state.review.disposition !== 'clear')
+        throw new Error('direct review is not clear for repair');
     return {
         ...structuredClone(state),
         status: 'active',
         stage: 'review-repair',
+        previousTarget: candidateTreeSha ? {
+            targetRevision: state.targetRevision,
+            targetFingerprint: state.targetFingerprint,
+            candidateTreeSha,
+        } : structuredClone(state.previousTarget),
         review: { ...structuredClone(state.review), disposition: 'active' },
         repairFindings: mergeRepairFindings(state.repairFindings, findings),
     };
@@ -174,10 +184,11 @@ function mergeRepairFindings(current, incoming) {
     }
     return [...merged.values()].sort((left, right) => left.id.localeCompare(right.id));
 }
-export function prepareDirectReviewClosure(state, targetFingerprint) {
-    assertSha256(targetFingerprint, 'direct review Closure target fingerprint');
-    if (state.status !== 'active' || state.stage !== 'review-repair' || state.invocation) {
-        throw new Error('direct review is not ready for Closure');
+export function prepareDirectReview(state, targetFingerprint, reviewerSessionId) {
+    assertSha256(targetFingerprint, 'direct review target fingerprint');
+    assertText(reviewerSessionId, 'direct review reviewer session ID');
+    if (state.status !== 'active' || state.stage !== 'review-repair') {
+        throw new Error('direct review is not ready for another review');
     }
     const targetRevision = state.targetRevision + 1;
     const defects = state.review.defects.map((defect) => defect.status === 'open' || defect.status === 'reopened'
@@ -186,53 +197,32 @@ export function prepareDirectReviewClosure(state, targetFingerprint) {
     const repairFindings = state.repairFindings.map((finding) => finding.status === 'open' || finding.status === 'reopened'
         ? { ...structuredClone(finding), status: 'fixed' }
         : structuredClone(finding));
-    const affectedIds = [
-        ...defects.filter((defect) => defect.status === 'fixed').map((defect) => defect.id),
-        ...repairFindings.filter((finding) => finding.status === 'fixed').map((finding) => finding.id),
-    ].sort();
-    if (affectedIds.length === 0)
-        throw new Error('direct review Closure has no fixed targets');
+    if (![...defects, ...repairFindings].some((item) => item.status === 'fixed'))
+        throw new Error('direct review has no fixed targets');
     const nextState = {
         ...structuredClone(state),
-        stage: 'review-closure',
+        stage: 'review',
         targetRevision,
         targetFingerprint,
+        previousTarget: structuredClone(state.previousTarget),
         review: {
             ...structuredClone(state.review),
-            mode: 'closure',
+            reviewerSessionId,
             reportRepairs: 0,
             transportRetries: 0,
             defects,
-            affectedDefectIds: affectedIds,
+            acceptedReportSha256: null,
         },
         repairFindings,
     };
-    const closureRequestSha256 = directReviewClosureRequestSha256(nextState);
-    return {
-        state: nextState,
-        closureRequestSha256,
-    };
-}
-export function directReviewClosureRequestSha256(state) {
-    if (state.status !== 'active' || state.stage !== 'review-closure' || state.review.mode !== 'closure') {
-        throw new Error('direct review state is not a code-review Closure');
-    }
-    return hashClosureRequest({
-        operation: 'code-review',
-        targetRevision: state.targetRevision,
-        targetFingerprint: state.targetFingerprint,
-        affectedDefectIds: state.review.affectedDefectIds,
-        fixedRepairFindings: state.repairFindings.filter((finding) => finding.status === 'fixed')
-            .map((finding) => ({ id: finding.id, affectedContracts: finding.affectedContracts })),
-        reviewFocus: ['acceptance-criteria', 'correctness', 'test-quality'],
-    });
+    return nextState;
 }
 export function projectTerminalDirectReview(state, terminalOutcome, terminalCode) {
     if (state.status === 'terminal')
         throw new Error('direct review terminal projection is immutable');
     if (terminalCode !== undefined)
         assertText(terminalCode, 'direct review terminal code');
-    const { invocation: _invocation, terminalCode: _priorCode, terminalOutcome: _priorOutcome, ...preserved } = structuredClone(state);
+    const { terminalCode: _priorCode, terminalOutcome: _priorOutcome, ...preserved } = structuredClone(state);
     return {
         ...preserved,
         status: 'terminal',
@@ -240,46 +230,27 @@ export function projectTerminalDirectReview(state, terminalOutcome, terminalCode
         terminalOutcome: structuredClone(terminalOutcome),
     };
 }
-export function canRecoverTerminalDirectReviewReport(state, options = {}) {
-    return state.status === 'terminal' && state.terminalOutcome?.status === 'internal-error'
-        && !state.invocation && state.stage !== null && state.stage !== 'review-repair'
-        && state.review.disposition === 'active' && state.review.reportRepairs > 0
-        && state.review.reportRepairs < MAX_DIRECT_REVIEW_REPORT_REPAIRS
-        && (state.terminalCode === 'direct-review-report-malformed'
-            || (state.terminalCode === undefined && options.allowLegacyMalformed === true));
-}
-export function recoverTerminalDirectReviewReport(state, options = {}) {
-    if (!canRecoverTerminalDirectReviewReport(state, options)) {
-        throw new Error('direct review terminal report is not recoverable');
-    }
-    const { terminalCode: _terminalCode, terminalOutcome: _terminalOutcome, ...withoutTerminal } = structuredClone(state);
-    return {
-        ...withoutTerminal,
-        status: 'active',
-        review: { ...withoutTerminal.review, transportRetries: 0 },
-    };
-}
 export function createInitialDirectReview(input) {
     assertSha256(input.targetFingerprint, 'direct review target fingerprint');
     assertText(input.codeReviewerSessionId, 'code reviewer session ID');
     return {
         version: 1,
         status: 'active',
-        stage: 'review-full',
+        stage: 'review',
         targetRevision: 1,
         targetFingerprint: input.targetFingerprint,
-        review: activeTrack(input.codeReviewerSessionId, 'full'),
+        previousTarget: null,
+        review: activeTrack(input.codeReviewerSessionId),
         repairFindings: [],
     };
 }
 export function validateDirectReview(value, context) {
     const optional = [
-        ...(hasOwn(value, 'invocation') ? ['invocation'] : []),
         ...(hasOwn(value, 'terminalCode') ? ['terminalCode'] : []),
         ...(hasOwn(value, 'terminalOutcome') ? ['terminalOutcome'] : []),
     ];
     assertExactObject(value, [
-        'version', 'status', 'stage', 'targetRevision', 'targetFingerprint', 'review', 'repairFindings', ...optional,
+        'version', 'status', 'stage', 'targetRevision', 'targetFingerprint', 'previousTarget', 'review', 'repairFindings', ...optional,
     ], 'direct review');
     if (value.version !== 1 || !['active', 'clear', 'terminal'].includes(value.status)) {
         throw new Error('direct review version/status is invalid');
@@ -289,8 +260,8 @@ export function validateDirectReview(value, context) {
     if (!Number.isSafeInteger(value.targetRevision) || value.targetRevision < 0)
         throw new Error('direct review target revision is invalid');
     assertSha256(value.targetFingerprint, 'direct review target fingerprint');
+    const previousTarget = validatePreviousTarget(value.previousTarget, value.targetRevision);
     const review = validateTrack(value.review, 'review', value.targetRevision);
-    const invocation = hasOwn(value, 'invocation') ? validateInvocation(value.invocation) : undefined;
     const repairFindings = validateRepairFindings(value.repairFindings, value.targetRevision);
     const terminalCode = hasOwn(value, 'terminalCode') ? value.terminalCode : undefined;
     if (terminalCode !== undefined)
@@ -304,7 +275,6 @@ export function validateDirectReview(value, context) {
         stage: value.stage,
         targetRevision: value.targetRevision,
         review,
-        invocation,
         repairFindings,
         terminalCode: terminalCode,
         terminalOutcome,
@@ -315,19 +285,43 @@ export function validateDirectReview(value, context) {
         stage: value.stage,
         targetRevision: value.targetRevision,
         targetFingerprint: value.targetFingerprint,
+        previousTarget,
         review,
-        ...(invocation ? { invocation } : {}),
         repairFindings,
         ...(terminalCode ? { terminalCode: terminalCode } : {}),
         ...(terminalOutcome ? { terminalOutcome } : {}),
     };
 }
+function validatePreviousTarget(value, targetRevision) {
+    if (value === null)
+        return null;
+    assertExactObject(value, ['targetRevision', 'targetFingerprint', 'candidateTreeSha'], 'direct review previous target');
+    if (!Number.isSafeInteger(value.targetRevision)
+        || (value.targetRevision !== targetRevision && value.targetRevision !== targetRevision - 1)) {
+        throw new Error('direct review previous target revision is invalid');
+    }
+    assertSha256(value.targetFingerprint, 'direct review previous target fingerprint');
+    assertGitSha(value.candidateTreeSha, 'direct review previous target tree');
+    return {
+        targetRevision: value.targetRevision,
+        targetFingerprint: value.targetFingerprint,
+        candidateTreeSha: value.candidateTreeSha,
+    };
+}
 function validateComposite(value, context) {
     if (value.status === 'terminal') {
-        if (value.stage === null || value.targetRevision < 1 || value.invocation || !value.terminalOutcome
+        if (value.stage === null || value.targetRevision < 1 || !value.terminalOutcome
             || !['blocked', 'transport-failed', 'cancelled', 'internal-error'].includes(context.lifecycle)) {
             throw new Error('terminal direct review composite is invalid');
         }
+        if (value.terminalOutcome.status === 'internal-error') {
+            if (value.terminalCode === undefined || value.terminalCode !== context.terminalCode) {
+                throw new Error('terminal direct review code does not match run terminal outcome');
+            }
+        }
+        else if (value.terminalCode !== undefined || context.terminalCode !== undefined) {
+            throw new Error('non-internal terminal direct review has a terminal code');
+        }
         return;
     }
     if (value.terminalOutcome || value.terminalCode)
@@ -335,36 +329,26 @@ function validateComposite(value, context) {
     if (value.stage === null || value.targetRevision < 1)
         throw new Error('active direct review requires a stage and revision');
     if (value.status === 'active') {
-        if (context.lifecycle !== 'implementing' && context.lifecycle !== 'safe-halt')
+        const allowed = value.stage === 'review'
+            ? ['checking', 'proving', 'reviewing', 'safe-halt']
+            : ['implementing', 'checking', 'proving', 'safe-halt'];
+        if (!allowed.includes(context.lifecycle))
             throw new Error('active direct review lifecycle is invalid');
         if (value.review.disposition !== 'active')
             throw new Error('active direct review stage has no active track');
-        validateStageFields(value.stage, value.review, value.invocation, value.repairFindings);
+        validateStageFields(value.stage, value.review, value.repairFindings);
     }
     else {
-        const proofSafeHalt = context.lifecycle === 'safe-halt' && context.process?.purpose === 'proof'
-            && context.process.resumeLifecycle === 'proving' && context.process.resumeReviewStage === null;
-        if ((!['checking', 'proving', 'publishing', 'review-ready'].includes(context.lifecycle) && !proofSafeHalt)
-            || value.invocation || value.review.disposition !== 'clear') {
+        if (!['publishing', 'safe-halt', 'review-ready'].includes(context.lifecycle)
+            || value.review.disposition !== 'clear') {
             throw new Error('clear direct review composite is invalid');
         }
     }
-    if (value.status === 'active' && context.lifecycle === 'safe-halt') {
-        const reviewProcess = context.process?.purpose === 'code-review'
-            && context.process.resumeLifecycle === 'implementing'
-            && context.process.resumeReviewStage === value.stage;
-        const feedbackImplementationProcess = value.stage === 'review-repair'
-            && context.process?.purpose === 'implementation'
-            && context.process.resumeLifecycle === 'implementing'
-            && context.process.resumeReviewStage === null;
-        if (!reviewProcess && !feedbackImplementationProcess)
-            throw new Error('safe-halt review stage/process mismatch');
-    }
 }
 function validateTerminalProjection(value, lifecycle) {
     if (lifecycle === 'blocked') {
         assertExactObject(value, ['status', 'kind'], 'direct review terminal outcome');
-        if (value.status !== 'blocked' || !['external', 'safety', 'exhausted'].includes(value.kind)) {
+        if (value.status !== 'blocked' || !['external', 'safety', 'decision-delta', 'out-of-scope', 'authority-boundary'].includes(value.kind)) {
             throw new Error('direct review blocked projection is invalid');
         }
     }
@@ -376,97 +360,53 @@ function validateTerminalProjection(value, lifecycle) {
     }
     return structuredClone(value);
 }
-function validateStageFields(stage, track, invocation, findings) {
-    const suffix = stage.split('-').at(-1);
-    if (suffix === 'full') {
-        if (track.mode !== 'full' || track.acceptedReportSha256 !== null || track.affectedDefectIds.length !== 0) {
-            throw new Error('Full review stage fields are invalid');
-        }
+function validateStageFields(stage, track, findings) {
+    if (stage === 'review') {
+        if (track.acceptedReportSha256 !== null)
+            throw new Error('review stage fields are invalid');
     }
-    else if (suffix === 'repair') {
-        if (invocation || track.acceptedReportSha256 === null || (track.defects.every((defect) => defect.status !== 'open' && defect.status !== 'reopened')
+    else {
+        if (track.acceptedReportSha256 === null || (track.defects.every((defect) => defect.status !== 'open' && defect.status !== 'reopened')
             && findings.every((finding) => finding.status !== 'open' && finding.status !== 'reopened'))) {
             throw new Error('review repair stage fields are invalid');
         }
     }
-    else if (track.mode !== 'closure' || track.acceptedReportSha256 === null || track.affectedDefectIds.length === 0
-        || !track.affectedDefectIds.every((id) => track.defects.some((defect) => defect.id === id && defect.status === 'fixed')
-            || findings.some((finding) => finding.id === id && finding.status === 'fixed'))) {
-        throw new Error('Closure review stage fields are invalid');
-    }
-    if (invocation) {
-        if (invocation.operation !== 'code-review' || invocation.mode !== track.mode || invocation.reviewerSessionId !== track.reviewerSessionId) {
-            throw new Error('review invocation does not match active stage');
-        }
-    }
 }
 function validateTrack(value, field, targetRevision) {
     assertExactObject(value, [
-        'version', 'disposition', 'profile', 'reviewerSessionId', 'mode', 'reportRepairs', 'transportRetries',
-        'coverage', 'defects', 'affectedDefectIds', 'acceptedReportSha256',
+        'version', 'disposition', 'profile', 'reviewerSessionId', 'reportRepairs', 'transportRetries',
+        'coverage', 'defects', 'acceptedReportSha256',
     ], `direct review ${field} track`);
     if (value.version !== 1 || !['active', 'clear'].includes(value.disposition)
         || !['simple', 'medium', 'high'].includes(value.profile)
-        || !isReportRepairCount(value.reportRepairs) || !isBit(value.transportRetries))
+        || !isNonNegativeInteger(value.reportRepairs) || !isNonNegativeInteger(value.transportRetries))
         throw new Error(`direct review ${field} track is invalid`);
     if (value.reviewerSessionId !== null)
         assertText(value.reviewerSessionId, `${field} reviewer session ID`);
-    if (value.mode !== null && value.mode !== 'full' && value.mode !== 'closure')
-        throw new Error(`${field} review mode is invalid`);
     const coverage = sortedUniqueStrings(value.coverage, `${field} coverage`);
-    const affectedDefectIds = sortedUniqueStrings(value.affectedDefectIds, `${field} affected defect IDs`);
     const defects = validateCodeReviewDefects(value.defects, targetRevision);
     if (value.acceptedReportSha256 !== null)
         assertSha256(value.acceptedReportSha256, `${field} accepted report hash`);
-    if (value.disposition === 'active' && (value.reviewerSessionId === null || value.mode === null))
+    if (value.disposition === 'active' && value.reviewerSessionId === null)
         throw new Error(`${field} active track lacks identity`);
-    if (value.disposition === 'clear' && (value.reviewerSessionId === null || value.mode === null || value.acceptedReportSha256 === null
-        || affectedDefectIds.length !== 0 || defects.some((defect) => (defect.class === 'blocker' || defect.class === 'execution-risk')
-        && defect.status !== 'verified' && defect.status !== 'superseded')))
+    if (value.disposition === 'clear' && (value.reviewerSessionId === null || value.acceptedReportSha256 === null
+        || defects.some((defect) => (defect.class === 'blocker' || defect.class === 'execution-risk')
+            && defect.status !== 'verified' && defect.status !== 'superseded')))
         throw new Error(`${field} clear track is invalid`);
     return {
         version: 1,
         disposition: value.disposition,
         profile: value.profile,
         reviewerSessionId: value.reviewerSessionId,
-        mode: value.mode,
         reportRepairs: value.reportRepairs,
         transportRetries: value.transportRetries,
         coverage,
         defects,
-        affectedDefectIds,
         acceptedReportSha256: value.acceptedReportSha256,
     };
 }
-function validateInvocation(value) {
-    assertExactObject(value, [
-        'attemptId', 'operation', 'mode', 'reviewerSessionId', 'targetRevision', 'targetFingerprint',
-        'closureRequestSha256', 'status', 'pid', 'processGroupId',
-    ], 'review invocation');
-    for (const field of ['attemptId', 'reviewerSessionId'])
-        assertText(value[field], `review invocation.${field}`);
-    if (value.operation !== 'code-review')
-        throw new Error('review invocation operation is invalid');
-    if (value.mode !== 'full' && value.mode !== 'closure')
-        throw new Error('review invocation mode is invalid');
-    if (!Number.isSafeInteger(value.targetRevision) || value.targetRevision < 1)
-        throw new Error('review invocation target revision is invalid');
-    assertSha256(value.targetFingerprint, 'review invocation target fingerprint');
-    if (value.closureRequestSha256 !== null)
-        assertSha256(value.closureRequestSha256, 'review invocation Closure hash');
-    if (!['prepared', 'launched', 'abandoned'].includes(value.status))
-        throw new Error('review invocation status is invalid');
-    const launched = value.status === 'launched';
-    if (launched !== (Number.isSafeInteger(value.pid) && value.pid > 0
-        && Number.isSafeInteger(value.processGroupId) && value.processGroupId > 0)) {
-        throw new Error('review invocation process identity is invalid');
-    }
-    if (!launched && (value.pid !== null || value.processGroupId !== null))
-        throw new Error('non-launched invocation has process identity');
-    return structuredClone(value);
-}
 function validateRepairFindings(value, targetRevision) {
-    if (!Array.isArray(value) || value.length > MAX_ITEMS)
+    if (!Array.isArray(value))
         throw new Error('direct repair findings are invalid');
     const findings = value.map((finding, index) => {
         assertExactObject(finding, ['id', 'provenance', 'sourceId', 'targetRevision', 'summary', 'affectedContracts', 'status'], `repair finding[${index}]`);
@@ -485,21 +425,20 @@ function validateRepairFindings(value, targetRevision) {
     assertUnique(findings.map((finding) => finding.id), 'repair finding IDs');
     return findings;
 }
-function activeTrack(reviewerSessionId, mode) {
+function activeTrack(reviewerSessionId) {
     return {
-        version: 1, disposition: 'active', profile: 'high', reviewerSessionId, mode,
-        reportRepairs: 0, transportRetries: 0, coverage: [], defects: [], affectedDefectIds: [], acceptedReportSha256: null,
+        version: 1, disposition: 'active', profile: 'high', reviewerSessionId,
+        reportRepairs: 0, transportRetries: 0, coverage: [], defects: [], acceptedReportSha256: null,
     };
 }
 function isStage(value) {
-    return ['review-full', 'review-repair', 'review-closure'].includes(value);
+    return value === 'review' || value === 'review-repair';
 }
-function isBit(value) { return value === 0 || value === 1; }
-function isReportRepairCount(value) {
-    return Number.isSafeInteger(value) && value >= 0 && value <= MAX_DIRECT_REVIEW_REPORT_REPAIRS;
+function isNonNegativeInteger(value) {
+    return Number.isSafeInteger(value) && value >= 0;
 }
 function sortedUniqueStrings(value, field) {
-    if (!Array.isArray(value) || value.length > MAX_ITEMS)
+    if (!Array.isArray(value))
         throw new Error(`${field} is invalid`);
     for (const item of value)
         assertText(item, `${field} entry`);
@@ -515,6 +454,10 @@ function assertSha256(value, field) {
     if (typeof value !== 'string' || !SHA256.test(value))
         throw new Error(`${field} is invalid`);
 }
+function assertGitSha(value, field) {
+    if (typeof value !== 'string' || !/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/u.test(value))
+        throw new Error(`${field} is invalid`);
+}
 function assertText(value, field) {
     if (typeof value !== 'string' || value.length === 0 || value.length > 16 * 1024)
         throw new Error(`${field} is invalid`);