codex-orchestrator 2.0.18 → 2.0.19

package/dist/src/v2/run-issue.js

@@ -7,11 +7,12 @@ import { adoptActiveAttempt, confirmActiveAttemptCleanup, createActiveAttempt, l
 import { validateImplementationReport } from './implementation-report.js';
 import { validateCompletedReport } from './contained-report-operation.js';
 import { directReviewCandidateTargetFingerprint, projectTerminalDirectReview, } from './direct-delivery.js';
+import { MAX_REVIEW_PATCH_BYTES } from './implementation-reviewer.js';
 import { CandidateProofInspectionError, ProofLaunchAuthorizationError } from './acceptance-proof.js';
 import { CheckProcessQuiescenceError, resolveIssueCheckPolicy } from './issue-check-policy.js';
 import { IssueInitializationUnrecoverableError, WorkflowGenerationUnrecoverableError, } from './run-store.js';
 import { createPendingEffect } from './run-store.js';
-import { blockReviewFeedback, initializeReviewFeedback, projectReviewFeedbackBatch, publishReviewFeedback, respondReviewFeedback, reserveNextReviewFeedbackRound, settleReviewFeedbackResponse, } from './review-feedback.js';
+import { blockReviewFeedback, initializeReviewFeedback, projectReviewFeedbackBatch, publishReviewFeedback, respondReviewFeedback, settleReviewFeedbackResponse, } from './review-feedback.js';
 import { createIssueDeliveryAuthority } from './delivery-authority.js';
 import { claimComment, claimRunId, freezeCriteria, historicalClaimCounts, isClaimMarkerComment, isExactClaimMarkerLine, isAdoptableAttempt, observedHistoricalClaimKeys, outcomeEvidenceBytes, publicOutcome, publicIssueSnapshot, refreshClaimedIssueSnapshot, snapshotIssue, sameInspectionIdentity, sameStrings, semanticChangesMatch, } from './run-state-projections.js';
 import { applyValidationTransition, nextValidationTransition, projectValidationFeedbackActivation, projectValidationProofPassed, projectValidationProofStart, projectValidationRepair, projectValidationReviewApproved, projectValidationReviewNeedsWork, projectValidationReviewReportRepair, projectValidationReviewTransportRetry, } from './validation-progression.js';
@@ -397,15 +398,15 @@ export class RunIssue {
                         if (recaptured.value.bindingId !== candidateBinding.bindingId) {
                             await candidate.releasePin({ binding: recaptured.value, expectedPinnedCommitSha: recaptured.value.candidateCommitSha });
                         }
-                        const released = await this.clearAndReleaseCandidate(active);
-                        if ('status' in released)
-                            return released;
-                        const reopened = await this.persist(released.active, {
-                            lifecycle: 'implementing',
-                            reviewFeedback: reserveNextReviewFeedbackRound(feedback),
-                            reworkFindings: ['The issue worktree changed after proof; rebuild and revalidate the review-feedback candidate.'],
-                            checks: [], checkedChangeSha256: undefined, proofId: undefined, proofReceipt: undefined,
-                        });
+                        const summary = 'The issue worktree changed after proof; rebuild and revalidate the review-feedback candidate.';
+                        const reopened = await this.startNextCycleFromCandidate(active, [summary], [{
+                                provenance: 'proof',
+                                sourceId: `proof:${active.record.proofId}:candidate-worktree-drift`,
+                                summary,
+                                affectedContracts: ['acceptance-proof'],
+                            }]);
+                        if ('status' in reopened)
+                            return reopened;
                         return this.invokedFailure(reopened, 'review-feedback-candidate-worktree-drift', 'The next review-feedback repair round is ready.');
                     }
                     active = await this.persist(active, { pendingEffect: {
@@ -847,6 +848,7 @@ export class RunIssue {
             activation.changes.checks = structuredClone(ready.record.checks);
             activation.changes.checkedChangeSha256 = ready.record.checkedChangeSha256;
             activation.changes.proofId = ready.record.proofId;
+            activation.changes.proofExecution = structuredClone(ready.record.proofExecution);
             activation.changes.proofReceipt = structuredClone(ready.record.proofReceipt);
             activation.changes.implementationResult = structuredClone(ready.record.implementationResult);
             activation.changes.terminalNotifications = undefined;
@@ -1370,6 +1372,10 @@ export class RunIssue {
                             transportRetries: active.record.transportRetries,
                             reportRepairs: 0,
                             implementationResult: { summary: report.summary, residualRisks: report.residualRisks },
+                            checkedChangeSha256: undefined,
+                            proofId: undefined,
+                            proofExecution: undefined,
+                            proofReceipt: undefined,
                         });
                         active = await this.clearAttempt(active);
                     }
@@ -1398,23 +1404,7 @@ export class RunIssue {
                 if (progression.phase !== 'checks' && progression.phase !== 'acceptance-proof') {
                     return await this.terminal(active, { status: 'internal-error', code: 'validation-progression-checks-invalid' });
                 }
-                let checkPolicy;
-                try {
-                    checkPolicy = resolveIssueCheckPolicy(active.record.issueSnapshot.body, config.checks);
-                }
-                catch (error) {
-                    const detail = error instanceof Error ? error.message : 'Verification policy is invalid.';
-                    return await this.terminal(active, {
-                        status: 'blocked', kind: 'decision-delta', resumable: false,
-                        blocker: {
-                            kind: 'decision-delta',
-                            summary: 'The unchanged issue Verification policy is malformed or unsafe and cannot be executed as authority.',
-                            attempted: ['Parsed the issue Verification section against the configured command safety policy.'],
-                            resumable: false,
-                            reviewerRejectionDetail: detail,
-                        },
-                    }, 'issue-verification-invalid');
-                }
+                const checkPolicy = resolveIssueCheckPolicy(active.record.issueSnapshot.body, config.checks);
                 const finalBinding = active.record.candidateBinding;
                 if (!finalBinding)
                     return await this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true }, 'candidate-git-v2-required');
@@ -1905,7 +1895,7 @@ export class RunIssue {
         if (Object.hasOwn(changes, 'terminalOutcome') && changes.terminalOutcome === undefined
             && !Object.hasOwn(changes, 'terminalNotifications'))
             delete record.terminalNotifications;
-        for (const key of ['checkedChangeSha256', 'proofId', 'proofReceipt', 'terminalOutcome', 'outcomeEvidenceId', 'reviewFeedback', 'changeBindingVersion', 'candidateBinding', 'candidateMaterialization', 'activeAttempt', 'terminalNotifications']) {
+        for (const key of ['checkedChangeSha256', 'proofId', 'proofExecution', 'proofReceipt', 'terminalOutcome', 'outcomeEvidenceId', 'reviewFeedback', 'changeBindingVersion', 'candidateBinding', 'candidateMaterialization', 'activeAttempt', 'terminalNotifications']) {
             if (Object.hasOwn(changes, key) && changes[key] === undefined)
                 delete record[key];
         }
@@ -2525,7 +2515,7 @@ export class RunIssue {
             throw new Error('review scope requires candidate identity');
         const completeDiff = await this.dependencies.git.diffTrees(active.record.worktreePath, active.record.baseSha, binding.candidateTreeSha);
         if (completeDiff.changedFiles.length === 0 || completeDiff.patch.trim().length === 0
-            || Buffer.byteLength(completeDiff.patch, 'utf8') > 1024 * 1024
+            || Buffer.byteLength(completeDiff.patch, 'utf8') > MAX_REVIEW_PATCH_BYTES
             || containsCredentialEvidence(completeDiff.patch)
             || completeDiff.changedFiles.some((path) => findDeniedPathMatch(path, deniedPaths))) {
             throw new Error('exact complete Review target is unavailable');
@@ -2578,7 +2568,7 @@ export class RunIssue {
             || defect.affectedTargets.some((target) => !directImpact.has(target)));
         const isolated = treeDiff.changedFiles.length > 0 && repairedBlockerIds.length > 0
             && treeDiff.patch.trim().length > 0
-            && Buffer.byteLength(treeDiff.patch, 'utf8') <= 1024 * 1024
+            && Buffer.byteLength(treeDiff.patch, 'utf8') <= MAX_REVIEW_PATCH_BYTES
             && !containsCredentialEvidence(treeDiff.patch)
             && !treeDiff.changedFiles.some((path) => findDeniedPathMatch(path, deniedPaths))
             && !retainedOutOfConeDefect;
@@ -2911,6 +2901,24 @@ export class RunIssue {
             return this.terminal(active, { status: 'transport-failed', resumable: proof.resumable });
         if (proof.status === 'cancelled')
             return this.terminal(active, { status: 'cancelled' });
+        if (proof.status === 'internal-error') {
+            try {
+                await this.dependencies.writeEvidence({
+                    runId: active.record.runId,
+                    code: 'acceptance-proof-diagnostic',
+                    summary: canonicalJson({
+                        summary: publicBlockedText(proof.receipt.summary, 'Proof failure detail was redacted.', 1024),
+                        packageVersion: active.record.packageVersion,
+                        workflowGenerationHash: active.record.workflowGeneration.generationHash,
+                        workflowManifestSha256: active.record.workflowGeneration.manifestSha256,
+                        candidateCommitSha: active.record.candidateBinding?.candidateCommitSha ?? null,
+                    }),
+                });
+            }
+            catch {
+                // Diagnostic storage is best-effort; it cannot authorize proof or prevent the safe terminal outcome.
+            }
+        }
         return this.terminal(active, { status: 'internal-error', code: 'acceptance-proof-internal-failure' });
     }
     async revoked(active) {