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

package/dist/src/workflow.js

@@ -13,14 +13,14 @@ import { inspectLocalDependency, inspectWorkflowVersions } from './diagnostics.j
 import { appendTaskClaim, appendTaskHandback, appendTaskHandoff, appendTaskWriterCredentialReplacement, assertTaskClaimAllowed, assertTaskMutationAllowedByC1, defaultTaskWorkerActor, readTaskC1Posture, } from './alpha6/handoff.js';
 import { applyAdoptionPosture, assertAdoptionBaselinePreserved, buildAdoptionPreparation, initializeProjectRegistrationAdoption, readCurrentAdoptionPosture, } from './alpha6/adoption.js';
 import { appendCurrentPlanRiskAudit, appendReboundPlanRiskAudit, readCurrentPlanRiskAudit, validatePlanRiskAuditCandidate, } from './alpha6/plan-risk.js';
-import { appendCorrectiveDecisionEvent, appendPlanIntegrityRecoveryDecision, appendRemediationEvent, appendRemediationModeRecovery, assertCorrectiveAuditorIndependence, assertGuardedRemediationAttemptAllowed, defaultCorrectiveAuditorActor, findCurrentGuardedRemediationPosture, findRemediationModeRecoveryCandidate, findFailedGuardedStepRequiringCorrectiveDecision, readGuardedRemediationPostureForStep, readCorrectiveDecisionEvents, readRemediationEvents, } from './alpha6/remediation.js';
+import { appendCorrectiveDecisionEvent, appendPlanIntegrityRecoveryDecision, appendRemediationEvent, appendRemediationModeRecovery, appendStopEscalateOverride, assertCorrectiveAuditorIndependence, assertGuardedRemediationAttemptAllowed, defaultCorrectiveAuditorActor, findCurrentGuardedRemediationPosture, findRemediationModeRecoveryCandidate, findFailedGuardedStepRequiringCorrectiveDecision, readGuardedRemediationPostureForStep, readCorrectiveDecisionEvents, readRemediationEvents, prepareStopEscalateOverride, stopEscalateOverrideDecisionEventIds, } from './alpha6/remediation.js';
 import { assessPlanIntegrityRecovery, defaultPlanIntegrityRecoveryActor, } from './alpha6/plan-integrity.js';
 import { assertMechanicalFeasibilityFresh, evaluateMechanicalFeasibility, hashMechanicalFeasibilityEvidence, } from './alpha6/mechanical-feasibility.js';
 import { assessMilestoneInitialAssembly, applyInitialMilestonePlanTransaction, applyMilestoneScopeChangeTransaction, assertMilestoneDependenciesDeclared, assertMilestoneTaskRunnable, assessMilestoneTaskDependencies, assertMilestoneMembershipIntegrity, assertMilestoneScopeChangeStatusAllowed, inspectMilestoneWithIntegrity, normalizeMilestonePlan, prepareMilestoneScopeChangeCandidate, prepareMilestoneScopeChangeBundle, readMilestoneForScopeChange, readMilestoneWithIntegrity, } from './alpha6/milestone.js';
 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';
@@ -110,6 +110,31 @@ export class WorkflowService {
             repaired: true,
         };
     }
+    prepareTaskStopOverride(repository, taskId, stepId, expectedRevision, actor, reason) {
+        const snapshot = this.observationSnapshot(repository);
+        if (snapshot.observation.kind !== 'assessment') {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Stop override requires a coherent observation boundary.', {
+                observation: snapshot.observation,
+            });
+        }
+        const task = snapshot.tasks.find((candidate) => candidate.id === taskId) ?? null;
+        if (!task)
+            throw new WorkflowError('NOT_FOUND', `Task ${taskId} was not found in this repository.`);
+        this.assertStopOverrideRepositoryBoundary(snapshot.identity, task);
+        return prepareStopEscalateOverride(this.store, task, stepId, expectedRevision, actor, reason, headCommit(snapshot.identity.repositoryRoot));
+    }
+    applyTaskStopOverride(repository, taskId, stepId, expectedRevision, actor, reason, confirmationCode) {
+        const snapshot = this.observationSnapshot(repository);
+        if (snapshot.observation.kind !== 'assessment') {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Stop override requires a coherent observation boundary.', {
+                observation: snapshot.observation,
+            });
+        }
+        const context = this.#mutationContext(repository);
+        const task = context.store.readTask(context.identity.projectId, taskId);
+        this.assertStopOverrideRepositoryBoundary(context.identity, task, context.locks.list());
+        return appendStopEscalateOverride(context.store, task, stepId, expectedRevision, actor, reason, headCommit(context.identity.repositoryRoot), confirmationCode, this.now());
+    }
     prepareCorrectiveReplan(repository, taskId, candidate) {
         return this.correctiveReplanController(repository).prepare({ taskId, candidate });
     }
@@ -1038,7 +1063,9 @@ export class WorkflowService {
             const passedBoundary = latestPassedVerifiedStepReviewEvent(this.store, task, event.stepId);
             return !passedBoundary || passedBoundary.recordedAt <= event.recordedAt;
         });
-        const currentHardBlockingDecisions = currentPlanCorrectiveDecisions.filter((event) => event.decision === 'split-required' || event.decision === 'stop-escalate');
+        const overriddenStopDecisionEventIds = stopEscalateOverrideDecisionEventIds(this.store, task);
+        const currentHardBlockingDecisions = currentPlanCorrectiveDecisions.filter((event) => event.decision === 'split-required'
+            || (event.decision === 'stop-escalate' && !overriddenStopDecisionEventIds.has(event.eventId)));
         const currentPlanRiskAudit = task.status === 'needs_fix' || currentReplanDecisions.length > 0
             ? readCurrentPlanRiskAudit(this.store, task)
             : null;
@@ -1758,8 +1785,11 @@ export class WorkflowService {
             throw new WorkflowError('TRANSITION_BLOCKED', `Task ${taskId} cannot run a Step while ${task.status}.`);
         }
         this.assertExecutionAuthorizationFresh(task, context.identity.repositoryRoot);
+        const overriddenStopDecisionEventIds = stopEscalateOverrideDecisionEventIds(this.store, task);
         const currentPlanBlockingDecisions = readCorrectiveDecisionEvents(this.store, task)
-            .filter((event) => event.planHash === task.planHash && event.decision !== 'continue-fix');
+            .filter((event) => event.planHash === task.planHash
+            && event.decision !== 'continue-fix'
+            && !(event.decision === 'stop-escalate' && overriddenStopDecisionEventIds.has(event.eventId)));
         if (currentPlanBlockingDecisions.length > 0) {
             throw new WorkflowError('TRANSITION_BLOCKED', `Task ${taskId} cannot run any Step while the current Plan has active blocking corrective decisions.`, {
                 taskId,
@@ -1797,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);
@@ -2035,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);
@@ -2155,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);
         }
@@ -2183,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);
     }
@@ -2255,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 {
@@ -3926,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
@@ -4039,16 +4105,50 @@ export class WorkflowService {
                     }
                     break;
                 case 'stop-escalate':
-                    guardedCorrectiveOverlay = {
-                        action: 'doctor',
-                        stepId: guardedCorrectivePosture.stepId,
-                        correctiveDecisionGate: {
-                            attemptCount: guardedCorrectivePosture.attemptCount,
-                            decision: guardedCorrectivePosture.correctiveDecision?.decision ?? null,
-                            decisionEventId: guardedCorrectivePosture.correctiveDecision?.eventId ?? null,
-                            humanApprovalRequired: false,
-                        },
-                    };
+                    try {
+                        this.assertStopOverrideRepositoryBoundary(resolveRepositoryIdentity(repositoryRoot), task);
+                        prepareStopEscalateOverride(this.store, task, guardedCorrectivePosture.stepId, task.revision, 'user', 'navigation eligibility probe', headCommit(repositoryRoot));
+                        guardedCorrectiveOverlay = {
+                            action: 'task stop-override-prepare',
+                            blockedAction: 'task run',
+                            stepId: guardedCorrectivePosture.stepId,
+                            correctiveDecisionGate: {
+                                attemptCount: guardedCorrectivePosture.attemptCount,
+                                decision: guardedCorrectivePosture.correctiveDecision?.decision ?? null,
+                                decisionEventId: guardedCorrectivePosture.correctiveDecision?.eventId ?? null,
+                                humanApprovalRequired: true,
+                                delegatedApprovalAllowed: false,
+                            },
+                            stopOverride: {
+                                state: 'eligible',
+                                policy: 'beta11-attempt4-stop-compatibility-v1',
+                                prepareCommand: 'task stop-override-prepare',
+                                applyCommand: 'task stop-override-apply',
+                                expectedRevision: task.revision,
+                                appendOnly: true,
+                                preservesOriginalDecision: true,
+                                requiredAction: 'Prepare with an explicit human actor and reason, then apply the exact confirmation code in a later user turn.',
+                            },
+                        };
+                    }
+                    catch (error) {
+                        guardedCorrectiveOverlay = {
+                            action: 'doctor',
+                            blockedAction: 'task stop-override-prepare',
+                            stepId: guardedCorrectivePosture.stepId,
+                            correctiveDecisionGate: {
+                                attemptCount: guardedCorrectivePosture.attemptCount,
+                                decision: guardedCorrectivePosture.correctiveDecision?.decision ?? null,
+                                decisionEventId: guardedCorrectivePosture.correctiveDecision?.eventId ?? null,
+                                humanApprovalRequired: true,
+                            },
+                            stopOverride: {
+                                state: 'blocked',
+                                policy: 'beta11-attempt4-stop-compatibility-v1',
+                                reason: error instanceof Error ? error.message : String(error),
+                            },
+                        };
+                    }
                     break;
                 default:
                     break;
@@ -4170,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;
     }
@@ -4184,6 +4287,42 @@ export class WorkflowService {
             ? posture
             : null;
     }
+    assertStopOverrideRepositoryBoundary(identity, task, observedLeases) {
+        const blockers = [];
+        const dirty = changedFiles(identity.repositoryRoot);
+        if (dirty.length > 0)
+            blockers.push('Repository checkout must be clean.');
+        if (task.workspaceOwner !== 'local')
+            blockers.push('Stop override is limited to a local Task workspace.');
+        if (!task.taskBranch || currentBranch(identity.repositoryRoot) !== task.taskBranch) {
+            blockers.push('The current branch must be the recorded Task branch.');
+        }
+        if (task.steps.some((step) => step.status === 'in_progress'))
+            blockers.push('No Step may be in progress.');
+        const leases = observedLeases
+            ?? new WriterLockManager(this.store.lockRoot(identity.projectId), this.now, this.store.root).list();
+        if (leases.some((lease) => lease.entityId === task.id))
+            blockers.push('No active or stale Task writer lease may exist.');
+        const projectRoot = this.store.projectRoot(identity.projectId);
+        const replanTransactions = inspectCorrectiveReplanTaskTransactions(projectRoot, this.store.root);
+        const yieldTransactions = inspectCorrectiveYieldTaskTransactions(projectRoot, this.store.root);
+        if (replanTransactions.pending.some((transaction) => transaction.taskId === task.id)
+            || replanTransactions.corrupt.some((transaction) => transaction.taskId === task.id)
+            || yieldTransactions.pending.some((transaction) => transaction.taskId === task.id)
+            || yieldTransactions.corrupt.some((transaction) => transaction.taskId === task.id)) {
+            blockers.push('No pending or corrupt Task transaction may exist.');
+        }
+        if (listCoreTaskOperationMutexes(this.store.lockRoot(identity.projectId), this.store.root)
+            .some((operation) => operation.entityId === task.id)) {
+            blockers.push('No Core Task operation may exist.');
+        }
+        if (blockers.length > 0) {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Stop override repository preconditions are not satisfied.', {
+                taskId: task.id,
+                blockers,
+            });
+        }
+    }
     delegatedApprovalOptions(projectId, transition, target) {
         return this.store.listDelegations(projectId)
             .filter((grant) => {