codex-orchestrator 2.0.10 → 2.0.11

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

@@ -1,13 +1,14 @@
-import { resolve } from 'node:path';
+import { dirname, resolve } from 'node:path';
 import { checkedChangePayloadSha256, } from './checked-change.js';
 import { parseAgentAutoConfig } from './config.js';
 import { canonicalJson, sha256 } from './containment.js';
 import { validateImplementationReport } from './implementation-report.js';
-import { acceptApprovedDirectReview, acceptNeedsWorkDirectReview, beginDirectReviewRepair, canRecoverTerminalDirectReviewReport, createInitialDirectReview, directReviewClosureRequestSha256, directReviewTargetFingerprint, launchDirectReviewInvocation, MAX_DIRECT_REVIEW_REPORT_REPAIRS, prepareDirectReviewClosure, prepareDirectReviewInvocation, projectTerminalDirectReview, recoverTerminalDirectReviewReport, } from './direct-delivery.js';
-import { ProofLaunchAuthorizationError, ProofQuiescenceError } from './acceptance-proof.js';
+import { acceptApprovedDirectReview, acceptNeedsWorkDirectReview, beginDirectReviewRepair, createInitialDirectReview, directReviewCandidateTargetFingerprint, directReviewClosureRequestSha256, MAX_DIRECT_REVIEW_REPORT_REPAIRS, prepareDirectReviewClosure, projectTerminalDirectReview, } from './direct-delivery.js';
+import { CandidateProofInspectionError, ProofLaunchAuthorizationError } from './acceptance-proof.js';
 import { CheckProcessQuiescenceError, resolveIssueCheckPolicy } from './issue-check-policy.js';
 import { RouteInitializationUnrecoverableError, WorkflowGenerationUnrecoverableError, } from './run-store.js';
 import { initialRouteExecution, } from './route-coordinator.js';
+import { reserveSpecAuthorSession, reserveSpecReviewerSession } from './spec-delivery.js';
 import { downstreamLifecycleForRoute, validateRouteTransition, validateTrustedAnswerResumeTransition, } from './route-decision.js';
 import { activateReviewFeedback, blockReviewFeedback, bootstrapReviewFeedback, markReviewFeedbackPublishing, markReviewFeedbackRepairing, markReviewFeedbackVerified, projectReviewFeedbackBatch, publishReviewFeedback, reserveNextReviewFeedbackRound, } from './review-feedback.js';
 export class OwnerLockSafetyError extends Error {
@@ -71,6 +72,7 @@ export class RunIssue {
             }
             if (comments.length === 0) {
                 try {
+                    await this.markV3ExternalEffect(active);
                     await this.dependencies.issues.postComment(issueNumber, body);
                 }
                 catch {
@@ -105,6 +107,7 @@ export class RunIssue {
             return { result: await this.publicationDiverged(active, 'claim-labels-intent-diverged') };
         }
         try {
+            await this.markV3ExternalEffect(active);
             await this.dependencies.issues.setLabels(issueNumber, expectedLabels);
         }
         catch {
@@ -122,7 +125,99 @@ export class RunIssue {
         const { runId, branchName, worktreePath, baseSha } = active.record;
         const message = `feat: implement #${issueNumber}`;
         let commitSha = await this.dependencies.git.getHead(worktreePath);
-        if (active.record.intent?.kind === 'commit' || !active.record.intent) {
+        const candidateBinding = active.record.candidateBinding;
+        if (candidateBinding) {
+            const candidate = this.dependencies.git.candidateV2;
+            if (!candidate)
+                return this.persistRetainedCommitIntentTerminal(active, 'candidate-git-v2-required');
+            if (!active.record.intent) {
+                if (commitSha !== candidateBinding.expectedHeadSha)
+                    return this.persistCandidateEvidenceSafetyTerminal(active, 'candidate-branch-diverged-without-intent');
+                const recaptured = await candidate.captureAndPin({
+                    worktreePath,
+                    expectedHeadSha: candidateBinding.expectedHeadSha,
+                    runId,
+                    boundary: { kind: 'implementation-cycle', cycle: active.record.cycle },
+                    artifactDir: config.proof.artifactDir,
+                });
+                if (recaptured.kind === 'failed')
+                    return this.mapCandidateFailure(active, recaptured.code);
+                if (recaptured.value.bindingId !== candidateBinding.bindingId
+                    || recaptured.value.candidateTreeSha !== candidateBinding.candidateTreeSha
+                    || !sameStrings(recaptured.value.canonicalChangedFiles, candidateBinding.canonicalChangedFiles)) {
+                    if (recaptured.value.bindingId !== candidateBinding.bindingId) {
+                        await candidate.releasePin({ binding: recaptured.value, expectedPinnedCommitSha: recaptured.value.candidateCommitSha });
+                    }
+                    if (this.repairBudgetExhausted(active, config.runner.maxCycles)) {
+                        const released = await this.clearAndReleaseCandidate(active);
+                        return 'status' in released
+                            ? released
+                            : this.terminal(released.active, { status: 'blocked', kind: 'exhausted', resumable: true }, 'candidate-worktree-drift');
+                    }
+                    const reopened = await this.startNextCycleFromCandidate(active, ['The issue worktree changed after proof; review the new candidate.']);
+                    if ('status' in reopened)
+                        return reopened;
+                    return this.invokedFailure(reopened, 'candidate-worktree-drift', 'The mutable issue worktree changed after proof; the next bounded repair cycle is ready.');
+                }
+                active = await this.persist(active, { intent: {
+                        kind: 'commit',
+                        parentSha: candidateBinding.expectedHeadSha,
+                        treeSha: candidateBinding.candidateTreeSha,
+                        message,
+                        candidateRef: candidateBinding.candidateRef,
+                    } });
+            }
+            const intent = active.record.intent;
+            if (intent?.kind !== 'commit' || intent.parentSha !== candidateBinding.expectedHeadSha
+                || intent.treeSha !== candidateBinding.candidateTreeSha || intent.message !== message
+                || intent.candidateRef !== candidateBinding.candidateRef) {
+                return this.persistRetainedCommitIntentTerminal(active, 'candidate-commit-intent-diverged');
+            }
+            if (this.signal.aborted)
+                return await this.persistRetainedCommitIntentTerminal(active, 'candidate-publication-cancelled');
+            if (!await this.authorized(active, config))
+                return await this.persistRetainedCommitIntentTerminal(active, 'candidate-publication-authority-revoked');
+            await this.markV3ExternalEffect(active);
+            const publication = await candidate.createOrObserveCommit({
+                worktreePath,
+                branchName,
+                parentSha: intent.parentSha,
+                treeSha: intent.treeSha,
+                message: intent.message,
+                candidateRef: intent.candidateRef,
+            });
+            if (publication.kind === 'failed') {
+                return publication.code === 'candidate-ref-update-unknown'
+                    ? this.persistTerminal(active, { status: 'transport-failed', resumable: false }, publication.code, true)
+                    : this.mapCandidateFailure(active, publication.code);
+            }
+            if (publication.value.kind === 'parent-unchanged')
+                return this.invokedFailure(active, 'candidate-branch-update-not-observed');
+            if (publication.value.kind === 'branch-diverged')
+                return this.persistRetainedCommitIntentTerminal(active, 'candidate-branch-diverged');
+            commitSha = publication.value.sha;
+            const normalized = await candidate.normalizeSharedIndex({ worktreePath, expectedHeadSha: commitSha });
+            if (normalized.kind === 'failed')
+                return this.mapCandidateFailure(active, normalized.code);
+            const residual = await this.dependencies.git.listChangedFilesIgnoringUntrackedRoot(worktreePath, config.proof.artifactDir);
+            if (residual.length > 0)
+                return this.persistRetainedCommitIntentTerminal(active, 'candidate-residual-worktree-drift');
+            try {
+                active = await this.persist(active, {
+                    intent: { kind: 'push', branch: branchName, sha: commitSha },
+                    changeBindingVersion: undefined,
+                    candidateBinding: undefined,
+                });
+            }
+            catch {
+                throw new PostEffectStateError(active);
+            }
+            const released = await candidate.releasePin({ binding: candidateBinding, expectedPinnedCommitSha: candidateBinding.candidateCommitSha });
+            if (released.kind === 'failed') {
+                return this.invokedFailure(active, 'candidate-pin-release-unknown', 'The publication commit is confirmed; orphan reconciliation will retry exact pin cleanup.');
+            }
+        }
+        else if (active.record.intent?.kind === 'commit' || !active.record.intent) {
             if (!active.record.intent) {
                 if (commitSha === baseSha) {
                     active = await this.persist(active, {
@@ -206,6 +301,7 @@ export class RunIssue {
                 if (!await this.authorized(active, config))
                     return await this.revoked(active);
                 try {
+                    await this.markV3ExternalEffect(active);
                     await this.dependencies.pullRequests.createDraft({
                         title: `Implement #${issueNumber}: ${issue.title}`,
                         body: prBody,
@@ -246,6 +342,7 @@ export class RunIssue {
                 if (!await this.authorized(active, config))
                     return await this.revoked(active);
                 try {
+                    await this.markV3ExternalEffect(active);
                     await this.dependencies.issues.postComment(issueNumber, handoffBody);
                 }
                 catch {
@@ -272,6 +369,7 @@ export class RunIssue {
                 if (!await this.authorized(active, config))
                     return await this.revoked(active);
                 try {
+                    await this.markV3ExternalEffect(active);
                     await this.dependencies.issues.setLabels(issueNumber, terminalLabels);
                 }
                 catch {
@@ -290,7 +388,7 @@ export class RunIssue {
                 ...(active.record.routeReceipt?.route === 'direct' ? {
                     reviewFeedback: bootstrapReviewFeedback(active.record.reviewFeedback ?? {
                         version: 1, phase: 'bootstrap-required', consumedSourceIds: [], previousPublishedHeadSha: null,
-                        repairRound: 0, activeBatch: null, implementationInvocation: null, history: [],
+                        repairRound: 0, activeBatch: null, history: [],
                         verifiedReceipt: null, terminal: null,
                     }, commitSha, []),
                 } : {}),
@@ -323,7 +421,105 @@ export class RunIssue {
                 return this.blockReviewFeedback(active, 'safety', 'review-feedback-update-baseline-diverged');
             }
         }
-        if (!active.record.intent || active.record.intent.kind === 'review-update-commit') {
+        const candidateBinding = active.record.candidateBinding;
+        if (candidateBinding) {
+            const candidate = this.dependencies.git.candidateV2;
+            if (!candidate)
+                return this.persistRetainedCommitIntentTerminal(active, 'candidate-git-v2-required');
+            if (!active.record.intent) {
+                const recaptured = await candidate.captureAndPin({
+                    worktreePath: active.record.worktreePath,
+                    expectedHeadSha: oldHead,
+                    runId: active.record.runId,
+                    boundary: {
+                        kind: 'review-feedback', batchId: batch.batchId,
+                        repairRound: feedback.repairRound,
+                    },
+                    artifactDir: config.proof.artifactDir,
+                });
+                if (recaptured.kind === 'failed')
+                    return this.mapCandidateFailure(active, recaptured.code);
+                if (recaptured.value.bindingId !== candidateBinding.bindingId
+                    || recaptured.value.candidateTreeSha !== candidateBinding.candidateTreeSha
+                    || !sameStrings(recaptured.value.canonicalChangedFiles, candidateBinding.canonicalChangedFiles)) {
+                    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;
+                    if (feedback.repairRound >= 3) {
+                        return this.blockReviewFeedback(released.active, 'exhausted', 'review-feedback-candidate-worktree-drift');
+                    }
+                    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,
+                    });
+                    return this.invokedFailure(reopened, 'review-feedback-candidate-worktree-drift', 'The next review-feedback repair round is ready.');
+                }
+                active = await this.persist(active, { intent: {
+                        kind: 'review-update-commit', batchId: batch.batchId, parentSha: oldHead,
+                        treeSha: candidateBinding.candidateTreeSha, message, candidateRef: candidateBinding.candidateRef,
+                    } });
+            }
+            const intent = active.record.intent;
+            if (intent?.kind !== 'review-update-commit' || intent.batchId !== batch.batchId
+                || intent.parentSha !== oldHead || intent.treeSha !== candidateBinding.candidateTreeSha
+                || intent.message !== message || intent.candidateRef !== candidateBinding.candidateRef) {
+                return this.persistRetainedCommitIntentTerminal(active, 'review-feedback-candidate-intent-diverged');
+            }
+            if (!await this.authorized(active, config))
+                return this.persistRetainedCommitIntentTerminal(active, 'review-feedback-publication-authority-revoked');
+            const validation = await coordinator.revalidate({ batch, epoch: 'pre-update', expectedHeadSha: oldHead });
+            const validationFailure = await this.mapFeedbackRevalidation(active, validation, 'review-feedback-precommit-revalidation-failed');
+            if (validationFailure)
+                return validationFailure;
+            await this.markV3ExternalEffect(active);
+            const publication = await candidate.createOrObserveCommit({
+                worktreePath: active.record.worktreePath,
+                branchName: active.record.branchName,
+                parentSha: intent.parentSha,
+                treeSha: intent.treeSha,
+                message: intent.message,
+                candidateRef: intent.candidateRef,
+            });
+            if (publication.kind === 'failed') {
+                return publication.code === 'candidate-ref-update-unknown'
+                    ? this.persistTerminal(active, { status: 'transport-failed', resumable: false }, publication.code, true)
+                    : this.mapCandidateFailure(active, publication.code);
+            }
+            if (publication.value.kind === 'parent-unchanged')
+                return this.invokedFailure(active, 'review-feedback-candidate-branch-update-not-observed');
+            if (publication.value.kind === 'branch-diverged')
+                return this.persistRetainedCommitIntentTerminal(active, 'candidate-branch-diverged');
+            head = publication.value.sha;
+            const normalized = await candidate.normalizeSharedIndex({ worktreePath: active.record.worktreePath, expectedHeadSha: head });
+            if (normalized.kind === 'failed')
+                return this.mapCandidateFailure(active, normalized.code);
+            if ((await this.dependencies.git.listChangedFilesIgnoringUntrackedRoot(active.record.worktreePath, config.proof.artifactDir)).length > 0) {
+                return this.persistRetainedCommitIntentTerminal(active, 'candidate-residual-worktree-drift');
+            }
+            try {
+                active = await this.persist(active, {
+                    intent: {
+                        kind: 'review-update-push', batchId: batch.batchId, branch: active.record.branchName,
+                        priorRemoteSha: oldHead, sha: head, treeSha: candidateBinding.candidateTreeSha,
+                    },
+                    changeBindingVersion: undefined,
+                    candidateBinding: undefined,
+                });
+            }
+            catch {
+                throw new PostEffectStateError(active);
+            }
+            const released = await candidate.releasePin({ binding: candidateBinding, expectedPinnedCommitSha: candidateBinding.candidateCommitSha });
+            if (released.kind === 'failed') {
+                return this.invokedFailure(active, 'candidate-pin-release-unknown', 'The review update commit is confirmed; orphan reconciliation will retry exact pin cleanup.');
+            }
+        }
+        else if (!active.record.intent || active.record.intent.kind === 'review-update-commit') {
             if (!active.record.intent) {
                 active = await this.persist(active, { intent: {
                         kind: 'review-update-commit', batchId: batch.batchId, parentSha: oldHead,
@@ -447,6 +643,7 @@ export class RunIssue {
                     return this.blockReviewFeedback(active, 'safety', 'review-feedback-publication-authority-revoked');
                 }
                 try {
+                    await this.markV3ExternalEffect(active);
                     await this.dependencies.pullRequests.postConversationComment(batch.pullRequest.number, body);
                 }
                 catch {
@@ -496,6 +693,7 @@ export class RunIssue {
                     return this.blockReviewFeedback(active, 'safety', 'review-feedback-publication-authority-revoked');
                 }
                 try {
+                    await this.markV3ExternalEffect(active);
                     await this.dependencies.issues.setLabels(issueNumber, finalLabels);
                 }
                 catch {
@@ -533,19 +731,31 @@ export class RunIssue {
         }
         return publicOutcome(outcome);
     }
-    async continueReviewReady(starting, targetRoot, config) {
+    async continueReviewReady(starting, targetRoot, config, initialIssue) {
         const terminal = starting.record.terminalOutcome;
         const feedback = starting.record.reviewFeedback;
         if (!terminal || terminal.status !== 'review-ready' || !feedback || !this.dependencies.reviewFeedback
             || starting.record.routeReceipt?.route !== 'direct' || starting.record.directReview?.status !== 'clear') {
             return { result: publicOutcome(terminal) };
         }
-        const pullRequest = await this.dependencies.pullRequests.findOpen({
-            headBranch: starting.record.branchName,
-            baseBranch: config.github.baseBranch,
-        });
+        const reviewLabels = [config.github.labels.review.name];
+        const initialAuthority = this.reviewReadyIssueAuthority(initialIssue, starting.record);
+        if (!initialAuthority)
+            return { result: await this.invokedFailure(starting, 'review-feedback-issue-observation-incomplete') };
+        if (!sameStrings(initialAuthority.labels, reviewLabels))
+            return { result: publicOutcome(terminal) };
+        let pullRequest;
+        try {
+            pullRequest = await this.dependencies.pullRequests.findOpen({
+                headBranch: starting.record.branchName,
+                baseBranch: config.github.baseBranch,
+            });
+        }
+        catch {
+            return { result: await this.invokedFailure(starting, 'review-feedback-pr-observation-incomplete') };
+        }
         if (!pullRequest?.number || !pullRequest.nodeId || !pullRequest.headSha) {
-            return { result: await this.reviewReadyObservationBlocked(starting, 'review-feedback-pr-identity-missing') };
+            return { result: await this.invokedFailure(starting, 'review-feedback-pr-observation-incomplete') };
         }
         const expectedHeadSha = feedback.phase === 'bootstrap-required'
             ? pullRequest.headSha
@@ -562,12 +772,33 @@ export class RunIssue {
             expectedBaseRefName: config.github.baseBranch,
             marker: `<!-- codex-orchestrator:run:${starting.record.runId}:pr -->`,
             consumedSourceIds: feedback.consumedSourceIds,
+            restPullRequest: {
+                number: pullRequest.number, nodeId: pullRequest.nodeId, headSha: pullRequest.headSha, body: pullRequest.body,
+            },
         });
         if (observed.status === 'retryable')
             return { result: await this.invokedFailure(starting, 'review-feedback-observation-retryable') };
         if (observed.status === 'blocked') {
             return { result: await this.reviewReadyObservationBlocked(starting, 'review-feedback-observation-blocked') };
         }
+        const willPersistFeedback = feedback.phase === 'bootstrap-required'
+            || (feedback.phase === 'idle' && observed.status === 'frozen');
+        if (willPersistFeedback) {
+            let currentIssue;
+            try {
+                currentIssue = await this.readIssue(starting.record.issueNumber);
+            }
+            catch {
+                return { result: await this.invokedFailure(starting, 'review-feedback-issue-observation-incomplete') };
+            }
+            const currentAuthority = this.reviewReadyIssueAuthority(currentIssue, starting.record);
+            if (!currentAuthority || canonicalJson(currentAuthority) !== canonicalJson(initialAuthority)) {
+                return { result: await this.invokedFailure(starting, 'review-feedback-issue-observation-torn') };
+            }
+            if (currentAuthority.state !== 'OPEN' || !currentAuthority.trustedClaim) {
+                return { result: await this.reviewReadyObservationBlocked(starting, 'review-feedback-claim-authority-diverged') };
+            }
+        }
         if (feedback.phase === 'bootstrap-required') {
             const sourceIds = observed.status === 'frozen'
                 ? observed.batch.sources.map((source) => source.sourceId)
@@ -579,9 +810,6 @@ export class RunIssue {
         }
         if (feedback.phase !== 'idle' || observed.status === 'none')
             return { result: publicOutcome(terminal) };
-        if (!await this.authorizedForExactLabels(starting, [config.github.labels.review.name])) {
-            return { result: publicOutcome(terminal) };
-        }
         const projected = projectReviewFeedbackBatch(observed.batch, starting.record.directReview.targetRevision);
         const repairReview = beginDirectReviewRepair(starting.record.directReview, projected.repairFindings);
         let active = await this.persist(starting, {
@@ -589,11 +817,10 @@ export class RunIssue {
             reviewFeedback: activateReviewFeedback(feedback, observed.batch),
             directReview: {
                 ...repairReview,
-                review: { ...repairReview.review, reportRepairs: 0, transportRetries: 0 },
+                review: { ...repairReview.review, reportRepairs: 0 },
             },
             reworkFindings: projected.repairFindings.map((finding) => finding.summary),
             reportRepairs: 0,
-            transportRetries: 0,
             checks: [],
             checkedChangeSha256: undefined,
             proofId: undefined,
@@ -609,6 +836,11 @@ export class RunIssue {
         });
         return this.resumeActivatedReviewFeedback(active, targetRoot, config);
     }
+    reviewReadyIssueAuthority(issue, record) {
+        if (!issue)
+            return undefined;
+        return { state: issue.state, labels: sortedUnique(issue.labels), trustedClaim: this.hasTrustedClaim(issue, record) };
+    }
     async resumeActivatedReviewFeedback(starting, targetRoot, config) {
         let active = starting;
         const feedback = active.record.reviewFeedback;
@@ -642,6 +874,7 @@ export class RunIssue {
             return { result: validationFailure };
         if (labelsAreReview) {
             try {
+                await this.markV3ExternalEffect(active);
                 await this.dependencies.issues.setLabels(active.record.issueNumber, runningLabels);
             }
             catch {
@@ -707,7 +940,6 @@ export class RunIssue {
     async runIssue(input) {
         let owner;
         let active;
-        let recoveredFeedbackImplementation;
         try {
             assertPositiveInteger(input.issueNumber, 'issueNumber');
             const targetRoot = resolve(input.targetRoot);
@@ -734,12 +966,16 @@ export class RunIssue {
                 return await this.preClaimInternal('state-write-failed', input.issueNumber);
             }
             const confirmedConfig = await this.readStrictConfig(targetRoot);
-            if (!confirmedConfig.bytes.equals(initialConfig.bytes)
-                || canonicalRepository !== `${confirmedConfig.config.github.owner.toLowerCase()}/${confirmedConfig.config.github.repo.toLowerCase()}`) {
+            if (!confirmedConfig.bytes.equals(initialConfig.bytes) || canonicalRepository !== `${confirmedConfig.config.github.owner.toLowerCase()}/${confirmedConfig.config.github.repo.toLowerCase()}`) {
                 return await this.preClaimInternal('config-changed-during-owner-acquire', input.issueNumber);
             }
             const config = confirmedConfig.config;
-            if (this.signal.aborted)
+            const persisted = await this.dependencies.runRecords.read();
+            const matchingRuns = persisted.runs.filter((run) => run.issueNumber === input.issueNumber && run.canonicalRepository === canonicalRepository);
+            if (matchingRuns.length > 1)
+                return await this.preClaimInternal('ambiguous-run-state', input.issueNumber);
+            const existing = matchingRuns[0];
+            if (this.signal.aborted && existing?.lifecycle !== 'proving')
                 return await this.preClaimCancelled(input.issueNumber);
             let issue;
             try {
@@ -748,11 +984,24 @@ export class RunIssue {
             catch {
                 return await this.preClaimTransport(input.issueNumber);
             }
-            const persisted = await this.dependencies.runRecords.read();
-            const matchingRuns = persisted.runs.filter((run) => run.issueNumber === input.issueNumber && run.canonicalRepository === canonicalRepository);
-            if (matchingRuns.length > 1)
-                return await this.preClaimInternal('ambiguous-run-state', input.issueNumber);
-            const existing = matchingRuns[0];
+            if (this.dependencies.git.candidateV2?.reconcileOrphans) {
+                const reconciled = await this.dependencies.git.candidateV2.reconcileOrphans({
+                    repositoryRoot: targetRoot,
+                    workspaceRoot: resolve(targetRoot, config.runner.workspaceRoot),
+                    activeCandidateRefs: persisted.runs.flatMap((run) => run.candidateBinding ? [run.candidateBinding.candidateRef] : []),
+                    pendingCandidates: persisted.runs.flatMap((run) => {
+                        const boundary = pendingCandidateBoundary(run);
+                        return !run.terminalOutcome && !run.candidateBinding && boundary
+                            ? [{ runId: run.runId, worktreePath: run.worktreePath, expectedHeadSha: expectedImplementationHead(run), boundary, artifactDir: config.proof.artifactDir }]
+                            : [];
+                    }),
+                    activeExecutions: persisted.runs.flatMap((run) => run.executionLease
+                        ? [{ path: run.executionLease.path, candidateCommitSha: run.executionLease.candidateCommitSha }]
+                        : []),
+                });
+                if (reconciled.kind === 'failed')
+                    return this.preClaimTransport(input.issueNumber);
+            }
             let issueSnapshot;
             let frozenCriteria;
             let runId;
@@ -787,15 +1036,21 @@ export class RunIssue {
                     && blockedLabelProjection(issue.labels, config).status !== 'settled') {
                     return await this.reconcilePersistedBlockedTerminal(active, issue, existing.terminalOutcome);
                 }
-                if (existing.terminalOutcome) {
-                    if (existing.terminalOutcome.status !== 'review-ready') {
-                        const recovered = await this.recoverTerminalReviewReport(active, issue, config, frozenCriteria);
-                        if (!recovered)
-                            return publicOutcome(existing.terminalOutcome);
-                        active = recovered;
+                if (active.record.terminalOutcome?.status === 'transport-failed'
+                    && !active.record.terminalOutcome.resumable
+                    && active.record.candidateBinding
+                    && (active.record.intent?.kind === 'commit' || active.record.intent?.kind === 'review-update-commit')) {
+                    const reconciled = await this.reconcileUnknownCandidatePublication(active);
+                    if ('status' in reconciled)
+                        return reconciled;
+                    active = reconciled.active;
+                }
+                if (active.record.terminalOutcome) {
+                    if (active.record.terminalOutcome.status !== 'review-ready') {
+                        return publicOutcome(active.record.terminalOutcome);
                     }
                     else {
-                        const continuation = await this.continueReviewReady(active, targetRoot, config);
+                        const continuation = await this.continueReviewReady(active, targetRoot, config, issue);
                         if ('result' in continuation)
                             return continuation.result;
                         active = continuation.active;
@@ -803,18 +1058,42 @@ export class RunIssue {
                         frozenCriteria = structuredClone(active.record.frozenCriteria);
                     }
                 }
+                const canonicalReviewRecovery = active.record.executionLease?.operation === 'direct-review'
+                    && active.record.reportInvocation?.operation === 'code-review';
+                const canonicalProofRecovery = active.record.lifecycle === 'proving'
+                    && active.record.executionLease?.operation === 'acceptance-proof';
+                if (active.record.executionLease && !canonicalReviewRecovery && !canonicalProofRecovery) {
+                    const reconciled = await this.reconcilePersistedCandidateExecution(active, config);
+                    if ('status' in reconciled)
+                        return reconciled;
+                    active = reconciled.active;
+                }
+                if (active.state.version === 2 && active.record.lifecycle === 'proving'
+                    && active.record.routeReceipt?.route === 'direct') {
+                    const cutover = await this.cutoverLegacyImmutableBoundary(active, config, frozenCriteria);
+                    if ('status' in cutover)
+                        return cutover;
+                    active = cutover.active;
+                }
+                else if (active.state.version === 2 && active.record.lifecycle === 'checking'
+                    && active.record.routeReceipt?.route === 'direct') {
+                    const cutover = await this.cutoverLegacyImmutableBoundary(active, config, frozenCriteria);
+                    if ('status' in cutover)
+                        return cutover;
+                    active = cutover.active;
+                }
                 if (active.record.reviewFeedback?.phase === 'frozen') {
                     const activation = await this.resumeActivatedReviewFeedback(active, targetRoot, config);
                     if ('result' in activation)
                         return activation.result;
                     active = activation.active;
                 }
-                if (existing.lifecycle === 'publishing') {
+                if (active.record.lifecycle === 'publishing') {
                     return active.record.reviewFeedback?.activeBatch
                         ? await this.updateExistingPullRequest(active, config, input.issueNumber)
                         : await this.publish(active, config, issueSnapshot, input.issueNumber);
                 }
-                if (existing.lifecycle === 'claimed') {
+                if (active.record.lifecycle === 'claimed') {
                     const claim = await this.reconcileClaim(active, config);
                     if ('result' in claim)
                         return claim.result;
@@ -841,19 +1120,7 @@ export class RunIssue {
                     issueSnapshot = structuredClone(active.record.issueSnapshot);
                 }
                 else {
-                    if (existing.lifecycle === 'safe-halt') {
-                        const process = existing.process;
-                        if (!process)
-                            return await this.publicationDiverged(active, 'safe-halt-process-missing');
-                        try {
-                            await this.dependencies.waitForReviewProcessAbsence(process.processGroupId);
-                        }
-                        catch {
-                            return await this.invokedFailure(active, 'safe-halt-process-absence-unconfirmed');
-                        }
-                        active = await this.persist(active, { lifecycle: process.resumeLifecycle, process: undefined });
-                    }
-                    if (existing.lifecycle === 'waiting-human') {
+                    if (active.record.lifecycle === 'waiting-human') {
                         const waiting = await this.continueWaitingHuman(active);
                         if ('result' in waiting)
                             return waiting.result;
@@ -861,46 +1128,15 @@ export class RunIssue {
                         issueSnapshot = structuredClone(active.record.issueSnapshot);
                         frozenCriteria = structuredClone(active.record.frozenCriteria);
                     }
-                    if (existing.lifecycle === 'spec-authoring') {
+                    if (active.record.lifecycle === 'spec-authoring') {
                         if (!await this.authorized(active, config))
                             return await this.revoked(active);
                         return await this.continueSpecRequired(active);
                     }
-                    const feedbackInvocation = active.record.reviewFeedback?.implementationInvocation;
-                    if (feedbackInvocation?.phase === 'prepared') {
-                        return await this.blockReviewFeedback(active, 'safety', 'review-feedback-implementation-launch-ambiguous');
-                    }
-                    if (feedbackInvocation?.phase === 'launched') {
-                        try {
-                            await this.dependencies.waitForReviewProcessAbsence(feedbackInvocation.processGroupId);
-                        }
-                        catch {
-                            return await this.blockReviewFeedback(active, 'safety', 'review-feedback-implementation-process-absence-unconfirmed');
-                        }
-                        if (!this.dependencies.implementationAgent.recover) {
-                            return await this.blockReviewFeedback(active, 'safety', 'review-feedback-implementation-report-recovery-unavailable');
-                        }
-                        try {
-                            recoveredFeedbackImplementation = await this.dependencies.implementationAgent.recover({
-                                runId: active.record.runId,
-                                canonicalRepository: active.record.canonicalRepository,
-                                invocation: feedbackInvocation,
-                            });
-                        }
-                        catch {
-                            return await this.blockReviewFeedback(active, 'safety', 'review-feedback-implementation-report-recovery-failed');
-                        }
-                        if (!recoveredFeedbackImplementation) {
-                            const snapshot = await this.dependencies.git.snapshot(active.record.worktreePath);
-                            if (!sameFreshness(snapshot, feedbackInvocation.baseline)) {
-                                return await this.blockReviewFeedback(active, 'safety', 'review-feedback-implementation-worktree-ambiguous');
-                            }
-                        }
-                    }
                     if (!['triaging', 'routed', 'implementing', 'reworking', 'checking', 'proving'].includes(active.record.lifecycle)) {
                         return await this.terminal(active, { status: 'internal-error', code: 'resume-phase-not-reconciled' });
                     }
-                    if (!await this.authorized(active, config))
+                    if (active.record.lifecycle !== 'proving' && !await this.authorized(active, config))
                         return await this.revoked(active);
                     if (active.record.lifecycle !== 'triaging' && active.record.lifecycle !== 'routed') {
                         if (!active.record.routeExecution || !active.record.routeReceipt)
@@ -911,12 +1147,13 @@ export class RunIssue {
                             && active.record.directReview?.status === 'clear';
                         const proofRecovery = active.record.lifecycle === 'proving'
                             && active.record.directReview?.status === 'clear';
-                        const feedbackRepair = active.record.reviewFeedback?.phase === 'repairing'
-                            && active.record.directReview?.stage === 'review-repair';
+                        const directReviewRepair = active.record.lifecycle === 'implementing'
+                            && active.record.directReview?.status === 'active'
+                            && active.record.directReview.stage === 'review-repair';
+                        const mutableRecovery = active.record.lifecycle === 'implementing' && active.record.mutableInvocation !== undefined;
                         const qualificationRecovery = active.record.lifecycle === 'implementing'
-                            && !active.record.directReview
-                            && !this.hasRecordedImplementationStart(active.record, config);
-                        if (!reviewRecovery && !checkRecovery && !proofRecovery && !feedbackRepair && !qualificationRecovery) {
+                            && !active.record.directReview;
+                        if (!reviewRecovery && !checkRecovery && !proofRecovery && !directReviewRepair && !qualificationRecovery && !mutableRecovery) {
                             if (this.repairBudgetExhausted(active, config.runner.maxCycles)) {
                                 return await this.terminal(active, { status: 'blocked', kind: 'exhausted', resumable: true });
                             }
@@ -937,7 +1174,12 @@ export class RunIssue {
                 assertUuid(runId);
                 branchName = `codex/issue-${input.issueNumber}`;
                 worktreePath = resolve(targetRoot, config.runner.workspaceRoot, `issue-${input.issueNumber}`);
-                baseSha = await this.dependencies.git.getBaseSha({ targetRoot, baseBranch: config.github.baseBranch });
+                try {
+                    baseSha = await this.dependencies.git.getBaseSha({ targetRoot, baseBranch: config.github.baseBranch });
+                }
+                catch {
+                    return await this.preClaimTransport(input.issueNumber, 'base-refresh-failed', 'The configured remote base branch could not be refreshed before claim.');
+                }
                 assertGitSha(baseSha, 'baseSha');
                 const claimBody = claimComment(runId, input.issueNumber, branchName);
                 active = await this.createRun({
@@ -972,28 +1214,51 @@ export class RunIssue {
             if (active.record.lifecycle === 'checking' && !active.record.directReview && active.record.routeReceipt?.route === 'direct') {
                 return await this.terminal(active, { status: 'internal-error', code: 'direct-review-state-missing' });
             }
+            if (active.record.routeReceipt?.route === 'direct' && !this.dependencies.git.candidateV2) {
+                return await this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true }, 'candidate-git-v2-required');
+            }
             if (active.record.lifecycle === 'implementing' && active.record.routeReceipt?.route === 'direct'
-                && !active.record.directReview) {
+                && !active.record.directReview
+                && (!active.record.mutableInvocation || active.record.mutableInvocation.operation === 'qualification-repair')) {
                 const qualification = await this.qualifyChecks(active, config, issueSnapshot, frozenCriteria);
                 if ('status' in qualification)
                     return qualification;
                 active = qualification.active;
             }
             attemptLoop: while (true) {
-                if (!await this.authorized(active, config)) {
+                if (active.record.lifecycle !== 'proving' && !await this.authorized(active, config))
                     return await this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true });
-                }
-                if (this.signal.aborted)
+                if (this.signal.aborted && active.record.lifecycle !== 'proving')
                     return await this.terminal(active, { status: 'cancelled' });
                 let resumeAtChecks = (active.record.lifecycle === 'checking' || active.record.lifecycle === 'proving')
                     && active.record.directReview?.status === 'clear';
                 if (active.record.lifecycle === 'implementing'
                     && active.record.directReview?.status === 'active'
                     && (active.record.directReview.stage === 'review-full' || active.record.directReview.stage === 'review-closure')) {
-                    const recovered = await this.recoverDirectReviewInvocation(active);
-                    if ('status' in recovered)
-                        return recovered;
-                    active = recovered;
+                    const recoveryBoundary = active.record.reviewFeedback?.activeBatch
+                        ? {
+                            kind: 'review-feedback',
+                            batchId: active.record.reviewFeedback.activeBatch.batchId,
+                            repairRound: active.record.reviewFeedback.repairRound,
+                        }
+                        : { kind: 'implementation-cycle', cycle: active.record.cycle };
+                    const captured = await this.ensureCandidateBinding(active, config, recoveryBoundary);
+                    if ('status' in captured)
+                        return captured;
+                    active = captured.active;
+                    const binding = active.record.candidateBinding;
+                    const candidateTargetFingerprint = directReviewCandidateTargetFingerprint({
+                        binding,
+                        routeDecisionSha256: active.record.routeReceipt.decisionSha256,
+                        workflowGenerationHash: active.record.workflowGeneration.generationHash,
+                        cycle: active.record.cycle,
+                        frozenCriteria,
+                    });
+                    if (active.record.directReview.targetFingerprint !== candidateTargetFingerprint) {
+                        active = await this.persist(active, {
+                            directReview: { ...active.record.directReview, targetFingerprint: candidateTargetFingerprint },
+                        });
+                    }
                     const reviewed = await this.runDirectReviewFull(active, publicIssueSnapshot(issueSnapshot), frozenCriteria, `recovered-implementation-cycle-${active.record.cycle}`, config.runner.maxCycles, config);
                     if ('status' in reviewed)
                         return reviewed;
@@ -1010,90 +1275,54 @@ export class RunIssue {
                     const feedbackProjection = feedbackBatch
                         ? projectReviewFeedbackBatch(feedbackBatch, active.record.directReview.targetRevision)
                         : undefined;
+                    let feedbackImplementationLaunchFailure;
                     const implementationLaunch = feedbackBatch ? {
                         reviewFeedbackRound: active.record.reviewFeedback.repairRound,
                         reviewFeedback: feedbackProjection.workerFeedback,
-                        onPrepared: async (invocation) => {
-                            const currentActive = active;
-                            active = await this.persist(currentActive, {
-                                reviewFeedback: {
-                                    ...structuredClone(currentActive.record.reviewFeedback),
-                                    implementationInvocation: { ...structuredClone(invocation), phase: 'prepared', pid: null, processGroupId: null, launchedAt: null },
-                                },
-                            });
-                        },
-                        onLaunched: async (invocation) => {
-                            const currentActive = active;
-                            const current = currentActive.record.reviewFeedback?.implementationInvocation;
-                            if (!current || current.phase !== 'prepared' || current.attemptId !== invocation.attemptId)
-                                throw new Error('review feedback implementation launch mismatch');
-                            active = await this.persist(currentActive, {
-                                reviewFeedback: {
-                                    ...structuredClone(currentActive.record.reviewFeedback),
-                                    implementationInvocation: { ...current, phase: 'launched', pid: invocation.pid, processGroupId: invocation.processGroupId, launchedAt: invocation.launchedAt },
-                                },
-                            });
-                        },
-                    } : {
-                        onLaunched: async () => {
-                            const currentActive = active;
-                            const qualification = currentActive.record.checkQualification;
-                            if (!qualification)
-                                throw new Error('implementation launch requires check qualification');
-                            active = await this.persist(currentActive, {
-                                checkQualification: { ...qualification, implementationStarted: true },
-                            });
+                        beforeLaunch: async () => {
+                            const failure = await this.revalidateFeedbackWorker(active, config, input.issueNumber);
+                            if (failure) {
+                                feedbackImplementationLaunchFailure = failure;
+                                throw new Error('review feedback implementation launch authorization changed');
+                            }
                         },
-                    };
+                    } : {};
                     const deniedPathsBaseline = await this.dependencies.git.fingerprintDeniedPaths(worktreePath, config.deny.readPaths);
-                    let implementation = recoveredFeedbackImplementation ?? await this.runImplementation({
-                        operation: 'implementation',
+                    const phaseFacts = [deniedPathsBaseline, sha256(canonicalJson(resolveIssueCheckPolicy(active.record.issueSnapshot.body, config.checks).checks)), canonicalJson(active.record.checkQualification?.checks ?? [])];
+                    const recoveredContext = active.record.mutableInvocation?.context;
+                    const invocationState = this.mutableInvocationState(() => active, (next) => { active = next; });
+                    let implementation = await this.runImplementation({
+                        operation: feedbackBatch ? 'review-feedback-implementation' : 'implementation',
                         runId,
                         worktreePath,
                         issue: publicIssueSnapshot(issueSnapshot),
                         frozenCriteria,
                         cycle: active.record.cycle,
-                        reworkFindings: active.record.reworkFindings,
-                        repairOnly: false,
+                        reworkFindings: recoveredContext?.reworkFindings ?? active.record.reworkFindings,
+                        repairOnly: recoveredContext?.repairOnly ?? false,
                         workflowGeneration: active.record.workflowGeneration,
+                        phaseFacts,
+                        invocationState,
                         ...implementationLaunch,
                     });
-                    recoveredFeedbackImplementation = undefined;
+                    if (feedbackImplementationLaunchFailure)
+                        return feedbackImplementationLaunchFailure;
                     if (implementation.kind === 'safe-halt') {
-                        active = await this.persist(active, {
-                            lifecycle: 'safe-halt',
-                            process: {
-                                ...implementation.process,
-                                purpose: 'implementation',
-                                resumeLifecycle: 'implementing',
-                                resumeReviewStage: null,
-                            },
-                        });
-                        while (true) {
-                            try {
-                                await implementation.waitForAbsence();
-                                break;
-                            }
-                            catch {
-                                await new Promise((resolveWait) => setTimeout(resolveWait, 25));
-                            }
+                        if (implementation.code === 'report-repair-modified-worktree') {
+                            return this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true }, implementation.code);
                         }
-                        if (await this.dependencies.git.fingerprintDeniedPaths(worktreePath, config.deny.readPaths) !== deniedPathsBaseline) {
-                            return await this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true }, 'denied-path-modified');
+                        if (implementation.code === 'mutable-operation-result-worktree-mismatch') {
+                            active = await this.persist(active, { mutableInvocation: undefined });
+                            return this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true }, implementation.code);
                         }
-                        return await this.terminal(active, { status: 'transport-failed', resumable: false }, 'process-quiescence-delayed');
+                        return await this.invokedFailure(active, implementation.code, 'Mutable implementation recovery remains fenced and requires a later bounded observation.');
                     }
                     if (await this.dependencies.git.fingerprintDeniedPaths(worktreePath, config.deny.readPaths) !== deniedPathsBaseline) {
+                        active = await this.persist(active, { mutableInvocation: undefined });
                         return await this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true }, 'denied-path-modified');
                     }
-                    if (implementation.kind === 'transport-failed' && implementation.resumable && active.record.transportRetries === 0) {
-                        const invocation = active.record.reviewFeedback?.implementationInvocation;
-                        if (invocation && !sameFreshness(await this.dependencies.git.snapshot(worktreePath), invocation.baseline)) {
-                            return await this.blockReviewFeedback(active, 'safety', 'review-feedback-implementation-worktree-ambiguous');
-                        }
-                        active = await this.persist(active, { transportRetries: 1 });
-                        continue attemptLoop;
-                    }
+                    if (implementation.kind === 'transport-failed')
+                        return this.invokedFailure(active, implementation.code ?? 'implementation-agent-transport-failed', 'Mutable implementation did not produce recoverable output; the durable invocation remains available for recovery.');
                     if (implementation.kind !== 'completed')
                         return await this.mapImplementationFailure(active, implementation);
                     let report;
@@ -1102,15 +1331,16 @@ export class RunIssue {
                     }
                     catch {
                         if (active.record.reportRepairs >= 1) {
+                            active = await this.persist(active, { mutableInvocation: undefined });
                             return await this.terminal(active, { status: 'internal-error', code: 'implementation-report-malformed' });
                         }
                         const repairBaseline = await this.dependencies.git.snapshot(worktreePath);
-                        active = await this.persist(active, { reportRepairs: 1 });
+                        active = await this.persist(active, { reportRepairs: 1, mutableInvocation: undefined });
                         const repairBlock = await this.revalidateFeedbackWorker(active, config, input.issueNumber);
                         if (repairBlock)
                             return repairBlock;
                         implementation = await this.runImplementation({
-                            operation: 'implementation',
+                            operation: feedbackBatch ? 'review-feedback-implementation' : 'implementation',
                             runId,
                             worktreePath,
                             issue: publicIssueSnapshot(issueSnapshot),
@@ -1119,60 +1349,56 @@ export class RunIssue {
                             reworkFindings: ['The previous implementation report did not match the generated schema.'],
                             repairOnly: true,
                             workflowGeneration: active.record.workflowGeneration,
+                            phaseFacts,
+                            invocationState,
                             ...implementationLaunch,
                         });
+                        if (feedbackImplementationLaunchFailure)
+                            return feedbackImplementationLaunchFailure;
                         if (implementation.kind === 'safe-halt') {
-                            active = await this.persist(active, {
-                                lifecycle: 'safe-halt',
-                                process: {
-                                    ...implementation.process,
-                                    purpose: 'implementation',
-                                    resumeLifecycle: 'implementing',
-                                    resumeReviewStage: null,
-                                },
-                            });
-                            while (true) {
-                                try {
-                                    await implementation.waitForAbsence();
-                                    break;
-                                }
-                                catch {
-                                    await new Promise((resolveWait) => setTimeout(resolveWait, 25));
-                                }
+                            if (implementation.code === 'report-repair-modified-worktree') {
+                                return this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true }, implementation.code);
                             }
-                            return await this.terminal(active, { status: 'transport-failed', resumable: false }, 'process-quiescence-delayed');
+                            return this.invokedFailure(active, implementation.code);
                         }
+                        if (implementation.kind === 'transport-failed')
+                            return this.invokedFailure(active, implementation.code ?? 'implementation-agent-transport-failed');
                         if (implementation.kind !== 'completed')
                             return await this.mapImplementationFailure(active, implementation);
                         const afterRepair = await this.dependencies.git.snapshot(worktreePath);
                         if (!sameFreshness(repairBaseline, afterRepair)) {
+                            active = await this.persist(active, { mutableInvocation: undefined });
                             return await this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true }, 'report-repair-modified-worktree');
                         }
                         try {
                             report = validateImplementationReport(implementation.report);
                         }
                         catch {
+                            active = await this.persist(active, { mutableInvocation: undefined });
                             return await this.terminal(active, { status: 'internal-error', code: 'implementation-report-malformed' });
                         }
                     }
                     if (report.status === 'external-block') {
+                        active = await this.persist(active, { mutableInvocation: undefined });
                         return await this.terminal(active, { status: 'blocked', kind: 'external', resumable: true });
                     }
                     if (await this.dependencies.git.getHead(worktreePath) !== expectedImplementationHead(active.record)) {
+                        active = await this.persist(active, { mutableInvocation: undefined });
                         return await this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true });
                     }
                     const changedFiles = await this.dependencies.git.listChangedFiles(worktreePath);
                     if (changedFiles.length === 0 || !sameStrings(changedFiles, report.changedFiles)) {
                         if (changedFiles.length === 0 || active.record.reportRepairs >= 1) {
+                            active = await this.persist(active, { mutableInvocation: undefined });
                             return await this.terminal(active, { status: 'internal-error', code: 'implementation-change-set-invalid' });
                         }
                         const repairBaseline = await this.dependencies.git.snapshot(worktreePath);
-                        active = await this.persist(active, { reportRepairs: 1 });
+                        active = await this.persist(active, { reportRepairs: 1, mutableInvocation: undefined });
                         const repairBlock = await this.revalidateFeedbackWorker(active, config, input.issueNumber);
                         if (repairBlock)
                             return repairBlock;
                         implementation = await this.runImplementation({
-                            operation: 'implementation',
+                            operation: feedbackBatch ? 'review-feedback-implementation' : 'implementation',
                             runId,
                             worktreePath,
                             issue: publicIssueSnapshot(issueSnapshot),
@@ -1181,52 +1407,64 @@ export class RunIssue {
                             reworkFindings: [`The report changedFiles must equal the complete current product change set: ${canonicalJson(changedFiles)}.`],
                             repairOnly: true,
                             workflowGeneration: active.record.workflowGeneration,
+                            phaseFacts,
+                            invocationState,
                             ...implementationLaunch,
                         });
+                        if (feedbackImplementationLaunchFailure)
+                            return feedbackImplementationLaunchFailure;
                         if (implementation.kind === 'safe-halt') {
-                            active = await this.persist(active, {
-                                lifecycle: 'safe-halt',
-                                process: {
-                                    ...implementation.process,
-                                    purpose: 'implementation',
-                                    resumeLifecycle: 'implementing',
-                                    resumeReviewStage: null,
-                                },
-                            });
-                            while (true) {
-                                try {
-                                    await implementation.waitForAbsence();
-                                    break;
-                                }
-                                catch {
-                                    await new Promise((resolveWait) => setTimeout(resolveWait, 25));
-                                }
+                            if (implementation.code === 'report-repair-modified-worktree') {
+                                return this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true }, implementation.code);
                             }
-                            return await this.terminal(active, { status: 'transport-failed', resumable: false }, 'process-quiescence-delayed');
+                            return this.invokedFailure(active, implementation.code);
                         }
+                        if (implementation.kind === 'transport-failed')
+                            return this.invokedFailure(active, implementation.code ?? 'implementation-agent-transport-failed');
                         if (implementation.kind !== 'completed')
                             return await this.mapImplementationFailure(active, implementation);
                         const afterRepair = await this.dependencies.git.snapshot(worktreePath);
                         if (!sameFreshness(repairBaseline, afterRepair)) {
+                            active = await this.persist(active, { mutableInvocation: undefined });
                             return await this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true }, 'report-repair-modified-worktree');
                         }
                         try {
                             report = validateImplementationReport(implementation.report);
                         }
                         catch {
+                            active = await this.persist(active, { mutableInvocation: undefined });
                             return await this.terminal(active, { status: 'internal-error', code: 'implementation-report-malformed' });
                         }
                         if (report.status === 'external-block') {
+                            active = await this.persist(active, { mutableInvocation: undefined });
                             return await this.terminal(active, { status: 'blocked', kind: 'external', resumable: true });
                         }
                         if (!sameStrings(changedFiles, report.changedFiles)) {
+                            active = await this.persist(active, { mutableInvocation: undefined });
                             return await this.terminal(active, { status: 'internal-error', code: 'implementation-change-set-invalid' });
                         }
                     }
                     if (active.record.routeReceipt?.route === 'direct') {
-                        const targetFingerprint = directReviewTargetFingerprint({
-                            snapshot: await this.dependencies.git.snapshot(worktreePath),
-                            changedFiles,
+                        const boundary = active.record.reviewFeedback?.activeBatch
+                            ? {
+                                kind: 'review-feedback',
+                                batchId: active.record.reviewFeedback.activeBatch.batchId,
+                                repairRound: active.record.reviewFeedback.repairRound,
+                            }
+                            : { kind: 'implementation-cycle', cycle: active.record.cycle };
+                        const captured = await this.ensureCandidateBinding(active, config, boundary);
+                        if ('status' in captured)
+                            return captured;
+                        active = captured.active;
+                        const binding = active.record.candidateBinding;
+                        if (!sameStrings(binding.canonicalChangedFiles, report.changedFiles)) {
+                            const released = await this.clearAndReleaseCandidate(active);
+                            if ('status' in released)
+                                return released;
+                            return this.terminal(released.active, { status: 'internal-error', code: 'implementation-change-set-invalid' });
+                        }
+                        const targetFingerprint = directReviewCandidateTargetFingerprint({
+                            binding,
                             routeDecisionSha256: active.record.routeReceipt.decisionSha256,
                             workflowGenerationHash: active.record.workflowGeneration.generationHash,
                             cycle: active.record.cycle,
@@ -1235,9 +1473,7 @@ export class RunIssue {
                         if (active.record.directReview?.stage === 'review-repair') {
                             active = await this.persist(active, {
                                 directReview: prepareDirectReviewClosure(active.record.directReview, targetFingerprint).state,
-                                ...(active.record.reviewFeedback ? {
-                                    reviewFeedback: { ...structuredClone(active.record.reviewFeedback), implementationInvocation: null },
-                                } : {}),
+                                mutableInvocation: undefined,
                             });
                         }
                         else {
@@ -1248,9 +1484,7 @@ export class RunIssue {
                                     targetFingerprint,
                                     codeReviewerSessionId: reviewerSessionId,
                                 }),
-                                ...(active.record.reviewFeedback ? {
-                                    reviewFeedback: { ...structuredClone(active.record.reviewFeedback), implementationInvocation: null },
-                                } : {}),
+                                mutableInvocation: undefined,
                             });
                         }
                         const reviewed = await this.runDirectReviewFull(active, publicIssueSnapshot(issueSnapshot), frozenCriteria, implementation.attemptId ?? `implementation-cycle-${active.record.cycle}`, config.runner.maxCycles, config);
@@ -1263,21 +1497,32 @@ export class RunIssue {
                     else {
                         active = await this.persist(active, {
                             lifecycle: 'checking',
-                            ...(active.record.reviewFeedback ? {
-                                reviewFeedback: { ...structuredClone(active.record.reviewFeedback), implementationInvocation: null },
-                            } : {}),
+                            mutableInvocation: undefined,
                         });
                     }
                 }
-                let checkPolicy;
+                let currentCheckPolicy;
                 try {
-                    checkPolicy = resolveIssueCheckPolicy(active.record.issueSnapshot.body, config.checks);
+                    currentCheckPolicy = resolveIssueCheckPolicy(active.record.issueSnapshot.body, config.checks);
                 }
                 catch (error) {
                     return await this.invokedFailure(active, 'issue-verification-invalid', error instanceof Error ? error.message : undefined);
                 }
-                const configuredChecks = Object.entries(checkPolicy.checks);
+                const currentCheckPolicySha256 = sha256(canonicalJson(currentCheckPolicy.checks));
+                const recoveringPersistedProof = active.record.lifecycle === 'proving' && active.record.executionLease?.operation === 'acceptance-proof'
+                    && active.record.checkedChangeSha256 !== undefined && active.record.proofId !== undefined;
+                const persistedProofCheckPolicySha256 = active.record.checks.find((check) => 'checkPolicySha256' in check)?.checkPolicySha256 ?? active.record.checkQualification?.checkPolicySha256;
+                const configuredChecks = recoveringPersistedProof
+                    ? active.record.checks.map((check) => [check.id, check.command]) : Object.entries(currentCheckPolicy.checks);
+                const finalCheckPolicySha256 = recoveringPersistedProof && persistedProofCheckPolicySha256 ? persistedProofCheckPolicySha256 : currentCheckPolicySha256;
+                const finalBinding = active.record.candidateBinding;
+                if (!finalBinding)
+                    return await this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true }, 'candidate-git-v2-required');
                 const reusableChecks = active.record.checks.filter((check) => check.status === 'passed'
+                    && 'bindingId' in check
+                    && check.bindingId === finalBinding.bindingId
+                    && check.candidateTreeSha === finalBinding.candidateTreeSha
+                    && check.checkPolicySha256 === finalCheckPolicySha256
                     && configuredChecks.some(([id, command]) => check.id === id && check.command === command));
                 if (reusableChecks.length !== active.record.checks.length) {
                     active = await this.persist(active, {
@@ -1290,13 +1535,34 @@ export class RunIssue {
                 for (const [id, command] of configuredChecks) {
                     if (active.record.checks.some((check) => check.id === id
                         && check.command === command
-                        && check.status === 'passed'))
+                        && check.status === 'passed'
+                        && 'bindingId' in check
+                        && check.bindingId === finalBinding.bindingId
+                        && check.candidateTreeSha === finalBinding.candidateTreeSha
+                        && check.checkPolicySha256 === finalCheckPolicySha256))
                         continue;
                     if (this.signal.aborted)
                         return await this.terminal(active, { status: 'cancelled' });
+                    if (this.dependencies.checks.supportsLaunchOwnership !== true) {
+                        return await this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true }, 'candidate-check-launch-ownership-required');
+                    }
+                    const execution = await this.prepareCandidateExecution(active, config, 'final-check', `${id}:${finalCheckPolicySha256}`);
+                    if ('status' in execution)
+                        return execution;
+                    active = execution.active;
+                    const lease = execution.lease;
                     let check;
                     try {
-                        check = await this.dependencies.checks.run({ id, command, source: checkPolicy.source, cwd: worktreePath, phase: 'changed', signal: this.signal });
+                        check = await this.dependencies.checks.run({
+                            id, command, source: currentCheckPolicy.source, cwd: lease.path, phase: 'changed', signal: this.signal,
+                            onLaunched: async ({ pid, processGroupId }) => {
+                                active = await this.persist(active, {
+                                    executionLease: this.dependencies.git.candidateV2.markExecutionLaunched({
+                                        lease, pid, processGroupId, launchedAt: this.timestamp(),
+                                    }),
+                                });
+                            },
+                        });
                     }
                     catch (error) {
                         if (error instanceof CheckProcessQuiescenceError) {
@@ -1306,160 +1572,162 @@ export class RunIssue {
                     }
                     if (this.signal.aborted)
                         return await this.terminal(active, { status: 'cancelled' });
-                    const row = { id, command, status: check.status, outputSha256: check.outputSha256 };
+                    const settledExecution = await this.settleCandidateExecution(active, config);
+                    if ('status' in settledExecution)
+                        return settledExecution;
+                    active = settledExecution.active;
+                    const row = {
+                        id, command, status: check.status, outputSha256: check.outputSha256,
+                        bindingId: finalBinding.bindingId,
+                        candidateTreeSha: finalBinding.candidateTreeSha,
+                        checkPolicySha256: finalCheckPolicySha256,
+                    };
                     active = await this.persist(active, { checks: [...active.record.checks, row] });
                     if (check.status === 'failed') {
                         if (this.repairBudgetExhausted(active, config.runner.maxCycles)) {
+                            const released = await this.clearAndReleaseCandidate(active);
+                            if ('status' in released)
+                                return released;
+                            active = released.active;
                             return active.record.reviewFeedback?.activeBatch
                                 ? await this.blockReviewFeedback(active, 'exhausted', 'review-feedback-check-repair-exhausted')
                                 : await this.terminal(active, { status: 'blocked', kind: 'exhausted', resumable: true });
                         }
                         const summary = `Check ${id} failed:\n${check.output.toString('utf8').slice(0, 8 * 1024)}`;
-                        active = await this.startNextCycle(active, [summary], [{
+                        const reopened = await this.startNextCycleFromCandidate(active, [summary], [{
                                 provenance: 'check', sourceId: `check:${id}:${row.outputSha256}`, summary,
                                 affectedContracts: ['configured-checks'],
                             }]);
+                        if ('status' in reopened)
+                            return reopened;
+                        active = reopened;
                         continue attemptLoop;
                     }
                 }
-                let reviewedStageBinding;
-                try {
-                    const reviewedFiles = await this.dependencies.git.listChangedFiles(worktreePath);
-                    const reviewedContentSha256 = await this.dependencies.git.fingerprintChangedFiles(worktreePath, reviewedFiles);
-                    reviewedStageBinding = { files: reviewedFiles, contentSha256: reviewedContentSha256 };
-                    if (active.record.directReview?.status === 'clear') {
-                        const currentFingerprint = directReviewTargetFingerprint({
-                            snapshot: await this.dependencies.git.snapshot(worktreePath),
-                            changedFiles: await this.dependencies.git.listChangedFiles(worktreePath),
-                            routeDecisionSha256: active.record.routeReceipt.decisionSha256,
-                            workflowGenerationHash: active.record.workflowGeneration.generationHash,
-                            cycle: active.record.cycle,
-                            frozenCriteria,
-                        });
-                        if (currentFingerprint !== active.record.directReview.targetFingerprint) {
-                            return await this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true }, 'direct-review-target-drift');
-                        }
-                    }
-                    await this.dependencies.git.stageAll(worktreePath);
-                    const stagedFiles = await this.dependencies.git.listChangedFiles(worktreePath);
-                    const stagedContentSha256 = await this.dependencies.git.fingerprintChangedFiles(worktreePath, stagedFiles);
-                    if (!sameStrings(reviewedFiles, stagedFiles) || reviewedContentSha256 !== stagedContentSha256) {
-                        return await this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true }, 'post-stage-review-binding-drift');
-                    }
-                }
-                catch {
-                    return await this.terminal(active, { status: 'internal-error', code: 'local-git-effect-failed' });
-                }
-                if (await this.dependencies.git.getHead(worktreePath) !== expectedImplementationHead(active.record)) {
-                    return await this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true });
-                }
-                const proofChangedFiles = await this.dependencies.git.listChangedFiles(worktreePath);
-                const freshness = await this.dependencies.git.snapshot(worktreePath);
-                const proofContentSha256 = await this.dependencies.git.fingerprintChangedFiles(worktreePath, proofChangedFiles);
-                if (!reviewedStageBinding || !sameStrings(reviewedStageBinding.files, proofChangedFiles)
-                    || reviewedStageBinding.contentSha256 !== proofContentSha256) {
-                    return await this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true }, 'checked-change-review-binding-drift');
-                }
-                if (!sameCheckPolicy(active.record.checks, checkPolicy.checks)) {
+                if (!sameCheckPolicy(active.record.checks, recoveringPersistedProof ? Object.fromEntries(configuredChecks) : currentCheckPolicy.checks)) {
                     return await this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true }, 'configured-check-policy-drift');
                 }
+                const proofBinding = active.record.candidateBinding;
+                if (!proofBinding || active.record.checks.some((check) => !('bindingId' in check)
+                    || check.bindingId !== proofBinding.bindingId || check.candidateTreeSha !== proofBinding.candidateTreeSha
+                    || check.checkPolicySha256 !== finalCheckPolicySha256)) {
+                    return await this.terminal(active, { status: 'blocked', kind: 'safety', resumable: false }, 'checked-change-candidate-binding-drift');
+                }
                 const payload = {
-                    version: 1,
+                    version: 2,
                     canonicalRepository,
                     runId,
                     issueNumber: input.issueNumber,
                     cycle: active.record.cycle,
                     baseSha: expectedImplementationHead(active.record),
-                    headSha: freshness.headSha,
-                    indexTreeSha: freshness.indexTreeSha,
-                    trackedContentSha256: freshness.trackedContentSha256,
-                    untrackedContentSha256: freshness.untrackedContentSha256,
-                    worktreeIdentity: freshness.worktreeIdentity,
-                    changedFiles: proofChangedFiles,
-                    checks: active.record.checks.map((check) => ({
-                        ...check,
-                        status: 'passed',
-                    })),
-                    checkPolicySha256: sha256(canonicalJson(checkPolicy.checks)),
+                    binding: structuredClone(proofBinding),
+                    changedFiles: [...proofBinding.canonicalChangedFiles],
+                    checks: active.record.checks.map((check) => ({ ...check, status: 'passed' })),
+                    checkPolicySha256: finalCheckPolicySha256,
                     packageVersion: active.record.packageVersion,
                     proofSchemaVersion: 1,
                 };
                 const checkedChange = this.dependencies.checkedChangeMint.mint(payload);
                 const checkedChangeSha256 = checkedChangePayloadSha256(payload);
-                const proofId = this.dependencies.createProofId();
+                if (active.record.checkedChangeSha256 && active.record.checkedChangeSha256 !== checkedChangeSha256) {
+                    return await this.persistCandidateEvidenceSafetyTerminal(active, 'checked-change-recovery-binding-drift');
+                }
+                const proofId = active.record.proofId ?? this.dependencies.createProofId();
                 assertNonEmptyString(proofId, 'proofId');
                 active = await this.persist(active, { lifecycle: 'proving', checkedChangeSha256, proofId });
+                const retainedProofLease = active.record.executionLease?.operation === 'acceptance-proof'
+                    ? active.record.executionLease
+                    : undefined;
+                const preparedProofExecution = retainedProofLease
+                    ? { active, lease: retainedProofLease }
+                    : await this.prepareCandidateExecution(active, config, 'acceptance-proof', proofId);
+                if ('status' in preparedProofExecution)
+                    return preparedProofExecution;
+                active = preparedProofExecution.active;
+                const proofExecution = preparedProofExecution;
                 let proof;
                 try {
+                    if (active.record.proofReceipt) {
+                        const settled = await this.settleCandidateExecution(active, config);
+                        if ('status' in settled)
+                            return settled;
+                        active = await this.persist(settled.active, { lifecycle: 'publishing', reworkFindings: [] });
+                        break;
+                    }
                     proof = await this.dependencies.proof.proveChange({
                         proofId,
                         issue: publicIssueSnapshot(issueSnapshot),
                         frozenCriteria,
                         checkedChange,
+                        executionLease: proofExecution.lease,
                         workflowGeneration: structuredClone(active.record.workflowGeneration),
                         beforeAgentLaunch: async () => {
-                            const failure = await this.revalidateFeedbackWorker(active, config, input.issueNumber);
-                            if (failure)
-                                throw new ProofLaunchAuthorizationError(failure);
+                            if (recoveringPersistedProof && currentCheckPolicySha256 !== finalCheckPolicySha256)
+                                throw new ProofLaunchAuthorizationError({ status: 'blocked', code: 'configured-check-policy-drift' });
+                            const observation = !await this.authorized(active, config) ? { status: 'blocked', code: 'proof-worker-authority-revoked' } : await this.observeFeedbackWorker(active, config, input.issueNumber);
+                            if (observation.status !== 'valid')
+                                throw new ProofLaunchAuthorizationError(observation);
                         },
                     });
                 }
                 catch (error) {
-                    if (error instanceof ProofLaunchAuthorizationError)
-                        return error.outcome;
-                    if (error instanceof ProofQuiescenceError) {
-                        active = await this.persist(active, {
-                            lifecycle: 'safe-halt',
-                            process: {
-                                pid: error.pid,
-                                processGroupId: error.processGroupId,
-                                startedAt: this.timestamp(),
-                                baseline: {
-                                    headSha: freshness.headSha,
-                                    indexTreeSha: freshness.indexTreeSha,
-                                    trackedContentSha256: freshness.trackedContentSha256,
-                                    untrackedContentSha256: freshness.untrackedContentSha256,
-                                    worktreeIdentity: freshness.worktreeIdentity,
-                                },
-                                purpose: 'proof',
-                                resumeLifecycle: 'proving',
-                                resumeReviewStage: null,
-                            },
-                        });
-                        while (true) {
-                            try {
-                                await error.waitForAbsence();
-                                break;
-                            }
-                            catch {
-                                await new Promise((resolveWait) => setTimeout(resolveWait, 25));
-                            }
+                    if (error instanceof ProofLaunchAuthorizationError) {
+                        const observation = error.outcome;
+                        if (observation.code === 'configured-check-policy-drift') {
+                            const settled = await this.settleCandidateExecution(active, config);
+                            return 'status' in settled ? settled : this.terminal(settled.active, { status: 'blocked', kind: 'safety', resumable: true }, observation.code);
                         }
-                        return await this.terminal(active, { status: 'transport-failed', resumable: false }, 'proof-process-quiescence-delayed');
+                        if (observation.status === 'retryable')
+                            return this.invokedFailure(active, `${observation.code}-retryable`);
+                        return active.record.reviewFeedback?.activeBatch ? this.blockReviewFeedback(active, 'safety', observation.code) : this.revoked(active);
+                    }
+                    if (error instanceof CandidateProofInspectionError) {
+                        return error.code === 'candidate-artifact-conflict'
+                            ? this.persistCandidateEvidenceSafetyTerminal(active, error.code)
+                            : this.mapCandidateFailure(active, error.code);
                     }
                     return await this.terminal(active, { status: 'internal-error', code: 'acceptance-proof-internal-failure' });
                 }
+                if (proof.status === 'transport-failed' && proof.resumable) {
+                    return this.invokedFailure(active, 'proof-invocation-deferred', 'Acceptance proof ownership or output requires bounded reconciliation on the next tick.');
+                }
+                if (recoveringPersistedProof && currentCheckPolicySha256 !== finalCheckPolicySha256) {
+                    const settled = await this.settleCandidateExecution(active, config);
+                    return 'status' in settled ? settled : this.terminal(settled.active, { status: 'blocked', kind: 'safety', resumable: true }, 'configured-check-policy-drift');
+                }
+                if (proof.status === 'passed')
+                    active = await this.persist(active, { proofReceipt: proof.receipt });
+                const settledProofExecution = await this.settleCandidateExecution(active, config);
+                if ('status' in settledProofExecution)
+                    return settledProofExecution;
+                active = settledProofExecution.active;
                 if (this.signal.aborted)
                     return await this.terminal(active, { status: 'cancelled' });
                 if (proof.status === 'needs-rework') {
                     if (this.repairBudgetExhausted(active, config.runner.maxCycles)) {
+                        const released = await this.clearAndReleaseCandidate(active);
+                        if ('status' in released)
+                            return released;
+                        active = released.active;
                         return active.record.reviewFeedback?.activeBatch
                             ? await this.blockReviewFeedback(active, 'exhausted', 'review-feedback-proof-repair-exhausted')
                             : await this.terminal(active, { status: 'blocked', kind: 'exhausted', resumable: true });
                     }
-                    active = await this.startNextCycle(active, proof.findings, proof.findings.map((summary) => ({
+                    const reopened = await this.startNextCycleFromCandidate(active, proof.findings, proof.findings.map((summary) => ({
                         provenance: 'proof',
                         sourceId: `proof:${proofId}:${sha256(summary)}`,
                         summary,
                         affectedContracts: ['acceptance-proof'],
                     })));
+                    if ('status' in reopened)
+                        return reopened;
+                    active = reopened;
                     continue attemptLoop;
                 }
                 if (proof.status !== 'passed')
                     return await this.mapProofFailure(active, proof);
                 active = await this.persist(active, {
                     lifecycle: 'publishing',
-                    proofReceipt: proof.receipt,
                     reworkFindings: [],
                     ...(active.record.reviewFeedback?.activeBatch ? {
                         reviewFeedback: markReviewFeedbackPublishing(markReviewFeedbackVerified(active.record.reviewFeedback, {
@@ -1525,7 +1793,6 @@ export class RunIssue {
     }
     async initializeClaimedRun(active, issue) {
         if (active.record.lifecycle !== 'claimed'
-            || active.record.process
             || active.record.intent
             || active.record.routeExecution
             || active.record.routeReceipt) {
@@ -1577,13 +1844,16 @@ export class RunIssue {
                     active = await this.persist(active, { routeExecution: structuredClone(next) });
                     return true;
                 },
-                complete: async (expected, next, receipt) => {
+                complete: async (expected, next, receipt, attemptId) => {
                     if (!sameRouteExecution(active.record.routeExecution, expected))
                         return false;
+                    if (active.record.reportInvocation?.attemptId !== attemptId)
+                        return false;
                     active = await this.persist(active, {
                         lifecycle: 'routed',
                         routeExecution: structuredClone(next),
                         routeReceipt: structuredClone(receipt),
+                        reportInvocation: undefined,
                     });
                     return true;
                 },
@@ -1601,10 +1871,19 @@ export class RunIssue {
                         routeReceipt: undefined,
                         outcomeEvidenceId: evidence.id,
                         terminalOutcome: { status: 'cancelled', evidencePath: evidence.path },
+                        reportInvocation: undefined,
                         ...(active.record.waitingHuman ? { waitingHuman: terminalWaiting(active.record.waitingHuman, { status: 'cancelled' }) } : {}),
                     });
                     return true;
                 },
+                invocation: this.reportInvocationState(() => active, (next) => { active = next; }),
+                settle: async (expected, next, attemptId) => {
+                    if (!sameRouteExecution(active.record.routeExecution, expected)
+                        || active.record.reportInvocation?.attemptId !== attemptId)
+                        return false;
+                    active = await this.persist(active, { routeExecution: structuredClone(next), reportInvocation: undefined });
+                    return true;
+                },
             };
             const result = await this.dependencies.routeCoordinator.run({
                 state,
@@ -1623,32 +1902,13 @@ export class RunIssue {
                 ],
                 signal: this.signal,
             });
-            if (result.status === 'repairable' || result.status === 'retryable')
+            if (result.status === 'repairable')
                 continue;
+            if (result.status === 'retryable') {
+                return { result: await this.invokedFailure(active, result.code, 'Report-only recovery is deferred to the next runner tick.') };
+            }
             if (result.status === 'safe-halt') {
-                active = await this.persist(active, {
-                    lifecycle: 'safe-halt',
-                    process: {
-                        ...result.process,
-                        purpose: 'route',
-                        resumeLifecycle: 'triaging',
-                        resumeReviewStage: null,
-                    },
-                });
-                while (true) {
-                    try {
-                        await result.waitForAbsence();
-                        break;
-                    }
-                    catch {
-                        await new Promise((resolveWait) => setTimeout(resolveWait, 25));
-                    }
-                }
-                const after = await this.dependencies.git.snapshot(worktreePath);
-                if (!sameFreshness(result.process.baseline, after)) {
-                    return { result: await this.terminal(active, { status: 'blocked', kind: 'safety', resumable: false }, 'report-operation-worktree-mutated') };
-                }
-                return { result: await this.terminal(active, { status: 'transport-failed', resumable: false }, 'process-quiescence-delayed') };
+                return { result: await this.invokedFailure(active, result.code, 'Report-only process ownership remains unresolved; no relaunch was attempted.') };
             }
             if (result.status === 'cancelled') {
                 if (!active.record.terminalOutcome)
@@ -1729,9 +1989,8 @@ export class RunIssue {
                     status: 'blocked', kind: continuation.kind, resumable: continuation.kind !== 'exhausted',
                 }, continuation.code) };
         }
-        if (continuation.status === 'retryable') {
-            return { result: await this.terminal(active, { status: 'transport-failed', resumable: true }, continuation.code) };
-        }
+        if (continuation.status === 'retryable')
+            return { result: await this.invokedFailure(active, continuation.code) };
         if (receipt.route !== 'direct') {
             const specContinuation = continuation;
             if (specContinuation.status !== 'completed')
@@ -1766,6 +2025,29 @@ export class RunIssue {
         };
     }
     specState(readActive, writeActive) {
+        const invocation = (reserveSession) => ({
+            read: async () => structuredClone(readActive().record.reportInvocation),
+            compareAndSwap: async (expected, next) => {
+                const active = readActive();
+                const observed = active.record.reportInvocation;
+                if (observed === undefined || expected === undefined ? observed !== expected
+                    : canonicalJson(observed) !== canonicalJson(expected))
+                    return false;
+                const preparing = expected === undefined && next?.phase === 'prepared';
+                const specDelivery = preparing ? reserveSession(active.record.specDelivery) : active.record.specDelivery;
+                writeActive(await this.persist(active, { ...(specDelivery ? { specDelivery } : {}),
+                    reportInvocation: next ? structuredClone(next) : undefined }));
+                return true;
+            },
+        });
+        const settle = async (expected, next, attemptId) => {
+            const active = readActive();
+            if (canonicalJson(active.record.specDelivery) !== canonicalJson(expected)
+                || active.record.reportInvocation?.attemptId !== attemptId)
+                return false;
+            writeActive(await this.persist(active, { specDelivery: structuredClone(next), reportInvocation: undefined }));
+            return true;
+        };
         return {
             read: async () => structuredClone(readActive().record.specDelivery),
             compareAndSwap: async (expected, next) => {
@@ -1781,6 +2063,34 @@ export class RunIssue {
                 writeActive(saved);
                 return true;
             },
+            authorInvocation: (authorSessionId) => invocation((state) => reserveSpecAuthorSession(state, authorSessionId)),
+            reviewInvocation: (reviewerSessionId) => invocation((state) => reserveSpecReviewerSession(state, reviewerSessionId)),
+            settleAuthor: settle,
+            settleReview: settle,
+        };
+    }
+    reportInvocationState(readActive, writeActive, launch) {
+        return {
+            read: async () => structuredClone(readActive().record.reportInvocation),
+            compareAndSwap: async (expected, next) => {
+                const active = readActive();
+                const observed = active.record.reportInvocation;
+                if (observed === undefined || expected === undefined) {
+                    if (observed !== expected)
+                        return false;
+                }
+                else if (canonicalJson(observed) !== canonicalJson(expected))
+                    return false;
+                const launching = expected?.phase === 'prepared' && next?.phase === 'launched';
+                if (launching)
+                    await launch?.beforeLaunch();
+                const launchChanges = launching && launch ? launch.launchChanges(next) : {};
+                writeActive(await this.persist(active, {
+                    ...launchChanges,
+                    reportInvocation: next ? structuredClone(next) : undefined,
+                }));
+                return true;
+            },
         };
     }
     async continueSpecRequired(active) {
@@ -1801,7 +2111,7 @@ export class RunIssue {
         if (result.status === 'cancelled')
             return await this.terminal(current, { status: 'cancelled' });
         if (result.status === 'retryable')
-            return await this.terminal(current, { status: 'transport-failed', resumable: true }, result.code);
+            return await this.invokedFailure(current, result.code);
         return await this.terminal(current, { status: 'blocked', kind: result.kind, resumable: result.kind !== 'exhausted' }, result.code);
     }
     async continueWaitingHuman(active) {
@@ -1889,7 +2199,7 @@ export class RunIssue {
         const { config, ...persistedInput } = input;
         const record = {
             ...persistedInput,
-            lifecycle: 'claimed', cycle: 1, reportRepairs: 0, transportRetries: 0,
+            lifecycle: 'claimed', cycle: 1, reportRepairs: 0,
             reworkFindings: [],
             packageVersion: workflow.receipt.packageVersion,
             workflowGeneration: structuredClone(workflow.receipt),
@@ -1897,23 +2207,21 @@ export class RunIssue {
             checks: [], createdAt: now, updatedAt: now,
         };
         const saved = await this.dependencies.runRecords.compareAndSwap(state.generation, {
-            schema: 'codex-orchestrator.agent-auto-state', version: 2, runs: [...state.runs, record],
+            schema: 'codex-orchestrator.agent-auto-state', version: state.version, runs: [...state.runs, record],
         });
         return { state: saved, record: findRun(saved, input.runId), config };
     }
-    async persist(active, changes) {
+    async persist(active, changes, stateVersion = active.state.version) {
         const record = { ...active.record, ...changes, updatedAt: this.timestamp() };
         if (Object.hasOwn(changes, 'intent') && changes.intent === undefined)
             delete record.intent;
-        if (Object.hasOwn(changes, 'process') && changes.process === undefined)
-            delete record.process;
-        for (const key of ['checkedChangeSha256', 'proofId', 'proofReceipt', 'terminalOutcome', 'outcomeEvidenceId', 'routeExecution', 'routeReceipt', 'reviewFeedback', 'checkQualification', 'baselineChecks']) {
+        for (const key of ['checkedChangeSha256', 'proofId', 'proofReceipt', 'terminalOutcome', 'outcomeEvidenceId', 'routeExecution', 'routeReceipt', 'reportInvocation', 'mutableInvocation', 'reviewFeedback', 'checkQualification', 'baselineChecks', 'changeBindingVersion', 'candidateBinding', 'executionLease']) {
             if (Object.hasOwn(changes, key) && changes[key] === undefined)
                 delete record[key];
         }
         const runs = active.state.runs.map((candidate) => candidate.runId === record.runId ? record : candidate);
         const saved = await this.dependencies.runRecords.compareAndSwap(active.state.generation, {
-            schema: 'codex-orchestrator.agent-auto-state', version: 2, runs,
+            schema: 'codex-orchestrator.agent-auto-state', version: stateVersion, runs,
         });
         return { state: saved, record: findRun(saved, record.runId), config: active.config };
     }
@@ -1943,11 +2251,6 @@ export class RunIssue {
             return false;
         return this.hasTrustedClaim(issue, record);
     }
-    async authorizedForExactLabels(active, expectedLabels) {
-        const issue = await this.readIssue(active.record.issueNumber);
-        return !!issue && issue.state === 'OPEN' && sameStrings(issue.labels, expectedLabels)
-            && this.hasTrustedClaim(issue, active.record);
-    }
     hasTrustedClaim(issue, record) {
         const exactBody = claimComment(record.runId, record.issueNumber, record.branchName);
         const markers = issue.comments.filter(isClaimMarkerComment);
@@ -1982,21 +2285,31 @@ export class RunIssue {
         }
     }
     async revalidateFeedbackWorker(active, config, issueNumber) {
+        const validation = await this.observeFeedbackWorker(active, config, issueNumber);
+        if (validation.status === 'valid')
+            return undefined;
+        if (validation.status === 'retryable')
+            return this.invokedFailure(active, `${validation.code}-retryable`);
+        return this.blockReviewFeedback(active, 'safety', validation.code);
+    }
+    async observeFeedbackWorker(active, config, issueNumber) {
         const batch = active.record.reviewFeedback?.activeBatch;
         if (!batch)
-            return undefined;
+            return { status: 'valid' };
         if (!await this.authorized(active, config)) {
-            return this.blockReviewFeedback(active, 'safety', 'review-feedback-worker-authority-revoked');
+            return { status: 'blocked', code: 'review-feedback-worker-authority-revoked' };
         }
         if (!this.dependencies.reviewFeedback) {
-            return this.blockReviewFeedback(active, 'safety', 'review-feedback-worker-revalidation-unavailable');
+            return { status: 'blocked', code: 'review-feedback-worker-revalidation-unavailable' };
         }
         const validation = await this.dependencies.reviewFeedback.revalidate({
             batch,
             epoch: 'pre-update',
             expectedHeadSha: batch.priorPublishedHeadSha,
         });
-        return this.mapFeedbackRevalidation(active, validation, 'review-feedback-worker-revalidation-failed');
+        return validation.status === 'valid'
+            ? { status: 'valid' }
+            : { status: validation.status, code: 'review-feedback-worker-revalidation-failed' };
     }
     async mapFeedbackRevalidation(active, validation, safetyCode) {
         if (validation.status === 'valid')
@@ -2005,6 +2318,277 @@ export class RunIssue {
             return this.invokedFailure(active, `${safetyCode}-retryable`);
         return this.blockReviewFeedback(active, 'safety', safetyCode);
     }
+    async ensureCandidateBinding(active, config, boundary) {
+        const candidate = this.dependencies.git.candidateV2;
+        if (!candidate)
+            return this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true }, 'candidate-git-v2-required');
+        if (active.record.candidateBinding) {
+            const inspection = await candidate.inspectPin(active.record.candidateBinding);
+            if (inspection.kind === 'failed')
+                return this.mapCandidateFailure(active, inspection.code);
+            if (inspection.value === 'missing')
+                return this.persistCandidateEvidenceSafetyTerminal(active, 'candidate-pin-missing');
+            if (inspection.value === 'diverged')
+                return this.persistCandidateEvidenceSafetyTerminal(active, 'candidate-pin-diverged');
+            return { active };
+        }
+        const captured = await candidate.captureAndPin({
+            worktreePath: active.record.worktreePath,
+            expectedHeadSha: expectedImplementationHead(active.record),
+            runId: active.record.runId,
+            boundary,
+            artifactDir: config.proof.artifactDir,
+        });
+        if (captured.kind === 'failed')
+            return this.mapCandidateFailure(active, captured.code);
+        return { active: await this.persist(active, {
+                changeBindingVersion: 2,
+                candidateBinding: captured.value,
+            }, 3) };
+    }
+    async cutoverLegacyImmutableBoundary(active, config, frozenCriteria) {
+        const captured = await this.ensureCandidateBinding(active, config, {
+            kind: 'implementation-cycle', cycle: active.record.cycle,
+        });
+        if ('status' in captured)
+            return captured;
+        active = captured.active;
+        const binding = active.record.candidateBinding;
+        const targetFingerprint = directReviewCandidateTargetFingerprint({
+            binding,
+            routeDecisionSha256: active.record.routeReceipt.decisionSha256,
+            workflowGenerationHash: active.record.workflowGeneration.generationHash,
+            cycle: active.record.cycle,
+            frozenCriteria,
+        });
+        return { active: await this.persist(active, {
+                lifecycle: 'implementing',
+                directReview: createInitialDirectReview({
+                    targetFingerprint,
+                    codeReviewerSessionId: this.dependencies.createReviewSessionId(),
+                }),
+                checks: [], checkedChangeSha256: undefined, proofId: undefined, proofReceipt: undefined,
+                checkQualification: undefined, baselineChecks: undefined,
+                terminalOutcome: undefined, outcomeEvidenceId: undefined,
+            }) };
+    }
+    async prepareCandidateExecution(active, config, operation, operationSourceId) {
+        const candidate = this.dependencies.git.candidateV2;
+        const binding = active.record.candidateBinding;
+        if (!candidate || !binding)
+            return this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true }, 'candidate-git-v2-required');
+        const attemptId = sha256(canonicalJson({ bindingId: binding.bindingId, operation, operationSourceId }));
+        const prepared = await candidate.prepareExecution({
+            binding,
+            runId: active.record.runId,
+            workspaceRoot: resolve(dirname(active.record.worktreePath)),
+            operation,
+            attemptId,
+        });
+        if (prepared.kind === 'failed')
+            return this.mapCandidateFailure(active, prepared.code);
+        if (prepared.value.kind === 'path-diverged') {
+            return this.persistCandidateEvidenceSafetyTerminal(active, 'path-diverged');
+        }
+        const next = await this.persist(active, { executionLease: prepared.value.lease });
+        return { active: next, lease: prepared.value.lease };
+    }
+    async settleCandidateExecution(active, config) {
+        const candidate = this.dependencies.git.candidateV2;
+        const binding = active.record.candidateBinding;
+        const lease = active.record.executionLease;
+        if (!candidate || !binding || !lease)
+            return this.terminal(active, { status: 'blocked', kind: 'safety', resumable: false }, 'candidate-execution-state-missing');
+        const inspection = await candidate.inspectExecution({ binding, lease, artifactDir: config.proof.artifactDir });
+        if (inspection.kind === 'failed')
+            return this.mapCandidateFailure(active, inspection.code);
+        if (inspection.value !== 'matching' && inspection.value !== 'missing') {
+            return this.reconcilePersistedCandidateExecution(active, config);
+        }
+        if (inspection.value === 'matching') {
+            const removed = await candidate.removeExecution({ lease, requireProcessAbsent: true });
+            if (removed.kind === 'failed')
+                return this.mapCandidateFailure(active, removed.code);
+        }
+        return { active: await this.persist(active, { executionLease: undefined }) };
+    }
+    async inspectCompletedReviewExecution(active, config) {
+        const candidate = this.dependencies.git.candidateV2;
+        const binding = active.record.candidateBinding;
+        const lease = active.record.executionLease;
+        if (!candidate || !binding || !lease || lease.operation !== 'direct-review') {
+            return this.persistCandidateEvidenceSafetyTerminal(active, 'candidate-execution-state-missing');
+        }
+        const inspection = await candidate.inspectExecution({ binding, lease, artifactDir: config.proof.artifactDir });
+        if (inspection.kind === 'failed')
+            return this.mapCandidateFailure(active, inspection.code);
+        if (inspection.value !== 'matching')
+            return this.persistCandidateEvidenceSafetyTerminal(active, `candidate-execution-${inspection.value}`);
+        return { lease };
+    }
+    async removeCompletedReviewExecution(active, lease) {
+        const candidate = this.dependencies.git.candidateV2;
+        if (!candidate)
+            return this.persistCandidateEvidenceSafetyTerminal(active, 'candidate-execution-state-missing');
+        const removed = await candidate.removeExecution({ lease, requireProcessAbsent: true });
+        if (removed.kind === 'failed')
+            return this.mapCandidateFailure(active, removed.code);
+        return { active };
+    }
+    async reconcilePersistedCandidateExecution(active, config) {
+        const candidate = this.dependencies.git.candidateV2;
+        const binding = active.record.candidateBinding;
+        const lease = active.record.executionLease;
+        if (!candidate || !binding || !lease) {
+            return this.persistCandidateEvidenceSafetyTerminal(active, 'candidate-execution-state-missing');
+        }
+        if (lease.operation === 'direct-review' && lease.phase === 'launched') {
+            return this.persistCandidateEvidenceSafetyTerminal(active, 'direct-review-canonical-invocation-missing');
+        }
+        if (lease.phase === 'launched') {
+            try {
+                await this.dependencies.waitForReviewProcessAbsence(lease.processGroupId);
+            }
+            catch {
+                return this.persistCandidateEvidenceSafetyTerminal(active, 'candidate-execution-process-absence-unconfirmed');
+            }
+        }
+        const inspection = await candidate.inspectExecution({ binding, lease, artifactDir: config.proof.artifactDir });
+        if (inspection.kind === 'failed')
+            return this.mapCandidateFailure(active, inspection.code);
+        if (inspection.value === 'missing')
+            return this.persistCandidateEvidenceSafetyTerminal(active, 'candidate-execution-missing');
+        if (inspection.value === 'mutated') {
+            const cleared = await this.persist(active, {
+                executionLease: undefined, changeBindingVersion: undefined, candidateBinding: undefined,
+            });
+            const removed = await candidate.removeExecution({ lease, requireProcessAbsent: true });
+            if (removed.kind === 'failed')
+                return this.mapCandidateFailure(cleared, removed.code);
+            const released = await candidate.releasePin({ binding, expectedPinnedCommitSha: binding.candidateCommitSha });
+            if (released.kind === 'failed')
+                return this.mapCandidateFailure(cleared, released.code);
+            return this.persistTerminal(cleared, { status: 'blocked', kind: 'safety', resumable: false }, 'candidate-materialization-mutated', false);
+        }
+        if (lease.operation === 'acceptance-proof') {
+            return { active };
+        }
+        const cleared = await this.persist(active, { executionLease: undefined });
+        const removed = await candidate.removeExecution({ lease, requireProcessAbsent: true });
+        if (removed.kind === 'failed')
+            return this.mapCandidateFailure(cleared, removed.code);
+        return { active: cleared };
+    }
+    async clearAndReleaseCandidate(active) {
+        const candidate = this.dependencies.git.candidateV2;
+        const binding = active.record.candidateBinding;
+        if (!candidate || !binding)
+            return { active };
+        if (active.record.executionLease)
+            return this.terminal(active, { status: 'blocked', kind: 'safety', resumable: false }, 'candidate-execution-not-quiescent');
+        const normalized = await candidate.normalizeSharedIndex({
+            worktreePath: active.record.worktreePath,
+            expectedHeadSha: expectedImplementationHead(active.record),
+        });
+        if (normalized.kind === 'failed')
+            return this.mapCandidateFailure(active, normalized.code);
+        const cleared = await this.persist(active, { changeBindingVersion: undefined, candidateBinding: undefined });
+        const released = await candidate.releasePin({ binding, expectedPinnedCommitSha: binding.candidateCommitSha });
+        if (released.kind === 'failed') {
+            return this.invokedFailure(cleared, 'candidate-pin-release-pending', 'The candidate state transition is durable; orphan reconciliation will retry exact pin cleanup.');
+        }
+        return { active: cleared };
+    }
+    async persistRetainedCommitIntentTerminal(active, evidenceCode) {
+        const intent = active.record.intent;
+        if (!active.record.candidateBinding || (intent?.kind !== 'commit' && intent?.kind !== 'review-update-commit')) {
+            return this.invokedFailure(active, 'retained-candidate-intent-state-invalid');
+        }
+        const evidence = await this.dependencies.writeEvidence({
+            runId: active.record.runId,
+            code: evidenceCode,
+            summary: 'Candidate publication stopped locally with the exact commit intent and pin retained.',
+        });
+        const terminalOutcome = {
+            status: 'blocked', kind: 'safety', resumable: false, evidencePath: evidence.path,
+        };
+        const directReview = active.record.directReview && active.record.directReview.status !== 'terminal'
+            ? projectTerminalDirectReview(active.record.directReview, { status: 'blocked', kind: 'safety' })
+            : active.record.directReview;
+        await this.persist(active, {
+            lifecycle: 'blocked',
+            terminalOutcome,
+            outcomeEvidenceId: evidence.id,
+            ...(directReview ? { directReview } : {}),
+            ...(active.record.reviewFeedback?.activeBatch ? {
+                reviewFeedback: blockReviewFeedback(active.record.reviewFeedback, 'safety', this.timestamp()),
+            } : {}),
+            reportInvocation: undefined,
+        });
+        return publicOutcome(terminalOutcome);
+    }
+    async reconcileUnknownCandidatePublication(active) {
+        const candidate = this.dependencies.git.candidateV2;
+        const binding = active.record.candidateBinding;
+        const intent = active.record.intent;
+        if (!candidate || !binding || (intent?.kind !== 'commit' && intent?.kind !== 'review-update-commit')) {
+            return publicOutcome(active.record.terminalOutcome);
+        }
+        const observation = await candidate.createOrObserveCommit({
+            worktreePath: active.record.worktreePath,
+            branchName: active.record.branchName,
+            parentSha: intent.parentSha,
+            treeSha: intent.treeSha,
+            message: intent.message,
+            candidateRef: intent.candidateRef,
+            observeOnly: true,
+        });
+        if (observation.kind === 'failed') {
+            return publicOutcome(active.record.terminalOutcome);
+        }
+        if (observation.value.kind === 'branch-diverged') {
+            return this.persistRetainedCommitIntentTerminal(active, 'candidate-branch-diverged');
+        }
+        let directReview = active.record.directReview;
+        if (directReview?.status === 'terminal') {
+            const { terminalCode: _terminalCode, terminalOutcome: _terminalOutcome, ...preserved } = structuredClone(directReview);
+            directReview = { ...preserved, status: 'clear' };
+        }
+        return { active: await this.persist(active, {
+                lifecycle: 'publishing', terminalOutcome: undefined, outcomeEvidenceId: undefined,
+                ...(directReview ? { directReview } : {}),
+            }) };
+    }
+    async persistCandidateEvidenceSafetyTerminal(active, evidenceCode) {
+        if (!active.record.candidateBinding)
+            return this.invokedFailure(active, 'candidate-evidence-state-invalid');
+        const evidence = await this.dependencies.writeEvidence({
+            runId: active.record.runId,
+            code: evidenceCode,
+            summary: 'Candidate evidence was retained without a Git or GitHub effect.',
+        });
+        const terminalOutcome = {
+            status: 'blocked', kind: 'safety', resumable: false, evidencePath: evidence.path,
+        };
+        const directReview = active.record.directReview && active.record.directReview.status !== 'terminal'
+            ? projectTerminalDirectReview(active.record.directReview, { status: 'blocked', kind: 'safety' })
+            : active.record.directReview;
+        await this.persist(active, {
+            lifecycle: 'blocked', terminalOutcome, outcomeEvidenceId: evidence.id,
+            ...(directReview ? { directReview } : {}),
+            ...(active.record.reviewFeedback?.activeBatch ? {
+                reviewFeedback: blockReviewFeedback(active.record.reviewFeedback, 'safety', this.timestamp()),
+            } : {}),
+            reportInvocation: undefined,
+        });
+        return publicOutcome(terminalOutcome);
+    }
+    mapCandidateFailure(active, code) {
+        if (code === 'candidate-unstable' || code === 'candidate-io-failed' || code === 'candidate-materialization-io-failed') {
+            return this.invokedFailure(active, code, 'Candidate operation failed before an effect and may be retried without consuming a repair budget.');
+        }
+        return this.terminal(active, { status: 'transport-failed', resumable: false }, code);
+    }
     async runImplementation(input) {
         try {
             return await this.dependencies.implementationAgent.run({
@@ -2017,6 +2601,23 @@ export class RunIssue {
             return { kind: 'internal-error' };
         }
     }
+    mutableInvocationState(current, replace) {
+        return {
+            read: async () => structuredClone(current().record.mutableInvocation),
+            compareAndSwap: async (expected, next) => {
+                const active = current();
+                if (canonicalJson(active.record.mutableInvocation ?? null) !== canonicalJson(expected ?? null))
+                    return false;
+                try {
+                    replace(await this.persist(active, { mutableInvocation: next }));
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            },
+        };
+    }
     async runDirectReviewFull(starting, issue, frozenCriteria, implementationAttemptId, maxCycles, config) {
         let active = starting;
         let reportRepair;
@@ -2034,12 +2635,52 @@ export class RunIssue {
                 ? directReviewClosureRequestSha256(directReview)
                 : null;
             const mode = directReview.stage === 'review-closure' ? 'closure' : 'full';
-            const reviewerAuthorizationFailure = await this.revalidateFeedbackWorker(active, config, active.record.issueNumber);
-            if (reviewerAuthorizationFailure)
-                return reviewerAuthorizationFailure;
+            const reviewerAuthorization = await this.observeFeedbackWorker(active, config, active.record.issueNumber);
+            if (reviewerAuthorization.status !== 'valid') {
+                const released = await this.clearAndReleaseCandidate(active);
+                if ('status' in released)
+                    return released;
+                active = released.active;
+                return reviewerAuthorization.status === 'retryable'
+                    ? this.invokedFailure(active, `${reviewerAuthorization.code}-retryable`)
+                    : this.blockReviewFeedback(active, 'safety', reviewerAuthorization.code);
+            }
+            let executionLease;
+            if (active.record.reportInvocation?.operation === 'code-review') {
+                if (active.record.executionLease?.operation !== 'direct-review') {
+                    return this.terminal(active, { status: 'blocked', kind: 'safety', resumable: false }, 'direct-review-candidate-execution-missing');
+                }
+                executionLease = active.record.executionLease;
+            }
+            else {
+                const execution = await this.prepareCandidateExecution(active, config, 'direct-review', `${reviewerSessionId}:${directReview.targetRevision}:${mode}:${implementationAttemptId}`);
+                if ('status' in execution)
+                    return execution;
+                active = execution.active;
+                executionLease = execution.lease;
+            }
+            const abortPreparedReview = async (validation) => {
+                const settledExecution = await this.settleCandidateExecution(active, config);
+                if ('status' in settledExecution)
+                    return settledExecution;
+                active = settledExecution.active;
+                if (active.record.reportInvocation)
+                    return this.invokedFailure(active, 'direct-review-authorization-changed-after-prepare');
+                const released = await this.clearAndReleaseCandidate(active);
+                if ('status' in released)
+                    return released;
+                active = released.active;
+                return validation.status === 'retryable'
+                    ? this.invokedFailure(active, `${validation.code}-retryable`)
+                    : this.blockReviewFeedback(active, 'safety', validation.code);
+            };
+            const launchAuthorization = await this.observeFeedbackWorker(active, config, active.record.issueNumber);
+            if (launchAuthorization.status !== 'valid')
+                return abortPreparedReview(launchAuthorization);
+            let launchAuthorizationFailure;
             const result = await this.dependencies.implementationReviewer.run({
                 runId: active.record.runId,
-                worktreePath: active.record.worktreePath,
+                worktreePath: executionLease.path,
                 operation: 'code-review',
                 mode,
                 reviewerSessionId,
@@ -2061,33 +2702,48 @@ export class RunIssue {
                 validationDiagnostic: reportRepair?.diagnostic ?? null,
                 originalReportBytes: reportRepair?.originalReportBytes ?? null,
                 signal: this.signal,
-                onPrepared: async (invocation) => {
-                    const current = active.record.directReview;
-                    if (!current)
-                        throw new Error('direct review disappeared before prepare');
-                    active = await this.persist(active, {
-                        directReview: prepareDirectReviewInvocation(current, invocation),
-                    });
-                },
-                onLaunched: async (invocation) => {
-                    const current = active.record.directReview;
-                    if (!current)
-                        throw new Error('direct review disappeared before launch');
-                    active = await this.persist(active, {
-                        directReview: launchDirectReviewInvocation(current, invocation),
-                    });
-                },
+                invocationState: this.reportInvocationState(() => active, (next) => { active = next; }, {
+                    beforeLaunch: async () => {
+                        const authorization = await this.observeFeedbackWorker(active, config, active.record.issueNumber);
+                        if (authorization.status !== 'valid') {
+                            launchAuthorizationFailure = authorization;
+                            throw new Error('direct review launch authorization changed');
+                        }
+                    },
+                    launchChanges: (invocation) => {
+                        const lease = active.record.executionLease;
+                        if (!lease || invocation.pid === null || invocation.processGroupId === null || invocation.launchedAt === null) {
+                            throw new Error('direct review candidate execution is missing at launch');
+                        }
+                        return {
+                            executionLease: this.dependencies.git.candidateV2.markExecutionLaunched({
+                                lease, pid: invocation.pid, processGroupId: invocation.processGroupId, launchedAt: invocation.launchedAt,
+                            }),
+                        };
+                    },
+                }),
             });
+            if (launchAuthorizationFailure)
+                return abortPreparedReview(launchAuthorizationFailure);
+            let adoptedExecution;
+            if (result.kind === 'completed' || result.kind === 'report-invalid') {
+                const inspected = await this.inspectCompletedReviewExecution(active, config);
+                if ('status' in inspected)
+                    return inspected;
+                adoptedExecution = inspected.lease;
+            }
+            else if (result.kind !== 'safe-halt') {
+                const settledExecution = await this.settleCandidateExecution(active, config);
+                if ('status' in settledExecution)
+                    return settledExecution;
+                active = settledExecution.active;
+            }
             if (result.kind === 'completed') {
                 const current = active.record.directReview;
                 if (!current)
                     return this.terminal(active, { status: 'internal-error', code: 'direct-review-result-orphaned' });
                 if (result.report.verdict === 'needs-work') {
-                    if (this.repairBudgetExhausted(active, maxCycles)) {
-                        return active.record.reviewFeedback?.activeBatch
-                            ? this.blockReviewFeedback(active, 'exhausted', 'direct-review-repair-exhausted')
-                            : this.terminal(active, { status: 'blocked', kind: 'exhausted', resumable: true }, 'direct-review-repair-exhausted');
-                    }
+                    const exhausted = this.repairBudgetExhausted(active, maxCycles);
                     const repaired = acceptNeedsWorkDirectReview(current, result.report, result.artifactSha256);
                     const findings = [
                         ...result.report.defects
@@ -2097,13 +2753,15 @@ export class RunIssue {
                             .filter((finding) => finding.status === 'reopened')
                             .map((finding) => `${finding.id}: ${finding.summary}`),
                     ];
-                    return this.persist(active, {
-                        lifecycle: 'implementing',
-                        cycle: active.record.reviewFeedback?.activeBatch
-                            ? active.record.cycle
-                            : (active.record.cycle + 1),
-                        ...(active.record.reviewFeedback?.activeBatch ? {
-                            reviewFeedback: reserveNextReviewFeedbackRound(active.record.reviewFeedback),
+                    active = await this.persist(active, {
+                        ...(!exhausted ? {
+                            lifecycle: 'implementing',
+                            cycle: active.record.reviewFeedback?.activeBatch
+                                ? active.record.cycle
+                                : (active.record.cycle + 1),
+                            ...(active.record.reviewFeedback?.activeBatch ? {
+                                reviewFeedback: reserveNextReviewFeedbackRound(active.record.reviewFeedback),
+                            } : {}),
                         } : {}),
                         directReview: repaired,
                         reworkFindings: findings,
@@ -2111,23 +2769,48 @@ export class RunIssue {
                         checkedChangeSha256: undefined,
                         proofId: undefined,
                         proofReceipt: undefined,
+                        reportInvocation: undefined,
+                        executionLease: undefined,
                     });
+                    const removed = await this.removeCompletedReviewExecution(active, adoptedExecution);
+                    if ('status' in removed)
+                        return removed;
+                    active = removed.active;
+                    const released = await this.clearAndReleaseCandidate(active);
+                    if ('status' in released)
+                        return released;
+                    active = released.active;
+                    if (exhausted) {
+                        return active.record.reviewFeedback?.activeBatch
+                            ? this.blockReviewFeedback(active, 'exhausted', 'direct-review-repair-exhausted')
+                            : this.terminal(active, { status: 'blocked', kind: 'exhausted', resumable: true }, 'direct-review-repair-exhausted');
+                    }
+                    return active;
                 }
-                if (result.report.verdict !== 'approved')
-                    return this.terminal(active, { status: 'blocked', kind: 'safety', resumable: false }, 'direct-review-rejected');
-                return this.persist(active, {
+                if (result.report.verdict !== 'approved') {
+                    const terminal = await this.terminal(active, { status: 'blocked', kind: 'safety', resumable: false }, 'direct-review-rejected');
+                    await this.dependencies.git.candidateV2.removeExecution({ lease: adoptedExecution, requireProcessAbsent: true });
+                    return terminal;
+                }
+                active = await this.persist(active, {
                     lifecycle: 'checking',
                     directReview: acceptApprovedDirectReview(current, result.report, result.artifactSha256),
+                    reportInvocation: undefined,
+                    executionLease: undefined,
                 });
+                const removed = await this.removeCompletedReviewExecution(active, adoptedExecution);
+                return 'status' in removed ? removed : removed.active;
             }
             if (result.kind === 'report-invalid') {
                 const current = active.record.directReview;
                 if (!current)
                     return this.terminal(active, { status: 'internal-error', code: 'direct-review-result-orphaned' });
                 if (current.review.reportRepairs >= MAX_DIRECT_REVIEW_REPORT_REPAIRS) {
-                    return this.terminal(active, { status: 'internal-error', code: 'direct-review-report-malformed' }, 'direct-review-report-malformed');
+                    const terminal = await this.terminal(active, { status: 'internal-error', code: 'direct-review-report-malformed' }, 'direct-review-report-malformed');
+                    await this.dependencies.git.candidateV2.removeExecution({ lease: adoptedExecution, requireProcessAbsent: true });
+                    return terminal;
                 }
-                const { invocation: _invocation, ...withoutInvocation } = structuredClone(current);
+                const withoutInvocation = structuredClone(current);
                 active = await this.persist(active, {
                     directReview: {
                         ...withoutInvocation,
@@ -2136,7 +2819,13 @@ export class RunIssue {
                             reportRepairs: (withoutInvocation.review.reportRepairs + 1),
                         },
                     },
+                    reportInvocation: undefined,
+                    executionLease: undefined,
                 });
+                const removed = await this.removeCompletedReviewExecution(active, adoptedExecution);
+                if ('status' in removed)
+                    return removed;
+                active = removed.active;
                 reportRepair = {
                     originalReportSha256: result.originalReportSha256,
                     originalReportBytes: Buffer.from(result.originalReportBytes),
@@ -2145,70 +2834,16 @@ export class RunIssue {
                 continue;
             }
             if (result.kind === 'transport-failed') {
-                const current = active.record.directReview;
-                if (!current || current.review.transportRetries >= 1) {
-                    return this.terminal(active, { status: 'blocked', kind: 'exhausted', resumable: true }, 'direct-review-transport-exhausted');
-                }
-                const { invocation: _invocation, ...withoutInvocation } = structuredClone(current);
-                active = await this.persist(active, {
-                    directReview: {
-                        ...withoutInvocation,
-                        review: { ...withoutInvocation.review, transportRetries: 1 },
-                    },
-                });
-                continue;
+                return this.invokedFailure(active, 'direct-review-transport-failed');
             }
             if (result.kind === 'safe-halt') {
-                active = await this.persist(active, {
-                    lifecycle: 'safe-halt',
-                    process: {
-                        ...result.process,
-                        purpose: 'code-review',
-                        resumeLifecycle: 'implementing',
-                        resumeReviewStage: directReview.stage,
-                    },
-                });
-                try {
-                    await result.waitForAbsence();
-                }
-                catch {
-                    return this.terminal(active, { status: 'transport-failed', resumable: false }, 'direct-review-quiescence-unconfirmed');
-                }
-                return this.terminal(active, { status: 'transport-failed', resumable: false }, 'direct-review-quiescence-delayed');
+                return this.invokedFailure(active, result.code, 'Code-review process ownership remains unresolved; no relaunch was attempted.');
             }
             if (result.kind === 'cancelled')
                 return this.terminal(active, { status: 'cancelled' });
             return this.terminal(active, { status: 'internal-error', code: result.code });
         }
     }
-    async recoverDirectReviewInvocation(starting) {
-        const directReview = starting.record.directReview;
-        const invocation = directReview?.invocation;
-        if (!directReview || !invocation)
-            return starting;
-        const { invocation: _invocation, ...withoutInvocation } = structuredClone(directReview);
-        if (invocation.status === 'prepared') {
-            return this.persist(starting, { directReview: withoutInvocation });
-        }
-        if (invocation.status === 'launched') {
-            try {
-                await this.dependencies.waitForReviewProcessAbsence(invocation.processGroupId);
-            }
-            catch {
-                return this.terminal(starting, { status: 'blocked', kind: 'safety', resumable: false }, 'direct-review-process-absence-unconfirmed');
-            }
-            if (directReview.review.transportRetries >= 1) {
-                return this.terminal(starting, { status: 'blocked', kind: 'exhausted', resumable: true }, 'direct-review-transport-exhausted');
-            }
-            return this.persist(starting, {
-                directReview: {
-                    ...withoutInvocation,
-                    review: { ...withoutInvocation.review, transportRetries: 1 },
-                },
-            });
-        }
-        return this.persist(starting, { directReview: withoutInvocation });
-    }
     async qualifyChecks(starting, config, issue, frozenCriteria) {
         let active = starting;
         let checkPolicy;
@@ -2226,70 +2861,74 @@ export class RunIssue {
             ? existingQualification
             : undefined;
         let repairAttempts = prior?.repairAttempts ?? 0;
-        const pendingInvocation = existingQualification?.repairInvocation ?? null;
-        if (pendingInvocation) {
-            if (pendingInvocation.phase === 'launched') {
-                try {
-                    await this.dependencies.waitForReviewProcessAbsence(pendingInvocation.processGroupId);
-                }
-                catch {
-                    return this.terminal(active, { status: 'blocked', kind: 'safety', resumable: false }, 'qualification-repair-process-absence-unconfirmed');
-                }
-            }
-            if (!this.dependencies.implementationAgent.recover) {
-                return this.terminal(active, { status: 'blocked', kind: 'safety', resumable: false }, 'qualification-repair-report-recovery-unavailable');
-            }
-            let recovered;
-            try {
-                recovered = await this.dependencies.implementationAgent.recover({
-                    runId: active.record.runId,
-                    canonicalRepository: active.record.canonicalRepository,
-                    invocation: pendingInvocation,
-                });
-            }
-            catch {
-                return this.terminal(active, { status: 'blocked', kind: 'safety', resumable: false }, 'qualification-repair-report-recovery-failed');
-            }
-            if (recovered) {
-                const settled = await this.settleQualificationRepair(active, config, recovered);
-                if ('status' in settled)
-                    return settled;
-                active = settled.active;
-            }
-            else {
-                const deniedPathsBaseline = active.record.checkQualification?.deniedPathsBaseline;
-                if (!deniedPathsBaseline
-                    || await this.dependencies.git.fingerprintDeniedPaths(active.record.worktreePath, config.deny.readPaths) !== deniedPathsBaseline) {
-                    return this.terminal(active, { status: 'blocked', kind: 'safety', resumable: false }, 'denied-path-modified');
-                }
-                if (!sameFreshness(await this.dependencies.git.snapshot(active.record.worktreePath), pendingInvocation.baseline)) {
-                    return this.terminal(active, { status: 'blocked', kind: 'safety', resumable: false }, 'qualification-repair-worktree-ambiguous');
-                }
-                active = await this.clearQualificationRepairInvocation(active);
-            }
-        }
         if (!prior) {
             active = await this.persist(active, {
                 checkQualification: {
                     version: 1, checkPolicySha256, repairAttempts, checks: [],
-                    implementationStarted: false, repairInvocation: null,
                 },
                 baselineChecks: undefined,
             });
         }
+        if (active.record.mutableInvocation?.operation === 'qualification-repair') {
+            const findings = active.record.checkQualification?.repairFindings;
+            if (!findings?.length)
+                return this.invokedFailure(active, 'qualification-repair-correlation-missing');
+            const deniedPathsBaseline = await this.dependencies.git.fingerprintDeniedPaths(active.record.worktreePath, config.deny.readPaths);
+            const invocationState = this.mutableInvocationState(() => active, (next) => { active = next; });
+            const recovered = await this.runImplementation({
+                operation: 'qualification-repair', runId: active.record.runId, worktreePath: active.record.worktreePath,
+                issue, frozenCriteria, cycle: repairAttempts + 1, reworkFindings: findings, repairOnly: false,
+                workflowGeneration: active.record.workflowGeneration, phaseFacts: [deniedPathsBaseline], invocationState,
+            });
+            if (recovered.kind === 'safe-halt')
+                return this.invokedFailure(active, recovered.code);
+            if (recovered.kind === 'transport-failed')
+                return this.invokedFailure(active, recovered.code ?? 'qualification-repair-agent-failed');
+            if (recovered.kind === 'cancelled')
+                return this.terminal(active, { status: 'cancelled' });
+            if (recovered.kind !== 'completed')
+                return this.invokedFailure(active, 'qualification-repair-agent-failed');
+            const settled = await this.settleQualificationRepair(active, config, recovered, deniedPathsBaseline);
+            if ('status' in settled)
+                return settled;
+            active = settled.active;
+            repairAttempts = active.record.checkQualification.repairAttempts;
+        }
         while (true) {
+            const captured = await this.ensureCandidateBinding(active, config, {
+                kind: 'qualification', repairAttempt: repairAttempts,
+            });
+            if ('status' in captured)
+                return captured;
+            active = captured.active;
+            const qualificationBinding = active.record.candidateBinding;
             const checks = [];
             const failures = [];
             for (const [id, command] of configuredChecks) {
                 if (this.signal.aborted)
                     return this.terminal(active, { status: 'cancelled' });
+                if (this.dependencies.checks.supportsLaunchOwnership !== true) {
+                    return this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true }, 'candidate-check-launch-ownership-required');
+                }
+                const execution = await this.prepareCandidateExecution(active, config, 'qualification-check', `${id}:${checkPolicySha256}`);
+                if ('status' in execution)
+                    return execution;
+                active = execution.active;
+                const lease = execution.lease;
                 let check;
                 try {
                     check = await this.dependencies.checks.run({
                         id, command, source: checkPolicy.source,
-                        cwd: active.record.worktreePath,
+                        cwd: lease.path,
                         phase: 'qualification',
                         signal: this.signal,
+                        onLaunched: async ({ pid, processGroupId }) => {
+                            active = await this.persist(active, {
+                                executionLease: this.dependencies.git.candidateV2.markExecutionLaunched({
+                                    lease, pid, processGroupId, launchedAt: this.timestamp(),
+                                }),
+                            });
+                        },
                     });
                 }
                 catch (error) {
@@ -2298,9 +2937,18 @@ export class RunIssue {
                     }
                     return this.invokedFailure(active, 'qualification-check-execution-failed', error instanceof Error ? error.message : 'The qualification check process did not start or settle. Retry the same run.');
                 }
+                const settledExecution = await this.settleCandidateExecution(active, config);
+                if ('status' in settledExecution)
+                    return settledExecution;
+                active = settledExecution.active;
                 if (this.signal.aborted)
                     return this.terminal(active, { status: 'cancelled' });
-                checks.push({ id, command, status: check.status, outputSha256: check.outputSha256 });
+                checks.push({
+                    id, command, status: check.status, outputSha256: check.outputSha256,
+                    bindingId: qualificationBinding.bindingId,
+                    candidateTreeSha: qualificationBinding.candidateTreeSha,
+                    checkPolicySha256,
+                });
                 if (check.status === 'failed') {
                     failures.push(`Pre-implementation scoped check ${id} failed (${command}):\n${check.output.toString('utf8').slice(0, 8 * 1024)}`);
                 }
@@ -2308,19 +2956,28 @@ export class RunIssue {
             active = await this.persist(active, {
                 checkQualification: {
                     version: 1, checkPolicySha256, repairAttempts, checks,
-                    implementationStarted: false, repairInvocation: null,
                 },
                 baselineChecks: undefined,
             });
-            if (failures.length === 0)
-                return { active };
+            if (failures.length === 0) {
+                const released = await this.clearAndReleaseCandidate(active);
+                return 'status' in released ? released : { active: released.active };
+            }
             if (repairAttempts >= config.runner.maxCycles) {
                 return this.terminal(active, { status: 'blocked', kind: 'exhausted', resumable: true }, 'qualification-repair-exhausted');
             }
             if (!await this.authorized(active, config)) {
                 return this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true });
             }
+            const released = await this.clearAndReleaseCandidate(active);
+            if ('status' in released)
+                return released;
+            active = released.active;
             const deniedPathsBaseline = await this.dependencies.git.fingerprintDeniedPaths(active.record.worktreePath, config.deny.readPaths);
+            active = await this.persist(active, {
+                checkQualification: { ...active.record.checkQualification, repairFindings: [...failures] },
+            });
+            const invocationState = this.mutableInvocationState(() => active, (next) => { active = next; });
             const repair = await this.runImplementation({
                 operation: 'qualification-repair',
                 runId: active.record.runId,
@@ -2331,82 +2988,37 @@ export class RunIssue {
                 reworkFindings: failures,
                 repairOnly: false,
                 workflowGeneration: active.record.workflowGeneration,
-                onPrepared: async (invocation) => {
-                    active = await this.persist(active, {
-                        checkQualification: {
-                            ...active.record.checkQualification,
-                            implementationStarted: false,
-                            deniedPathsBaseline,
-                            repairInvocation: {
-                                ...structuredClone(invocation), phase: 'prepared',
-                                pid: null, processGroupId: null, launchedAt: null,
-                            },
-                        },
-                    });
-                },
-                onLaunched: async (invocation) => {
-                    const current = active.record.checkQualification?.repairInvocation;
-                    if (!current || current.phase !== 'prepared' || current.attemptId !== invocation.attemptId) {
-                        throw new Error('qualification repair launch mismatch');
-                    }
-                    repairAttempts = (repairAttempts + 1);
-                    active = await this.persist(active, {
-                        checkQualification: {
-                            ...active.record.checkQualification, repairAttempts,
-                            repairInvocation: {
-                                ...current, phase: 'launched', pid: invocation.pid,
-                                processGroupId: invocation.processGroupId, launchedAt: invocation.launchedAt,
-                            },
-                        },
-                    });
-                },
+                phaseFacts: [deniedPathsBaseline],
+                invocationState,
             });
             if (repair.kind === 'safe-halt') {
-                active = await this.persist(active, {
-                    lifecycle: 'safe-halt',
-                    process: {
-                        ...repair.process,
-                        purpose: 'implementation',
-                        resumeLifecycle: 'implementing',
-                        resumeReviewStage: null,
-                    },
-                });
-                while (true) {
-                    try {
-                        await repair.waitForAbsence();
-                        break;
-                    }
-                    catch {
-                        await new Promise((resolveWait) => setTimeout(resolveWait, 25));
-                    }
-                }
-                if (await this.dependencies.git.fingerprintDeniedPaths(active.record.worktreePath, config.deny.readPaths) !== deniedPathsBaseline) {
-                    return this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true }, 'denied-path-modified');
-                }
-                return this.terminal(active, { status: 'transport-failed', resumable: false }, 'process-quiescence-delayed');
+                return this.invokedFailure(active, repair.code);
             }
             if (repair.kind !== 'completed'
                 && await this.dependencies.git.fingerprintDeniedPaths(active.record.worktreePath, config.deny.readPaths) !== deniedPathsBaseline) {
-                return this.terminal(active, { status: 'blocked', kind: 'safety', resumable: true }, 'denied-path-modified');
+                return this.invokedFailure(active, 'qualification-repair-effect-unresolved');
             }
             if (repair.kind === 'cancelled')
                 return this.terminal(active, { status: 'cancelled' });
             if (repair.kind !== 'completed') {
                 return this.invokedFailure(active, 'qualification-repair-agent-failed', 'Qualification repair did not complete. Retry the same run.');
             }
-            const settled = await this.settleQualificationRepair(active, config, repair);
+            const settled = await this.settleQualificationRepair(active, config, repair, deniedPathsBaseline);
             if ('status' in settled)
                 return settled;
             active = settled.active;
+            repairAttempts = active.record.checkQualification.repairAttempts;
         }
     }
-    async settleQualificationRepair(active, config, repair) {
-        const deniedPathsBaseline = active.record.checkQualification?.deniedPathsBaseline;
-        if (!deniedPathsBaseline
-            || await this.dependencies.git.fingerprintDeniedPaths(active.record.worktreePath, config.deny.readPaths) !== deniedPathsBaseline) {
+    async settleQualificationRepair(active, config, repair, deniedPathsBaseline) {
+        if (await this.dependencies.git.fingerprintDeniedPaths(active.record.worktreePath, config.deny.readPaths) !== deniedPathsBaseline) {
+            active = await this.persist(active, { mutableInvocation: undefined });
             return this.terminal(active, { status: 'blocked', kind: 'safety', resumable: false }, 'denied-path-modified');
         }
-        active = await this.clearQualificationRepairInvocation(active);
+        const qualification = { ...active.record.checkQualification };
+        delete qualification.repairFindings;
+        qualification.repairAttempts = (qualification.repairAttempts + 1);
+        active = await this.persist(active, { checkQualification: qualification, mutableInvocation: undefined });
         let report;
         try {
             report = validateImplementationReport(repair.report);
@@ -2426,71 +3038,6 @@ export class RunIssue {
         }
         return { active };
     }
-    async clearQualificationRepairInvocation(active) {
-        const qualification = { ...active.record.checkQualification, implementationStarted: false, repairInvocation: null };
-        delete qualification.deniedPathsBaseline;
-        return this.persist(active, { checkQualification: qualification });
-    }
-    hasRecordedImplementationStart(record, config) {
-        const qualification = record.checkQualification;
-        if (!qualification)
-            return false;
-        let policy;
-        try {
-            policy = resolveIssueCheckPolicy(record.issueSnapshot.body, config.checks);
-        }
-        catch {
-            return false;
-        }
-        return qualification.implementationStarted === true
-            && qualification.checkPolicySha256 === sha256(canonicalJson(policy.checks))
-            && sameCheckPolicy(qualification.checks, policy.checks)
-            && qualification.checks.every((check) => check.status === 'passed');
-    }
-    async recoverTerminalReviewReport(active, issue, config, frozenCriteria) {
-        const directReview = active.record.directReview;
-        const allowLegacyMalformed = directReview?.terminalCode === undefined
-            && active.record.outcomeEvidenceId === `evidence:${active.record.runId}:direct-review-report-malformed`;
-        if (!issue || !directReview || active.record.intent || active.record.process
-            || active.record.terminalOutcome?.status !== 'internal-error'
-            || directReview.status !== 'terminal' || directReview.terminalOutcome?.status !== 'internal-error'
-            || !canRecoverTerminalDirectReviewReport(directReview, { allowLegacyMalformed })
-            || !this.isAuthorizedIssue(issue, active.record, config))
-            return undefined;
-        let worktree;
-        try {
-            worktree = await this.dependencies.git.inspectWorktree({
-                worktreePath: active.record.worktreePath,
-                branchName: active.record.branchName,
-                baseSha: active.record.baseSha,
-            });
-        }
-        catch {
-            return undefined;
-        }
-        if (worktree !== 'matching'
-            || await this.dependencies.git.getHead(active.record.worktreePath) !== expectedImplementationHead(active.record))
-            return undefined;
-        const changedFiles = await this.dependencies.git.listChangedFiles(active.record.worktreePath);
-        if (changedFiles.length === 0 || !active.record.routeReceipt)
-            return undefined;
-        const targetFingerprint = directReviewTargetFingerprint({
-            snapshot: await this.dependencies.git.snapshot(active.record.worktreePath),
-            changedFiles,
-            routeDecisionSha256: active.record.routeReceipt.decisionSha256,
-            workflowGenerationHash: active.record.workflowGeneration.generationHash,
-            cycle: active.record.cycle,
-            frozenCriteria,
-        });
-        if (targetFingerprint !== directReview.targetFingerprint)
-            return undefined;
-        return this.persist(active, {
-            lifecycle: 'implementing',
-            directReview: recoverTerminalDirectReviewReport(directReview, { allowLegacyMalformed }),
-            terminalOutcome: undefined,
-            outcomeEvidenceId: undefined,
-        });
-    }
     async startNextCycle(active, findings, sources) {
         if (active.record.directReview?.status === 'clear') {
             const fallbackProvenance = active.record.lifecycle === 'proving' ? 'proof' : 'check';
@@ -2511,6 +3058,8 @@ export class RunIssue {
             }));
             return this.persist(active, {
                 lifecycle: 'implementing',
+                changeBindingVersion: undefined,
+                candidateBinding: undefined,
                 cycle: active.record.reviewFeedback?.activeBatch
                     ? active.record.cycle
                     : (active.record.cycle + 1),
@@ -2528,6 +3077,8 @@ export class RunIssue {
         active = await this.persist(active, { lifecycle: 'reworking', reworkFindings: [...findings] });
         return this.persist(active, {
             lifecycle: 'implementing',
+            changeBindingVersion: undefined,
+            candidateBinding: undefined,
             cycle: active.record.reviewFeedback?.activeBatch
                 ? active.record.cycle
                 : (active.record.cycle + 1),
@@ -2540,12 +3091,39 @@ export class RunIssue {
             proofReceipt: undefined,
         });
     }
+    async startNextCycleFromCandidate(active, findings, sources) {
+        const binding = active.record.candidateBinding;
+        const candidate = this.dependencies.git.candidateV2;
+        if (!binding || !candidate)
+            return this.startNextCycle(active, findings, sources);
+        if (active.record.executionLease) {
+            return this.terminal(active, { status: 'blocked', kind: 'safety', resumable: false }, 'candidate-execution-not-quiescent');
+        }
+        const normalized = await candidate.normalizeSharedIndex({
+            worktreePath: active.record.worktreePath,
+            expectedHeadSha: expectedImplementationHead(active.record),
+        });
+        if (normalized.kind === 'failed')
+            return this.mapCandidateFailure(active, normalized.code);
+        const transitioned = await this.startNextCycle(active, findings, sources);
+        const released = await candidate.releasePin({ binding, expectedPinnedCommitSha: binding.candidateCommitSha });
+        if (released.kind === 'failed') {
+            return this.invokedFailure(transitioned, 'candidate-pin-release-pending', 'The next repair cycle is durable; orphan reconciliation will retry exact pin cleanup.');
+        }
+        return transitioned;
+    }
     repairBudgetExhausted(active, maxCycles) {
         return active.record.reviewFeedback?.activeBatch
             ? active.record.reviewFeedback.repairRound >= 3
             : active.record.cycle >= maxCycles;
     }
     async blockReviewFeedback(active, kind, evidenceCode) {
+        if (active.record.mutableInvocation) {
+            const reconciled = await this.reconcileMutableBeforeTerminal(active);
+            if ('status' in reconciled)
+                return reconciled;
+            active = reconciled.active;
+        }
         const feedback = active.record.reviewFeedback;
         if (!feedback?.activeBatch)
             return this.terminal(active, { status: 'blocked', kind, resumable: false }, evidenceCode);
@@ -2576,6 +3154,7 @@ export class RunIssue {
             }
             if (canReduceAuthority && !sameStrings(issue.labels, blockedLabels)) {
                 try {
+                    await this.markV3ExternalEffect(active);
                     await this.dependencies.issues.setLabels(active.record.issueNumber, blockedLabels);
                 }
                 catch {
@@ -2598,7 +3177,7 @@ export class RunIssue {
             ...(directReview ? { directReview } : {}),
             terminalOutcome,
             outcomeEvidenceId: evidence.id,
-            process: undefined,
+            reportInvocation: undefined,
             intent: undefined,
         });
         return publicOutcome(terminalOutcome);
@@ -2628,7 +3207,21 @@ export class RunIssue {
         const evidence = await this.dependencies.writeEvidence({ runId: active.record.runId, code, summary });
         return { status: 'transport-failed', resumable: true, evidencePath: evidence.path };
     }
+    async markV3ExternalEffect(active) {
+        if (active.state.version !== 3)
+            return;
+        if (!this.dependencies.runRecords.markPublicationEffectPossible) {
+            throw new Error('run-state publication watermark is unavailable');
+        }
+        await this.dependencies.runRecords.markPublicationEffectPossible();
+    }
     async terminal(active, outcome, evidenceCode = outcome.status, retainIntent = false) {
+        if (active.record.mutableInvocation) {
+            const reconciled = await this.reconcileMutableBeforeTerminal(active);
+            if ('status' in reconciled)
+                return reconciled;
+            active = reconciled.active;
+        }
         if (active.record.reviewFeedback?.activeBatch && outcome.status !== 'review-ready') {
             return this.blockReviewFeedback(active, outcome.status === 'blocked' && outcome.kind === 'exhausted' ? 'exhausted' : 'safety', evidenceCode);
         }
@@ -2637,6 +3230,68 @@ export class RunIssue {
         }
         return this.persistTerminal(active, outcome, evidenceCode, retainIntent);
     }
+    async reconcileMutableBeforeTerminal(starting) {
+        let active = starting;
+        const invocation = active.record.mutableInvocation;
+        if (!invocation)
+            return { active };
+        let deniedPathsBaseline;
+        try {
+            deniedPathsBaseline = await this.dependencies.git.fingerprintDeniedPaths(active.record.worktreePath, active.config.deny.readPaths);
+        }
+        catch {
+            return this.invokedFailure(active, 'mutable-operation-terminal-baseline-unavailable');
+        }
+        const qualification = invocation.operation === 'qualification-repair';
+        const feedback = invocation.operation === 'review-feedback-implementation';
+        const repairFindings = invocation.context.reworkFindings;
+        if (qualification && !repairFindings?.length) {
+            return this.invokedFailure(active, 'qualification-repair-correlation-missing');
+        }
+        const activeBatch = feedback ? active.record.reviewFeedback?.activeBatch : undefined;
+        const directReview = feedback ? active.record.directReview : undefined;
+        if (feedback && (!activeBatch || !directReview)) {
+            return this.invokedFailure(active, 'review-feedback-implementation-correlation-missing');
+        }
+        const feedbackProjection = activeBatch && directReview
+            ? projectReviewFeedbackBatch(activeBatch, directReview.targetRevision)
+            : undefined;
+        const phaseFacts = qualification
+            ? [deniedPathsBaseline]
+            : [
+                deniedPathsBaseline,
+                sha256(canonicalJson(resolveIssueCheckPolicy(active.record.issueSnapshot.body, active.config.checks).checks)),
+                canonicalJson(active.record.checkQualification?.checks ?? []),
+            ];
+        const invocationState = this.mutableInvocationState(() => active, (next) => { active = next; });
+        let settled;
+        try {
+            settled = await this.dependencies.implementationAgent.settle({
+                operation: invocation.operation,
+                runId: active.record.runId,
+                worktreePath: active.record.worktreePath,
+                issue: publicIssueSnapshot(active.record.issueSnapshot),
+                frozenCriteria: active.record.frozenCriteria,
+                cycle: qualification ? active.record.checkQualification.repairAttempts + 1 : active.record.cycle,
+                reworkFindings: repairFindings ?? [],
+                repairOnly: invocation.context.repairOnly,
+                workflowGeneration: active.record.workflowGeneration,
+                ...(feedbackProjection ? {
+                    reviewFeedbackRound: active.record.reviewFeedback.repairRound,
+                    reviewFeedback: feedbackProjection.workerFeedback,
+                } : {}),
+                phaseFacts,
+                invocationState,
+                signal: this.signal,
+            });
+        }
+        catch {
+            return this.invokedFailure(active, 'mutable-operation-terminal-settlement-failed');
+        }
+        return settled.kind === 'settled'
+            ? { active }
+            : this.invokedFailure(active, settled.code, 'Mutable invocation remains fenced before terminal reconciliation.');
+    }
     async publishBlockedTerminal(starting, outcome, evidenceCode) {
         let active = starting;
         const autoBlocked = [active.config.github.labels.auto.name, active.config.github.labels.blocked.name].sort();
@@ -2675,6 +3330,7 @@ export class RunIssue {
                 return this.invokedFailure(active, 'blocked-labels-transition-unavailable');
             }
             try {
+                await this.markV3ExternalEffect(active);
                 await this.dependencies.issues.transitionToBlocked(active.record.issueNumber, blockedLabelPolicy(active.config));
             }
             catch {
@@ -2714,6 +3370,7 @@ export class RunIssue {
             return this.invokedFailure(active, 'blocked-labels-transition-unavailable');
         }
         try {
+            await this.markV3ExternalEffect(active);
             await this.dependencies.issues.transitionToBlocked(active.record.issueNumber, blockedLabelPolicy(active.config));
         }
         catch {
@@ -2733,8 +3390,10 @@ export class RunIssue {
             lifecycle: outcome.status,
             terminalOutcome,
             outcomeEvidenceId: evidence.id,
-            process: undefined,
+            reportInvocation: undefined,
         };
+        if (active.record.reportInvocation?.operation === 'code-review')
+            changes.executionLease = undefined;
         if (outcome.status !== 'review-ready' && active.record.directReview && active.record.directReview.status !== 'terminal') {
             changes.directReview = projectTerminalDirectReview(active.record.directReview, outcome.status === 'blocked'
                 ? { status: 'blocked', kind: outcome.kind }
@@ -2763,7 +3422,7 @@ export class RunIssue {
                 });
             }
         }
-        if (active.record.lifecycle === 'triaging' || (active.record.lifecycle === 'safe-halt' && !active.record.routeReceipt)) {
+        if (active.record.lifecycle === 'triaging') {
             changes.routeExecution = undefined;
             changes.routeReceipt = undefined;
         }
@@ -2780,8 +3439,8 @@ export class RunIssue {
         const evidence = await this.dependencies.writeEvidence({ runId: `issue-${issueNumber}`, code: 'cancelled', summary: 'Cancelled.' });
         return { status: 'cancelled', evidencePath: evidence.path };
     }
-    async preClaimTransport(issueNumber) {
-        const evidence = await this.dependencies.writeEvidence({ runId: `issue-${issueNumber}`, code: 'issue-read-failed', summary: 'Issue read failed.' });
+    async preClaimTransport(issueNumber, code = 'issue-read-failed', summary = 'Issue read failed.') {
+        const evidence = await this.dependencies.writeEvidence({ runId: `issue-${issueNumber}`, code, summary });
         return { status: 'transport-failed', resumable: true, evidencePath: evidence.path };
     }
     timestamp() {
@@ -3018,6 +3677,25 @@ function sameFreshness(left, right) {
 function expectedImplementationHead(record) {
     return record.reviewFeedback?.activeBatch?.priorPublishedHeadSha ?? record.baseSha;
 }
+function pendingCandidateBoundary(record) {
+    if (record.lifecycle !== 'implementing')
+        return undefined;
+    const feedback = record.reviewFeedback;
+    if (feedback?.activeBatch && feedback.repairRound >= 1 && feedback.repairRound <= 3) {
+        return {
+            kind: 'review-feedback',
+            batchId: feedback.activeBatch.batchId,
+            repairRound: feedback.repairRound,
+        };
+    }
+    if (record.mutableInvocation?.operation === 'qualification-repair' && record.checkQualification) {
+        return {
+            kind: 'qualification',
+            repairAttempt: record.checkQualification.repairAttempts,
+        };
+    }
+    return { kind: 'implementation-cycle', cycle: record.cycle };
+}
 function commentsWithMarker(issue, marker) {
     return issue.comments.filter((comment) => comment.body.split('\n')[0] === marker);
 }