codex-workflow-v2 2.0.0-beta.12.18 → 2.0.0-beta.12.19

package/dist/src/workflow.js

@@ -2401,15 +2401,22 @@ export class WorkflowService {
         const downstreamProofCarryover = step.status === 'planned' && dirty.length > 0
             ? assessDownstreamProofCarryover(this.store, context.identity.repositoryRoot, task, stepId)
             : null;
+        const planIntegrityDirtyCarryover = step.status === 'planned' && dirty.length > 0
+            ? this.assessPostRebindCheckSupportDirtyCarryover(context.identity.repositoryRoot, task, stepId)
+            : null;
         if (step.status === 'planned'
             && dirty.length > 0
             && !resumesCorrectiveReplan
-            && !downstreamProofCarryover?.eligible) {
+            && !downstreamProofCarryover?.eligible
+            && !planIntegrityDirtyCarryover?.eligible) {
             throw new WorkflowError('GIT_PRECONDITION_FAILED', `${stepId} must start from a clean checkout.`, {
                 changedFiles: dirty,
                 ...(downstreamProofCarryover?.applicable
                     ? { downstreamProofCarryoverBlockers: downstreamProofCarryover.blockers }
                     : {}),
+                ...(planIntegrityDirtyCarryover?.applicable
+                    ? { planIntegrityDirtyCarryoverBlockers: planIntegrityDirtyCarryover.blockers }
+                    : {}),
             });
         }
         const dirtyOutsideStep = dirty.filter((file) => !pathAllowed(file, allowedWrites));
@@ -3643,6 +3650,17 @@ export class WorkflowService {
         const adoptedCompatibility = assessment
             ? null
             : this.postRebindCheckSupportCompatibility(snapshot, task);
+        const dirtyCarryoverAssessment = assessment || adoptedCompatibility
+            ? null
+            : this.assessPostRebindCheckSupportDirtyCarryover(snapshot.identity.repositoryRoot, task);
+        const dirtyCarryoverCompatibility = dirtyCarryoverAssessment?.eligible
+            && dirtyCarryoverAssessment.compatibility
+            ? {
+                ...dirtyCarryoverAssessment.compatibility,
+                planHash: task.planHash,
+                mode: 'post-rebind-dirty-carryover',
+            }
+            : null;
         const versions = inspectWorkflowVersions(snapshot.identity.repositoryRoot, [task.baseBranch]);
         const versionSurfaces = {
             declared: versions.declared,
@@ -3658,9 +3676,11 @@ export class WorkflowService {
         const targetPatchOrdinal = targetPatch === null ? null : Number(targetPatch);
         const blockers = [
             ...(assessments.length > 1 ? ['Exactly one failed Step may expose a Plan-integrity conflict.'] : []),
-            ...(assessment?.blockers ?? (adoptedCompatibility
+            ...(assessment?.blockers ?? (adoptedCompatibility || dirtyCarryoverCompatibility
                 ? []
-                : ['No eligible Plan-integrity conflict or post-rebind check-support adoption was found.'])),
+                : (dirtyCarryoverAssessment?.blockers.length
+                    ? dirtyCarryoverAssessment.blockers
+                    : ['No eligible Plan-integrity conflict, post-rebind scope adoption, or dirty carryover was found.']))),
             ...(sourcePatchOrdinal === null
                 || targetPatchOrdinal === null
                 || sourcePatchOrdinal < 11
@@ -3675,21 +3695,29 @@ export class WorkflowService {
         ];
         return {
             readOnly: true,
-            eligible: Boolean(assessment?.eligible || adoptedCompatibility) && blockers.length === 0,
-            action: (assessment?.eligible || adoptedCompatibility) && blockers.length === 0
+            eligible: Boolean(assessment?.eligible || adoptedCompatibility || dirtyCarryoverCompatibility) && blockers.length === 0,
+            action: (assessment?.eligible || adoptedCompatibility || dirtyCarryoverCompatibility) && blockers.length === 0
                 ? 'update plan-integrity-transport'
                 : null,
             projectId: task.projectId,
             taskId: task.id,
             taskRevision: task.revision,
-            stepId: assessment?.stepId ?? adoptedCompatibility?.stepId ?? null,
+            stepId: assessment?.stepId ?? adoptedCompatibility?.stepId ?? dirtyCarryoverCompatibility?.stepId ?? null,
             sourceVersion,
             targetVersion: PACKAGE_VERSION,
             taskBranch: task.taskBranch,
             baseBranch: task.baseBranch,
-            dirtyFiles: assessment?.evidence?.changedFiles ?? adoptedCompatibility?.dirtyFiles ?? [],
-            conflictHash: assessment?.evidence?.conflictHash ?? adoptedCompatibility?.conflictHash ?? null,
-            compatibilityMode: adoptedCompatibility?.mode ?? 'failed-step-conflict',
+            dirtyFiles: assessment?.evidence?.changedFiles
+                ?? adoptedCompatibility?.dirtyFiles
+                ?? dirtyCarryoverCompatibility?.dirtyFiles
+                ?? [],
+            conflictHash: assessment?.evidence?.conflictHash
+                ?? adoptedCompatibility?.conflictHash
+                ?? dirtyCarryoverCompatibility?.conflictHash
+                ?? null,
+            compatibilityMode: adoptedCompatibility?.mode
+                ?? dirtyCarryoverCompatibility?.mode
+                ?? 'failed-step-conflict',
             requiredTransport: [
                 'Commit only package.json and package-lock.json on the active Milestone base.',
                 'Fast-forward or apply only that dependency commit to the Task branch while preserving all product bytes.',
@@ -3728,10 +3756,16 @@ export class WorkflowService {
         const adoptedCompatibility = assessment?.evidence
             ? null
             : this.postRebindCheckSupportCompatibility(snapshot, task);
+        const dirtyCarryoverCompatibility = assessment?.evidence || adoptedCompatibility
+            ? null
+            : this.carriedPostRebindCheckSupportDirtyCarryover(snapshot, task);
         const carriedCompatibility = !assessment?.evidence && task.planHash
             ? this.carriedPlanIntegrityUpdateCompatibility(snapshot, task)
             : null;
-        if ((!assessment?.evidence && !carriedCompatibility && !adoptedCompatibility) || !task.planHash) {
+        if ((!assessment?.evidence
+            && !carriedCompatibility
+            && !adoptedCompatibility
+            && !dirtyCarryoverCompatibility) || !task.planHash) {
             const ordinary = this.inspectDependencyProvenanceCandidate(snapshot, task);
             return {
                 ...ordinary,
@@ -3745,16 +3779,19 @@ export class WorkflowService {
                     ])],
             };
         }
-        const compatibility = carriedCompatibility ?? adoptedCompatibility ?? {
-            stepId: assessment.stepId,
-            planHash: task.planHash,
-            conflictHash: assessment.evidence.conflictHash,
-            dirtyFiles: [...assessment.evidence.changedFiles],
-            dirtyWorktreeHash: hashDirtyWorktree(snapshot.identity.repositoryRoot, assessment.evidence.changedFiles),
-            remediationEventIds: assessment.evidence.kind === 'missing-npm-script-outside-allowed-writes'
-                ? [assessment.evidence.remediationEventId]
-                : assessment.evidence.remediationEvents.map((event) => event.eventId),
-        };
+        const compatibility = carriedCompatibility
+            ?? adoptedCompatibility
+            ?? dirtyCarryoverCompatibility
+            ?? {
+                stepId: assessment.stepId,
+                planHash: task.planHash,
+                conflictHash: assessment.evidence.conflictHash,
+                dirtyFiles: [...assessment.evidence.changedFiles],
+                dirtyWorktreeHash: hashDirtyWorktree(snapshot.identity.repositoryRoot, assessment.evidence.changedFiles),
+                remediationEventIds: assessment.evidence.kind === 'missing-npm-script-outside-allowed-writes'
+                    ? [assessment.evidence.remediationEventId]
+                    : assessment.evidence.remediationEvents.map((event) => event.eventId),
+            };
         return this.inspectDependencyProvenanceCandidate(snapshot, task, null, null, null, compatibility);
     }
     downstreamProofReplanDependencyRecoveryPreflight(repository, taskId) {
@@ -5185,6 +5222,11 @@ export class WorkflowService {
             && changedFiles(repositoryRoot).length > 0
             ? assessDownstreamProofCarryover(this.store, repositoryRoot, task, nextStepId)
             : null;
+        const planIntegrityDirtyCarryover = next.action === 'task run'
+            && nextStepId
+            && changedFiles(repositoryRoot).length > 0
+            ? this.assessPostRebindCheckSupportDirtyCarryover(repositoryRoot, task, nextStepId)
+            : null;
         let mechanicalFeasibilityOverlay = {};
         if (task.status === 'awaiting_execution_authorization' && task.planHash) {
             try {
@@ -5736,6 +5778,29 @@ export class WorkflowService {
                         },
                     }
                 : {}),
+            ...(planIntegrityDirtyCarryover?.applicable
+                ? planIntegrityDirtyCarryover.eligible
+                    ? {
+                        planIntegrityDirtyCarryover: {
+                            state: 'validated',
+                            stepId: nextStepId,
+                            dependencyRecoveryCommit: planIntegrityDirtyCarryover.dependencyRecoveryCommit,
+                            dirtyFiles: planIntegrityDirtyCarryover.compatibility?.dirtyFiles ?? [],
+                            dirtyWorktreeHash: planIntegrityDirtyCarryover.compatibility?.dirtyWorktreeHash ?? null,
+                            scopeExtensions: planIntegrityDirtyCarryover.compatibility?.scopeExtensions ?? [],
+                            meaning: 'The current Step may adopt exactly these hash-bound check-support bytes on task run.',
+                        },
+                    }
+                    : {
+                        action: 'doctor',
+                        blockedAction: 'task run',
+                        planIntegrityDirtyCarryover: {
+                            state: 'blocked',
+                            stepId: nextStepId,
+                            blockers: planIntegrityDirtyCarryover.blockers,
+                        },
+                    }
+                : {}),
             ...(delegatedApprovalOptions.length > 0 ? { delegatedApprovalOptions } : {}),
             ...(correctiveDerivedAuthority && correctiveDerivedActor
                 ? {
@@ -6133,6 +6198,144 @@ export class WorkflowService {
         });
         return candidates.length === 1 ? candidates[0] : null;
     }
+    carriedPostRebindCheckSupportDirtyCarryover(snapshot, task) {
+        let boundaryCommit = headCommit(snapshot.identity.repositoryRoot);
+        let dependencyCommitCount = 0;
+        while (!task.systemCommits.includes(boundaryCommit)) {
+            const dependencyCommit = inspectBoundedWorkflowDependencyCommit(snapshot.identity.repositoryRoot, boundaryCommit);
+            if (!dependencyCommit)
+                return null;
+            boundaryCommit = dependencyCommit.parentCommitSha;
+            dependencyCommitCount += 1;
+        }
+        if (dependencyCommitCount === 0)
+            return null;
+        const assessment = this.assessPostRebindCheckSupportDirtyCarryover(snapshot.identity.repositoryRoot, task, undefined, boundaryCommit);
+        if (!assessment.eligible || !assessment.compatibility || !task.planHash)
+            return null;
+        return {
+            ...assessment.compatibility,
+            planHash: task.planHash,
+            mode: 'post-rebind-dirty-carryover',
+        };
+    }
+    assessPostRebindCheckSupportDirtyCarryover(repositoryRoot, task, stepId, historyBoundary = headCommit(repositoryRoot)) {
+        const relevantRecords = [...(task.dependencyProvenanceRecoveries ?? [])]
+            .reverse()
+            .filter((record) => {
+            const compatibility = record.planIntegrity;
+            return compatibility
+                && ['post-rebind-scope-adoption', 'post-rebind-dirty-carryover'].includes(compatibility.mode ?? '')
+                && (!stepId || compatibility.stepId === stepId);
+        });
+        if (relevantRecords.length === 0) {
+            return {
+                applicable: false,
+                eligible: false,
+                compatibility: null,
+                dependencyRecoveryCommit: null,
+                blockers: [],
+            };
+        }
+        const blockers = [];
+        const record = relevantRecords[0];
+        const compatibility = record.planIntegrity;
+        const step = task.steps.find((candidate) => candidate.id === compatibility.stepId) ?? null;
+        const dirtyFiles = changedFiles(repositoryRoot).sort();
+        let dirtyWorktreeHash = null;
+        try {
+            dirtyWorktreeHash = hashDirtyWorktree(repositoryRoot, dirtyFiles);
+        }
+        catch (error) {
+            blockers.push(error instanceof Error ? error.message : String(error));
+        }
+        if (record.commitSha !== historyBoundary || !task.systemCommits.includes(record.commitSha)) {
+            blockers.push('The latest check-support compatibility record must bind the exact registered history boundary.');
+        }
+        if (task.workspaceOwner !== 'local') {
+            blockers.push('Check-support dirty carryover requires the recorded local Task workspace.');
+        }
+        if (!task.taskBranch || currentBranch(repositoryRoot) !== task.taskBranch) {
+            blockers.push('Current branch must equal the recorded Task branch.');
+        }
+        if (!['ready', 'in_progress'].includes(task.status)) {
+            blockers.push('The Task must retain an execution-authorized posture before dirty carryover.');
+        }
+        if (!task.planHash) {
+            blockers.push('The Task must retain a current Plan hash.');
+        }
+        if (!step || step.status !== 'planned' || step.evidence !== null) {
+            blockers.push(`The bound Step ${compatibility.stepId} must remain planned with no evidence.`);
+        }
+        if (task.steps.some((candidate) => candidate.status === 'in_progress')) {
+            blockers.push('No Step may already be in progress before dirty carryover.');
+        }
+        if (canonicalJsonStringify(dirtyFiles)
+            !== canonicalJsonStringify([...compatibility.dirtyFiles].sort())) {
+            blockers.push('Dirty files changed after the registered check-support compatibility boundary.');
+        }
+        if (dirtyWorktreeHash !== compatibility.dirtyWorktreeHash) {
+            blockers.push('Dirty file content changed after the registered check-support compatibility boundary.');
+        }
+        if (!compatibility.scopeExtensions?.length) {
+            blockers.push('The compatibility record must retain at least one machine-derived scope extension.');
+        }
+        if (step) {
+            if (dirtyFiles.some((dirtyPath) => !pathAllowed(dirtyPath, step.allowedWrites))) {
+                blockers.push('The current Step must explicitly own every preserved dirty file.');
+            }
+            if ((compatibility.scopeExtensions ?? []).some((scopePath) => !pathAllowed(scopePath, step.allowedWrites)
+                || !step.expectedOutputs.some((declared) => (declared.startsWith('path:') ? declared.slice(5) : declared) === scopePath))) {
+                blockers.push('The current Step must explicitly own every check-support scope extension as allowedWrites and expectedOutputs.');
+            }
+        }
+        let reboundPlanHash = compatibility.planHash;
+        for (const rebind of task.knowledgeRebinds) {
+            if (rebind.previousPlanHash === reboundPlanHash)
+                reboundPlanHash = rebind.reboundPlanHash;
+        }
+        if (!task.planHash || reboundPlanHash !== task.planHash) {
+            blockers.push('The current Plan must equal the compatibility Plan or its exact Knowledge-rebind descendant.');
+        }
+        const matchingDecisions = readCorrectiveDecisionEvents(this.store, task).filter((event) => {
+            const evidence = event.planIntegrityEvidence;
+            return event.stepId === compatibility.stepId
+                && event.decision === 'continue-fix'
+                && event.recoveryBasis === 'plan-integrity'
+                && evidence?.kind === 'check-support-anchor-outside-allowed-writes'
+                && evidence.conflictHash === compatibility.conflictHash
+                && canonicalJsonStringify([...evidence.changedFiles].sort())
+                    === canonicalJsonStringify([...compatibility.dirtyFiles].sort())
+                && canonicalJsonStringify(evidence.remediationEvents.map((binding) => binding.eventId))
+                    === canonicalJsonStringify(compatibility.remediationEventIds)
+                && canonicalJsonStringify([...evidence.scopeExtensions].sort())
+                    === canonicalJsonStringify([...(compatibility.scopeExtensions ?? [])].sort());
+        });
+        if (matchingDecisions.length !== 1) {
+            blockers.push('Exactly one validated historical check-support decision must bind the preserved dirty set and scope.');
+        }
+        try {
+            validateTaskHistory(repositoryRoot, task, historyBoundary);
+        }
+        catch (error) {
+            blockers.push(error instanceof Error ? error.message : String(error));
+        }
+        return {
+            applicable: true,
+            eligible: blockers.length === 0,
+            compatibility: blockers.length === 0
+                ? {
+                    ...structuredClone(compatibility),
+                    planHash: task.planHash,
+                    dirtyFiles,
+                    dirtyWorktreeHash: dirtyWorktreeHash,
+                    mode: 'post-rebind-dirty-carryover',
+                }
+                : null,
+            dependencyRecoveryCommit: record.commitSha,
+            blockers,
+        };
+    }
     inspectDependencyProvenanceCandidate(snapshot, task, activeDownstreamProof = null, downstreamProofReplan = null, historicalStepProvenance = null, planIntegrity = null) {
         const versions = inspectWorkflowVersions(snapshot.identity.repositoryRoot, [task.baseBranch]);
         const now = this.now().getTime();