codex-workflow-v2 2.0.0-beta.13.5 → 2.0.0-beta.13.6

package/dist/src/workflow.js

@@ -3,7 +3,7 @@ import { appendFileSync, existsSync, lstatSync, readFileSync, readdirSync } from
 import { createHash } from 'node:crypto';
 import path from 'node:path';
 import { PROTOCOL_VERSION, STATE_SCHEMA_VERSION, } from './contracts.js';
-import { inspectBoundedWorkflowDependencyCommit, inspectDependencyKnowledgeRefresh, inspectDependencyProvenanceRecovery, } from './dependency-provenance.js';
+import { inspectBoundedWorkflowDependencyCommit, inspectDependencyKnowledgeRefresh, inspectDependencyProvenanceRecovery, workflowDependencyVersionAt, } from './dependency-provenance.js';
 import { inspectHistoricalStepProvenanceRecovery, omittedStepEvidenceCommits, } from './historical-step-provenance.js';
 import { renderBrief, renderPlan, renderResult } from './artifacts.js';
 import { assertDelegationCanAuthorize, hashDelegationPolicy, prepareDelegationGrantGate, } from './delegation.js';
@@ -20,6 +20,7 @@ import { assessDownstreamProofCarryover, assessDownstreamProofReplanRecovery, as
 import { applyAdoptionPosture, assertAdoptionBaselinePreserved, buildAdoptionPreparation, initializeProjectRegistrationAdoption, readCurrentAdoptionPosture, } from './alpha6/adoption.js';
 import { appendCurrentPlanRiskAudit, appendReboundPlanRiskAudit, buildCandidatePlanRiskAuditEvent, buildPlanRiskAuditEvent, readCurrentPlanRiskAudit, readPlanRiskAuditEvents, validatePlanRiskAuditCandidate, } from './alpha6/plan-risk.js';
 import { hashCompletedSteps, hashExecutionAuthorization, preparePreExecutionReplanEvent, preExecutionReplanSidecar, readCurrentPreExecutionReplan, } from './alpha6/preexecution-replan.js';
+import { assessRootCauseReplanDirtyCarryover, } from './alpha6/root-cause-replan-carryover.js';
 import { appendCorrectiveDecisionEvent, appendPlanIntegrityRecoveryDecision, appendRemediationModeRecovery, appendStopEscalateOverride, assertCorrectiveAuditorIndependence, assertGuardedRemediationAttemptAllowed, defaultCorrectiveAuditorActor, effectiveStepAllowedWrites, findCurrentGuardedRemediationPosture, findRemediationModeRecoveryCandidate, findFailedGuardedStepRequiringCorrectiveDecision, readGuardedRemediationPostureForStep, readCorrectiveDecisionEvents, readRemediationEvents, deriveRollingCauseDecision, deriveCurrentCauseDecisionForTask, prepareRemediationEvent, prepareStopEscalateOverride, stopEscalateOverrideDecisionEventIds, } from './alpha6/remediation.js';
 import { assessPlanIntegrityRecovery, defaultPlanIntegrityRecoveryActor, } from './alpha6/plan-integrity.js';
 import { mechanicalCauseBindings, normalizeMechanicalFailures, } from './alpha6/remediation-cause.js';
@@ -2756,11 +2757,15 @@ export class WorkflowService {
         const planIntegrityDirtyCarryover = step.status === 'planned' && dirty.length > 0
             ? this.assessPostRebindCheckSupportDirtyCarryover(context.identity.repositoryRoot, task, stepId)
             : null;
+        const rootCauseReplanDirtyCarryover = step.status === 'planned' && dirty.length > 0
+            ? this.assessCurrentRootCauseReplanDirtyCarryover(context.identity.repositoryRoot, task, stepId)
+            : null;
         if (step.status === 'planned'
             && dirty.length > 0
             && !resumesCorrectiveReplan
             && !downstreamProofCarryover?.eligible
-            && !planIntegrityDirtyCarryover?.eligible) {
+            && !planIntegrityDirtyCarryover?.eligible
+            && !rootCauseReplanDirtyCarryover?.eligible) {
             throw new WorkflowError('GIT_PRECONDITION_FAILED', `${stepId} must start from a clean checkout.`, {
                 changedFiles: dirty,
                 ...(downstreamProofCarryover?.applicable
@@ -2769,6 +2774,9 @@ export class WorkflowService {
                 ...(planIntegrityDirtyCarryover?.applicable
                     ? { planIntegrityDirtyCarryoverBlockers: planIntegrityDirtyCarryover.blockers }
                     : {}),
+                ...(rootCauseReplanDirtyCarryover?.applicable
+                    ? { rootCauseReplanDirtyCarryoverBlockers: rootCauseReplanDirtyCarryover.blockers }
+                    : {}),
             });
         }
         const dirtyOutsideStep = dirty.filter((file) => !pathAllowed(file, allowedWrites));
@@ -4174,7 +4182,145 @@ export class WorkflowService {
         const task = snapshot.tasks.find((candidate) => candidate.id === taskId);
         if (!task)
             throw new WorkflowError('NOT_FOUND', `Task ${taskId} was not found in this repository.`);
-        return this.inspectDependencyProvenanceCandidate(snapshot, task);
+        const carryover = this.assessCurrentRootCauseReplanDirtyCarryover(snapshot.identity.repositoryRoot, task);
+        const preflight = this.inspectDependencyProvenanceCandidate(snapshot, task, null, null, null, null, carryover.eligible ? carryover.compatibility : null);
+        if (!preflight.rootCauseReplan)
+            return preflight;
+        let baseTip = null;
+        let baseDependency = null;
+        try {
+            baseTip = runGit(snapshot.identity.repositoryRoot, ['rev-parse', task.baseBranch]);
+            baseDependency = inspectBoundedWorkflowDependencyCommit(snapshot.identity.repositoryRoot, baseTip);
+        }
+        catch {
+            // The blocker below keeps a missing or unreadable base reference fail closed.
+        }
+        const bridgeBlockers = [
+            ...(preflight.dependencyCommits.length !== 1
+                ? ['Corrective carryover recovery requires exactly one Task dependency-only commit.'] : []),
+            ...(preflight.parentCommitSha !== preflight.rootCauseReplan.sourceHeadCommit
+                ? ['Corrective carryover dependency parent must equal the bound source HEAD.'] : []),
+            ...(preflight.parentCommitSha
+                && workflowDependencyVersionAt(snapshot.identity.repositoryRoot, preflight.parentCommitSha) !== '2.0.0-beta.13.5'
+                ? ['Corrective carryover dependency parent must declare exact source 2.0.0-beta.13.5.'] : []),
+            ...(preflight.dependencyCommits.at(-1)?.packageVersion !== '2.0.0-beta.13.6'
+                ? ['Corrective carryover dependency commit must declare exact target 2.0.0-beta.13.6.'] : []),
+            ...(!baseDependency
+                || baseDependency.commitSha !== baseTip
+                || baseDependency.packageVersion !== '2.0.0-beta.13.6'
+                || workflowDependencyVersionAt(snapshot.identity.repositoryRoot, baseDependency.parentCommitSha) !== '2.0.0-beta.13.5'
+                ? ['Corrective carryover Milestone-base tip must be one exact 2.0.0-beta.13.5 to 2.0.0-beta.13.6 dependency-only commit.'] : []),
+        ];
+        return bridgeBlockers.length === 0
+            ? preflight
+            : {
+                ...preflight,
+                eligible: false,
+                action: null,
+                commitSha: null,
+                parentCommitSha: null,
+                blockers: [...new Set([...preflight.blockers, ...bridgeBlockers])],
+            };
+    }
+    correctiveCarryoverUpdatePreflight(repository, taskId) {
+        const snapshot = this.observationSnapshot(repository);
+        const task = snapshot.tasks.find((candidate) => candidate.id === taskId);
+        if (!task)
+            throw new WorkflowError('NOT_FOUND', `Task ${taskId} was not found in this repository.`);
+        const sourceVersion = '2.0.0-beta.13.5';
+        const targetVersion = '2.0.0-beta.13.6';
+        const versions = inspectWorkflowVersions(snapshot.identity.repositoryRoot, [task.baseBranch]);
+        const sourceSurfaces = {
+            declared: versions.declared,
+            locked: versions.locked,
+            installed: versions.installed,
+            currentBranch: versions.currentBranch,
+            baseBranch: versions.milestoneBases.find((base) => base.branch === task.baseBranch)?.version ?? null,
+        };
+        const assessment = this.assessCurrentRootCauseReplanDirtyCarryover(snapshot.identity.repositoryRoot, task);
+        const c1 = readTaskC1Posture(this.store, task);
+        const now = this.now().getTime();
+        const activeLeases = snapshot.leases.filter((lease) => Date.parse(lease.expiresAt) > now);
+        const staleLeases = snapshot.leases.filter((lease) => Date.parse(lease.expiresAt) <= now);
+        const transactionCount = snapshot.observation.pendingProjectTransactions.length
+            + snapshot.observation.pendingMilestoneTransactions.length
+            + snapshot.observation.pendingTaskTransactions.length;
+        const authorizationBlockers = [];
+        if (assessment.eligible) {
+            try {
+                this.assertExecutionAuthorizationFresh(task, snapshot.identity.repositoryRoot);
+            }
+            catch (error) {
+                authorizationBlockers.push(error instanceof Error ? error.message : String(error));
+            }
+        }
+        const baseBlockers = [
+            ...assessment.blockers,
+            ...authorizationBlockers,
+            ...(PACKAGE_VERSION !== targetVersion ? [`Runner must be the exact ${targetVersion} compatibility target.`] : []),
+            ...Object.entries(sourceSurfaces)
+                .filter(([, version]) => version !== sourceVersion)
+                .map(([surface]) => `${surface} Workflow version must equal the exact ${sourceVersion} source.`),
+            ...observationPreflightBlockers(snapshot.observation),
+            ...(transactionCount > 0 ? ['No pending Workflow transaction may exist.'] : []),
+            ...(snapshot.observation.corruptTaskTransactions.length > 0 ? ['No corrupt Task transaction may exist.'] : []),
+            ...(snapshot.observation.coreTaskOperations.length > 0 ? ['No Core Task operation may exist.'] : []),
+            ...(c1.state !== 'claimed' || assessment.compatibility?.claimant !== c1.claimant
+                ? ['The exact original Worker C1 claim must remain current.'] : []),
+            ...(activeLeases.length > 0 ? ['No live writer lease may exist during corrective carryover transport.'] : []),
+            ...(staleLeases.some((lease) => lease.entityId !== task.id
+                || c1.state !== 'claimed' || lease.owner !== c1.claimant
+                || createHash('sha256').update(lease.token).digest('hex') !== c1.writerLeaseTokenHash)
+                ? ['No unrelated or differently owned stale writer lease may exist.'] : []),
+            ...(staleLeases.length > 1 ? ['At most the exact corrective Task stale lease may exist.'] : []),
+        ];
+        const repairableStale = baseBlockers.length === 0 && staleLeases.length === 1
+            ? staleLeases[0]
+            : null;
+        const blockers = [
+            ...baseBlockers,
+            ...(repairableStale
+                ? ['Repair the exact expired claimant lease with source locks repair, then run status, next, and this preflight again.']
+                : []),
+        ];
+        const compatibility = assessment.compatibility;
+        return {
+            readOnly: true,
+            eligible: Boolean(assessment.eligible && compatibility && blockers.length === 0 && staleLeases.length === 0),
+            action: assessment.eligible && compatibility && blockers.length === 0 && staleLeases.length === 0
+                ? 'update corrective-carryover-transport'
+                : null,
+            projectId: task.projectId,
+            taskId: task.id,
+            taskRevision: task.revision,
+            stepId: compatibility?.stepId ?? null,
+            sourceVersion,
+            targetVersion,
+            sourceHeadCommit: compatibility?.sourceHeadCommit ?? null,
+            taskBranch: task.taskBranch,
+            baseBranch: task.baseBranch,
+            dirtyFiles: compatibility?.dirtyFiles ?? [],
+            dirtyWorktreeHash: compatibility?.dirtyWorktreeHash ?? null,
+            compatibilityHash: compatibility?.compatibilityHash ?? null,
+            c1Posture: c1.state === 'claimed' ? {
+                state: 'claimed',
+                claimant: c1.claimant,
+                claimEventId: compatibility?.c1ClaimEventId ?? null,
+                claimEventHash: compatibility?.c1ClaimEventHash ?? null,
+            } : null,
+            staleLeaseRepair: repairableStale ? [{
+                    action: 'locks repair',
+                    entityId: task.id,
+                    owner: repairableStale.owner,
+                    expiresAt: repairableStale.expiresAt,
+                }] : [],
+            requiredTransport: [
+                'Commit only package.json and package-lock.json on the active Milestone base.',
+                'Commit only the same dependency files on the Task branch while preserving the bound dirty bytes.',
+                'Install the exact target package, register dependency provenance, refresh context, replace the same Worker credential, then follow fresh next.',
+            ],
+            blockers,
+        };
     }
     historicalStepProvenanceRecoveryPreflight(repository, taskId) {
         const snapshot = this.observationSnapshot(repository);
@@ -4645,7 +4791,9 @@ export class WorkflowService {
                     ? Boolean(record.historicalStepProvenance)
                     : recoveryMode === 'plan-integrity'
                         ? Boolean(record.planIntegrity)
-                        : Boolean(record.activeDownstreamProof) === recoveryMode));
+                        : recoveryMode === false && record.rootCauseReplan
+                            ? true
+                            : Boolean(record.activeDownstreamProof) === recoveryMode));
         if (prior && current.systemCommits.includes(currentHead))
             return current;
         assertExpectedRevision(current, expectedRevision);
@@ -4661,13 +4809,26 @@ export class WorkflowService {
                     ? this.planIntegrityDependencyRecoveryPreflight(repository, taskId)
                     : recoveryMode
                         ? this.activeDownstreamProofDependencyRecoveryPreflight(repository, taskId)
-                        : this.inspectDependencyProvenanceCandidate(snapshot, task);
+                        : this.dependencyProvenanceRecoveryPreflight(repository, taskId);
         if (!preflight.eligible || !preflight.commitSha || !preflight.parentCommitSha) {
             throw new WorkflowError('GIT_PRECONDITION_FAILED', 'The bounded dependency provenance recovery preflight failed.', {
                 taskId,
                 blockers: preflight.blockers,
             });
         }
+        if (preflight.rootCauseReplan) {
+            const posture = readTaskC1Posture(this.store, task);
+            if (posture.state !== 'claimed'
+                || posture.claimant !== preflight.rootCauseReplan.claimant
+                || normalizedActor !== posture.claimant) {
+                throw new WorkflowError('TRANSITION_BLOCKED', 'Corrective carryover dependency recovery requires the exact retained C1 claimant actor.', {
+                    taskId,
+                    actor: normalizedActor,
+                    requiredActor: preflight.rootCauseReplan.claimant,
+                    posture: posture.state,
+                });
+            }
+        }
         const now = this.now();
         const recoveredRecords = preflight.dependencyCommits.map((dependencyCommit, index) => {
             const isTerminalCommit = index === preflight.dependencyCommits.length - 1;
@@ -4693,6 +4854,9 @@ export class WorkflowService {
                 ...(isTerminalCommit && preflight.planIntegrity
                     ? { planIntegrity: preflight.planIntegrity }
                     : {}),
+                ...(isTerminalCommit && preflight.rootCauseReplan
+                    ? { rootCauseReplan: preflight.rootCauseReplan }
+                    : {}),
             };
         });
         const nextTask = {
@@ -6039,6 +6203,9 @@ export class WorkflowService {
         }
         const next = this.taskGitNavigationOverride(task) ?? nextForTask(task);
         const nextStepId = typeof next.stepId === 'string' ? next.stepId : null;
+        const rootCauseStepId = nextStepId
+            ?? task.steps.find((candidate) => candidate.status === 'planned')?.id
+            ?? null;
         const downstreamProofCarryover = next.action === 'task run'
             && nextStepId
             && changedFiles(repositoryRoot).length > 0
@@ -6049,6 +6216,24 @@ export class WorkflowService {
             && changedFiles(repositoryRoot).length > 0
             ? this.assessPostRebindCheckSupportDirtyCarryover(repositoryRoot, task, nextStepId)
             : null;
+        let rootCauseReplanDirtyCarryover = ['task run', 'task handoff-prepare', 'task claim'].includes(String(next.action))
+            && rootCauseStepId
+            && changedFiles(repositoryRoot).length > 0
+            ? this.assessCurrentRootCauseReplanDirtyCarryover(repositoryRoot, task, rootCauseStepId)
+            : null;
+        if (rootCauseReplanDirtyCarryover?.eligible) {
+            try {
+                this.assertExecutionAuthorizationFresh(task, repositoryRoot);
+            }
+            catch (error) {
+                rootCauseReplanDirtyCarryover = {
+                    applicable: true,
+                    eligible: false,
+                    compatibility: null,
+                    blockers: [error instanceof Error ? error.message : String(error)],
+                };
+            }
+        }
         let mechanicalFeasibilityOverlay = {};
         if (task.status === 'awaiting_execution_authorization' && task.planHash) {
             try {
@@ -6678,7 +6863,7 @@ export class WorkflowService {
                         downstreamProofCarryover: {
                             state: 'validated',
                             invalidationEventId: downstreamProofCarryover.invalidationEventId,
-                            stepId: nextStepId,
+                            stepId: rootCauseStepId,
                             dirtyFiles: downstreamProofCarryover.dirtyFiles,
                             dirtyWorktreeHash: downstreamProofCarryover.dirtyWorktreeHash,
                             meaning: 'The replacement Step may adopt exactly these preserved uncommitted bytes on task run.',
@@ -6718,6 +6903,52 @@ export class WorkflowService {
                         },
                     }
                 : {}),
+            ...(rootCauseReplanDirtyCarryover?.applicable
+                ? rootCauseReplanDirtyCarryover.eligible && rootCauseReplanDirtyCarryover.compatibility
+                    ? {
+                        action: 'task run',
+                        rootCauseReplanDirtyCarryover: {
+                            state: 'validated',
+                            stepId: nextStepId,
+                            compatibilityHash: rootCauseReplanDirtyCarryover.compatibility.compatibilityHash,
+                            dirtyFiles: rootCauseReplanDirtyCarryover.compatibility.dirtyFiles,
+                            dirtyWorktreeHash: rootCauseReplanDirtyCarryover.compatibility.dirtyWorktreeHash,
+                            meaning: 'The replacement Step may adopt the exact retained root-cause failure bytes.',
+                        },
+                    }
+                    : rootCauseReplanDirtyCarryover.blockers.length === 1
+                        && rootCauseReplanDirtyCarryover.blockers[0]?.startsWith('Corrective carryover requires the retained claimed C1')
+                        ? handoffPosture.state === 'none'
+                            ? {
+                                action: 'task handoff-prepare',
+                                blockedAction: 'task run',
+                                rootCauseReplanDirtyCarryover: {
+                                    state: 'awaiting-c1',
+                                    stepId: rootCauseStepId,
+                                    requiredActor: defaultTaskWorkerActor(task.id),
+                                },
+                            }
+                            : handoffPosture.state === 'pending'
+                                ? {}
+                                : {
+                                    action: 'doctor',
+                                    blockedAction: 'task run',
+                                    rootCauseReplanDirtyCarryover: {
+                                        state: 'blocked',
+                                        stepId: rootCauseStepId,
+                                        blockers: rootCauseReplanDirtyCarryover.blockers,
+                                    },
+                                }
+                        : {
+                            action: 'doctor',
+                            blockedAction: 'task run',
+                            rootCauseReplanDirtyCarryover: {
+                                state: 'blocked',
+                                stepId: rootCauseStepId,
+                                blockers: rootCauseReplanDirtyCarryover.blockers,
+                            },
+                        }
+                : {}),
             ...(delegatedApprovalOptions.length > 0 ? { delegatedApprovalOptions } : {}),
             ...(correctiveDerivedAuthority && correctiveDerivedActor
                 ? {
@@ -6734,7 +6965,10 @@ export class WorkflowService {
                 }
                 : {}),
         };
-        if (handoffPosture.state === 'pending') {
+        const rootCauseAllowsPendingClaim = !rootCauseReplanDirtyCarryover?.applicable
+            || (rootCauseReplanDirtyCarryover.blockers.length === 1
+                && rootCauseReplanDirtyCarryover.blockers[0]?.startsWith('Corrective carryover requires the retained claimed C1'));
+        if (handoffPosture.state === 'pending' && rootCauseAllowsPendingClaim) {
             return this.withTaskNavigationContracts(task, {
                 ...result,
                 action: 'task claim',
@@ -7256,7 +7490,7 @@ export class WorkflowService {
             blockers,
         };
     }
-    inspectDependencyProvenanceCandidate(snapshot, task, activeDownstreamProof = null, downstreamProofReplan = null, historicalStepProvenance = null, planIntegrity = null) {
+    inspectDependencyProvenanceCandidate(snapshot, task, activeDownstreamProof = null, downstreamProofReplan = null, historicalStepProvenance = null, planIntegrity = null, rootCauseReplan = null) {
         const versions = inspectWorkflowVersions(snapshot.identity.repositoryRoot, [task.baseBranch]);
         const now = this.now().getTime();
         return inspectDependencyProvenanceRecovery(snapshot.identity.repositoryRoot, task, {
@@ -7276,7 +7510,43 @@ export class WorkflowService {
                 currentBranch: versions.currentBranch,
                 baseBranch: versions.milestoneBases.find((base) => base.branch === task.baseBranch)?.version ?? null,
             },
-        }, activeDownstreamProof, downstreamProofReplan, historicalStepProvenance, planIntegrity);
+        }, activeDownstreamProof, downstreamProofReplan, historicalStepProvenance, planIntegrity, rootCauseReplan);
+    }
+    assessCurrentRootCauseReplanDirtyCarryover(repositoryRoot, task, stepId) {
+        const recorded = [...(task.dependencyProvenanceRecoveries ?? [])].reverse().find((record) => record.rootCauseReplan
+            && task.systemCommits.includes(record.commitSha))?.rootCauseReplan ?? null;
+        if (recorded) {
+            if (stepId && stepId !== recorded.stepId) {
+                return {
+                    applicable: true,
+                    eligible: false,
+                    compatibility: null,
+                    blockers: [`Recorded corrective carryover is bound to ${recorded.stepId}, not requested ${stepId}.`],
+                };
+            }
+            return assessRootCauseReplanDirtyCarryover(this.store, repositoryRoot, task, recorded.stepId, {
+                binding: recorded,
+            });
+        }
+        const candidates = task.steps
+            .filter((step) => step.status === 'planned' && (!stepId || step.id === stepId))
+            .flatMap((step) => [...new Set(readRemediationEvents(this.store, task)
+                .filter((event) => event.stepId === step.id && event.failureKind === 'checks-failed')
+                .map((event) => event.failureEvidence.completionCommit))]
+            .map((historyHead) => assessRootCauseReplanDirtyCarryover(this.store, repositoryRoot, task, step.id, { historyHead })))
+            .filter((assessment) => assessment.applicable);
+        const eligible = candidates.filter((assessment) => assessment.eligible && assessment.compatibility);
+        if (eligible.length === 1)
+            return eligible[0];
+        return {
+            applicable: candidates.length > 0,
+            eligible: false,
+            compatibility: null,
+            blockers: [...new Set([
+                    ...candidates.flatMap((assessment) => assessment.blockers),
+                    ...(eligible.length > 1 ? ['Corrective carryover history resolved to more than one eligible boundary.'] : []),
+                ])],
+        };
     }
     inspectHistoricalStepProvenanceCandidate(snapshot, task, options = {}) {
         const now = this.now().getTime();