codex-workflow-v2 2.0.0-beta.12.1 → 2.0.0-beta.12.2

package/dist/src/workflow.js

@@ -20,7 +20,7 @@ import { assessMilestoneInitialAssembly, applyInitialMilestonePlanTransaction, a
 import { applyProjectTransaction, recoverProjectTransactions, runRollbackProjectTransaction, } from './beta1/project-transaction.js';
 import { buildCurrentStrictStepReviewCycle, countUnverifiedStrictStepReviews, ensurePendingStrictStepReview, isStepReviewRequired, latestFailedStepReviewRouting, latestPassedVerifiedStepReviewEvent, recordStrictStepReview, verifiedHistoricalStepReviewCommits, } from './alpha6/review.js';
 import { applyMilestoneAutonomyContract, assertAutonomousPlanEvolution, prepareMilestoneAutonomyContract, readMilestoneAutonomyEvents, requireActiveMilestoneAutonomy, } from './alpha7/autonomy.js';
-import { appendCorrectiveDecisionRecovery, readValidatedCorrectiveDecisionRecoveryForNavigation, requireCorrectiveDecisionRecoveryForRun, } from './alpha7/corrective-recovery.js';
+import { appendCorrectiveDecisionRecovery, readValidatedCorrectiveDecisionRecoveryForNavigation, readValidatedStopOverrideContextRebindIfApplicable, requireCorrectiveDecisionRecoveryForRun, } from './alpha7/corrective-recovery.js';
 import { applyKnowledgeSelections, hashKnowledgeMap, inspectKnowledgeMap, normalizeRelativePath, reconcileKnowledgeMap, scanProjectKnowledge, selectKnowledgeSources, } from './memory.js';
 import { canonicalJsonStringify, sha256Hex } from './alpha6/store-sidecars.js';
 import { ensureDirectory } from './fs-utils.js';
@@ -1827,7 +1827,10 @@ export class WorkflowService {
             const recovery = staleDecision?.decision === 'continue-fix'
                 ? requireCorrectiveDecisionRecoveryForRun(this.store, task, stepId, actor, writerToken)
                 : null;
-            const gate = assertGuardedRemediationAttemptAllowed(this.store, task, stepId, planRiskAudit, recovery?.correctiveDecisionEventId ?? null);
+            const stopOverrideContextRebind = staleDecision?.decision === 'stop-escalate'
+                ? readValidatedStopOverrideContextRebindIfApplicable(this.store, task, stepId)
+                : null;
+            const gate = assertGuardedRemediationAttemptAllowed(this.store, task, stepId, planRiskAudit, recovery?.correctiveDecisionEventId ?? null, stopOverrideContextRebind?.stopDecision.eventId ?? null);
             resumesCorrectiveReplan = gate.posture === 'replan-ready';
         }
         const knowledgeMap = this.assertTaskKnowledgeBinding(context.identity.repositoryRoot, task);
@@ -2065,7 +2068,7 @@ export class WorkflowService {
                     checksHash: sha256Hex(canonicalJsonStringify(checks)),
                     reviewEventHash: null,
                     reviewerAttestationHash: null,
-                }, planRiskAudit, this.now());
+                }, planRiskAudit, this.now(), this.stopOverrideContextRebindDecisionId(task, stepId));
             }
             const steps = task.steps.map((candidate) => candidate.id === stepId ? { ...candidate, status: 'failed' } : candidate);
             return this.store.writeTask({ ...task, status: 'needs_fix', steps, blockReason: `${stepId} checks failed.` }, expectedRevision);
@@ -2185,7 +2188,7 @@ export class WorkflowService {
                     checksHash: currentCycle.reviewRecordedEvent.checksHash,
                     reviewEventHash: currentCycle.reviewRecordedEvent.eventHash,
                     reviewerAttestationHash: currentCycle.reviewerAttestationEvent.eventHash,
-                }, planRiskAudit, this.now());
+                }, planRiskAudit, this.now(), this.stopOverrideContextRebindDecisionId(task, stepId));
             }
             return this.store.writeTask(applyStrictStepReviewResolution(task, stepId, currentCycle.resolution), expectedRevision);
         }
@@ -2213,7 +2216,7 @@ export class WorkflowService {
                 checksHash: reviewRecordedEvent.checksHash,
                 reviewEventHash: reviewRecordedEvent.eventHash,
                 reviewerAttestationHash: reviewerAttestationEvent.eventHash,
-            }, planRiskAudit, this.now());
+            }, planRiskAudit, this.now(), this.stopOverrideContextRebindDecisionId(task, stepId));
         }
         return this.store.writeTask(applyStrictStepReviewResolution(task, stepId, recorded.resolution, launch.review.summary), expectedRevision);
     }
@@ -2285,7 +2288,7 @@ export class WorkflowService {
                 checksHash: recorded.reviewRecordedEvent.checksHash,
                 reviewEventHash: recorded.reviewRecordedEvent.eventHash,
                 reviewerAttestationHash: recorded.reviewerAttestationEvent.eventHash,
-            }, readCurrentPlanRiskAudit(this.store, task), this.now());
+            }, readCurrentPlanRiskAudit(this.store, task), this.now(), this.stopOverrideContextRebindDecisionId(task, stepId));
         }
         const saved = this.store.writeTask(applyStrictStepReviewResolution(task, stepId, recorded.resolution, review.summary), expectedRevision);
         return {
@@ -3956,6 +3959,39 @@ export class WorkflowService {
                 case 'decision-required':
                     if (guardedCorrectivePosture.correctiveDecision
                         && guardedCorrectivePosture.correctiveDecision.planHash !== task.planHash) {
+                        if (guardedCorrectivePosture.correctiveDecision.decision === 'stop-escalate') {
+                            try {
+                                const assessment = readValidatedStopOverrideContextRebindIfApplicable(this.store, task, guardedCorrectivePosture.stepId);
+                                if (!assessment) {
+                                    throw new WorkflowError('TRANSITION_BLOCKED', 'Stale stop decision has no validated stop-override context-rebind continuation.');
+                                }
+                                guardedCorrectiveOverlay = {
+                                    action: 'task run',
+                                    stepId: guardedCorrectivePosture.stepId,
+                                    stopOverrideContextRebind: {
+                                        state: 'validated',
+                                        overrideEventId: assessment.override.eventId,
+                                        stopDecisionEventId: assessment.stopDecision.eventId,
+                                        sourcePlanHash: assessment.override.planHash,
+                                        reboundPlanHash: task.planHash,
+                                        semanticPlanHash: assessment.semanticPlanHash,
+                                        appendOnly: true,
+                                    },
+                                };
+                            }
+                            catch (error) {
+                                guardedCorrectiveOverlay = {
+                                    action: 'doctor',
+                                    stepId: guardedCorrectivePosture.stepId,
+                                    blockedAction: 'task run',
+                                    stopOverrideContextRebind: {
+                                        state: 'blocked',
+                                        reason: error instanceof Error ? error.message : String(error),
+                                    },
+                                };
+                            }
+                            break;
+                        }
                         try {
                             const navigation = readValidatedCorrectiveDecisionRecoveryForNavigation(this.store, task, guardedCorrectivePosture.stepId);
                             guardedCorrectiveOverlay = navigation.recovery
@@ -4234,6 +4270,9 @@ export class WorkflowService {
                 : 'Escalate outside this Task; stop-escalate cannot be resumed or rebound.',
         });
     }
+    stopOverrideContextRebindDecisionId(task, stepId) {
+        return readValidatedStopOverrideContextRebindIfApplicable(this.store, task, stepId)?.stopDecision.eventId ?? null;
+    }
     taskHasTerminalCorrectiveDecision(task) {
         return this.taskTerminalCorrectivePosture(task) !== null;
     }