codex-workflow-v2 2.0.0-beta.12.11 → 2.0.0-beta.12.12

package/dist/src/workflow.d.ts

@@ -250,11 +250,14 @@ export declare class WorkflowService {
     recoverHistoricalStepProvenance(repository: string, taskId: string, expectedRevision: number, commitSha: string, actor: string, reason: string): TaskState;
     activeDownstreamProofDependencyRecoveryPreflight(repository: string, taskId: string): DependencyProvenanceRecoveryPreflight;
     downstreamProofReplanUpdatePreflight(repository: string, taskId: string): Record<string, unknown>;
+    planIntegrityUpdatePreflight(repository: string, taskId: string): Record<string, unknown>;
+    planIntegrityDependencyRecoveryPreflight(repository: string, taskId: string): DependencyProvenanceRecoveryPreflight;
     downstreamProofReplanDependencyRecoveryPreflight(repository: string, taskId: string): DependencyProvenanceRecoveryPreflight;
     recoverDependencyProvenance(repository: string, taskId: string, expectedRevision: number, actor: string, reason: string): TaskState;
     recoverActiveDownstreamProofDependencyProvenance(repository: string, taskId: string, expectedRevision: number, actor: string, reason: string): TaskState;
     recoverDownstreamProofReplanDependencyProvenance(repository: string, taskId: string, expectedRevision: number, actor: string, reason: string): TaskState;
     recoverHistoricalStepDependencyProvenance(repository: string, taskId: string, expectedRevision: number, actor: string, reason: string): TaskState;
+    recoverPlanIntegrityDependencyProvenance(repository: string, taskId: string, expectedRevision: number, actor: string, reason: string): TaskState;
     private recoverDependencyProvenanceCandidate;
     milestoneProgress(repository: string, milestoneId: string): MilestoneProgressProjection;
     alpha6StrictReviewRescuePreflight(repository: string): Alpha6StrictReviewRescuePreflight;

package/dist/src/workflow.js

@@ -3013,8 +3013,6 @@ export class WorkflowService {
         const task = this.store.readTask(context.identity.projectId, taskId);
         assertExpectedRevision(task, expectedRevision);
         this.requireExecutionAdoptionPosture(context.identity, taskId);
-        this.assertExecutionAuthorizationFresh(task, context.identity.repositoryRoot);
-        this.assertTaskKnowledgeBinding(context.identity.repositoryRoot, task);
         assertTaskBranch(context.identity.repositoryRoot, task);
         this.proveOptionalWriterLeaseToken(context, taskId, writerToken);
         this.assertTaskMutationAllowedByHandoff(task, actor, writerToken);
@@ -3046,6 +3044,20 @@ export class WorkflowService {
                 blockers: assessment.blockers,
             });
         }
+        const remediationEventIds = assessment.evidence.kind === 'missing-npm-script-outside-allowed-writes'
+            ? [assessment.evidence.remediationEventId]
+            : assessment.evidence.remediationEvents.map((event) => event.eventId);
+        const compatibility = [...(task.dependencyProvenanceRecoveries ?? [])].reverse().find((record) => record.commitSha === headCommit(context.identity.repositoryRoot)
+            && record.packageVersion === PACKAGE_VERSION
+            && task.systemCommits.includes(record.commitSha)
+            && record.planIntegrity?.stepId === stepId
+            && record.planIntegrity.planHash === task.planHash
+            && canonicalJsonStringify(record.planIntegrity.remediationEventIds) === canonicalJsonStringify(remediationEventIds)
+            && record.planIntegrity.dirtyWorktreeHash === hashDirtyWorktree(context.identity.repositoryRoot, record.planIntegrity.dirtyFiles));
+        if (!compatibility) {
+            this.assertExecutionAuthorizationFresh(task, context.identity.repositoryRoot);
+            this.assertTaskKnowledgeBinding(context.identity.repositoryRoot, task);
+        }
         const event = appendPlanIntegrityRecoveryDecision(this.store, task, stepId, defaultPlanIntegrityRecoveryActor(task.id), assessment.evidence, this.now());
         return { assessment, event };
     }
@@ -3610,6 +3622,115 @@ export class WorkflowService {
             blockers,
         };
     }
+    planIntegrityUpdatePreflight(repository, taskId) {
+        const snapshot = this.observationSnapshot(repository);
+        if (snapshot.observation.kind !== 'assessment') {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Plan-integrity update preflight requires a coherent observation boundary.', {
+                observation: snapshot.observation,
+            });
+        }
+        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 assessments = task.steps
+            .filter((step) => step.status === 'failed')
+            .map((step) => assessPlanIntegrityRecovery(this.store, snapshot.identity.repositoryRoot, task, step.id))
+            .filter((assessment) => assessment.applicable);
+        const assessment = assessments.length === 1 ? assessments[0] : null;
+        const versions = inspectWorkflowVersions(snapshot.identity.repositoryRoot, [task.baseBranch]);
+        const sourceVersion = '2.0.0-beta.12.11';
+        const versionSurfaces = {
+            declared: versions.declared,
+            locked: versions.locked,
+            installed: versions.installed,
+            currentBranch: versions.currentBranch,
+            baseBranch: versions.milestoneBases.find((base) => base.branch === task.baseBranch)?.version ?? null,
+        };
+        const blockers = [
+            ...(assessments.length > 1 ? ['Exactly one failed Step may expose a Plan-integrity conflict.'] : []),
+            ...(assessment?.blockers ?? ['No eligible Plan-integrity conflict was found.']),
+            ...(String(PACKAGE_VERSION) === sourceVersion ? ['Recovery runner must be newer than the beta.12.11 source package.'] : []),
+            ...Object.entries(versionSurfaces)
+                .filter(([, version]) => version !== sourceVersion)
+                .map(([surface]) => `${surface} Workflow version must equal the stranded source ${sourceVersion}.`),
+            ...(snapshot.leases.length > 0 ? ['No active or stale Task writer lease may exist.'] : []),
+            ...observationPreflightBlockers(snapshot.observation),
+        ];
+        return {
+            readOnly: true,
+            eligible: Boolean(assessment?.eligible) && blockers.length === 0,
+            action: assessment?.eligible && blockers.length === 0 ? 'update plan-integrity-transport' : null,
+            projectId: task.projectId,
+            taskId: task.id,
+            taskRevision: task.revision,
+            stepId: assessment?.stepId ?? null,
+            sourceVersion,
+            targetVersion: PACKAGE_VERSION,
+            taskBranch: task.taskBranch,
+            baseBranch: task.baseBranch,
+            dirtyFiles: assessment?.evidence?.changedFiles ?? [],
+            conflictHash: assessment?.evidence?.conflictHash ?? null,
+            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.',
+                'Install the exact target package, then follow fresh next to Plan-integrity dependency registration.',
+            ],
+            blockers,
+        };
+    }
+    planIntegrityDependencyRecoveryPreflight(repository, taskId) {
+        const snapshot = this.observationSnapshot(repository);
+        if (snapshot.observation.kind !== 'assessment') {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Plan-integrity dependency recovery requires a coherent observation boundary.', {
+                observation: snapshot.observation,
+            });
+        }
+        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 assessmentBlockers = [];
+        const assessments = task.steps
+            .filter((step) => step.status === 'failed')
+            .flatMap((step) => {
+            try {
+                return [assessPlanIntegrityRecovery(this.store, snapshot.identity.repositoryRoot, task, step.id)];
+            }
+            catch (error) {
+                if (error instanceof WorkflowError && error.code === 'STATE_CORRUPT') {
+                    assessmentBlockers.push(`Plan-integrity compatibility cannot be assessed until the existing remediation history is repaired: ${error.message}`);
+                    return [];
+                }
+                throw error;
+            }
+        })
+            .filter((assessment) => assessment.applicable && assessment.eligible && assessment.evidence);
+        const assessment = assessments.length === 1 ? assessments[0] : null;
+        if (!assessment?.evidence || !task.planHash) {
+            const ordinary = this.inspectDependencyProvenanceCandidate(snapshot, task);
+            return {
+                ...ordinary,
+                eligible: false,
+                action: null,
+                planIntegrity: null,
+                blockers: [...new Set([
+                        ...ordinary.blockers,
+                        ...assessmentBlockers,
+                        'The dependency candidate must preserve one exact eligible Plan-integrity conflict.',
+                    ])],
+            };
+        }
+        const compatibility = {
+            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) {
         const snapshot = this.observationSnapshot(repository);
         if (snapshot.observation.kind !== 'assessment') {
@@ -3664,6 +3785,9 @@ export class WorkflowService {
     recoverHistoricalStepDependencyProvenance(repository, taskId, expectedRevision, actor, reason) {
         return this.recoverDependencyProvenanceCandidate(repository, taskId, expectedRevision, actor, reason, 'historical-step');
     }
+    recoverPlanIntegrityDependencyProvenance(repository, taskId, expectedRevision, actor, reason) {
+        return this.recoverDependencyProvenanceCandidate(repository, taskId, expectedRevision, actor, reason, 'plan-integrity');
+    }
     recoverDependencyProvenanceCandidate(repository, taskId, expectedRevision, actor, reason, recoveryMode) {
         const normalizedActor = actor.trim();
         const normalizedReason = reason.trim();
@@ -3680,7 +3804,9 @@ export class WorkflowService {
                 ? Boolean(record.downstreamProofReplan)
                 : recoveryMode === 'historical-step'
                     ? Boolean(record.historicalStepProvenance)
-                    : Boolean(record.activeDownstreamProof) === recoveryMode));
+                    : recoveryMode === 'plan-integrity'
+                        ? Boolean(record.planIntegrity)
+                        : Boolean(record.activeDownstreamProof) === recoveryMode));
         if (prior && current.systemCommits.includes(currentHead))
             return current;
         assertExpectedRevision(current, expectedRevision);
@@ -3692,17 +3818,22 @@ export class WorkflowService {
             ? this.downstreamProofReplanDependencyRecoveryPreflight(repository, taskId)
             : recoveryMode === 'historical-step'
                 ? this.historicalStepDependencyRecoveryPreflight(repository, taskId)
-                : recoveryMode
-                    ? this.activeDownstreamProofDependencyRecoveryPreflight(repository, taskId)
-                    : this.inspectDependencyProvenanceCandidate(snapshot, task);
+                : recoveryMode === 'plan-integrity'
+                    ? this.planIntegrityDependencyRecoveryPreflight(repository, taskId)
+                    : recoveryMode
+                        ? this.activeDownstreamProofDependencyRecoveryPreflight(repository, taskId)
+                        : this.inspectDependencyProvenanceCandidate(snapshot, task);
         if (!preflight.eligible || !preflight.commitSha || !preflight.parentCommitSha) {
             throw new WorkflowError('GIT_PRECONDITION_FAILED', 'The bounded dependency provenance recovery preflight failed.', {
                 taskId,
                 blockers: preflight.blockers,
             });
         }
-        return context.store.writeTask({
+        const now = this.now();
+        const nextTask = {
             ...task,
+            revision: task.revision + 1,
+            updatedAt: now.toISOString(),
             systemCommits: [...task.systemCommits, preflight.commitSha],
             dependencyProvenanceRecoveries: [
                 ...(task.dependencyProvenanceRecoveries ?? []),
@@ -3714,7 +3845,7 @@ export class WorkflowService {
                     files: ['package-lock.json', 'package.json'],
                     actor: normalizedActor,
                     reason: normalizedReason,
-                    recordedAt: this.now().toISOString(),
+                    recordedAt: now.toISOString(),
                     retainedHistoricalCommits: preflight.retainedHistoricalCommits,
                     ...(preflight.activeDownstreamProof
                         ? { activeDownstreamProof: preflight.activeDownstreamProof }
@@ -3725,9 +3856,68 @@ export class WorkflowService {
                     ...(preflight.historicalStepProvenance
                         ? { historicalStepProvenance: preflight.historicalStepProvenance }
                         : {}),
+                    ...(preflight.planIntegrity
+                        ? { planIntegrity: preflight.planIntegrity }
+                        : {}),
                 },
             ],
-        }, expectedRevision);
+        };
+        if (recoveryMode !== 'plan-integrity' || !preflight.planIntegrity) {
+            return context.store.writeTask({ ...nextTask, revision: task.revision }, expectedRevision);
+        }
+        const currentKnowledgeMap = this.store.readKnowledgeMap(task.projectId);
+        const scannedKnowledgeMap = scanProjectKnowledge(context.identity.repositoryRoot, task.projectId, now);
+        const inspectedKnowledgeMap = inspectKnowledgeMap(currentKnowledgeMap, scannedKnowledgeMap);
+        let refreshedKnowledgeMap = null;
+        if (inspectedKnowledgeMap.status !== 'active' || !inspectedKnowledgeMap.approval) {
+            const knowledgeRefresh = inspectDependencyKnowledgeRefresh(context.identity.repositoryRoot, task.baseBranch, currentKnowledgeMap, inspectedKnowledgeMap, preflight.planIntegrity.dirtyFiles);
+            if (!knowledgeRefresh.eligible) {
+                throw new WorkflowError('TRANSITION_BLOCKED', 'Plan-integrity dependency recovery cannot bypass unrelated Project Knowledge drift.', {
+                    taskId,
+                    dependencyKnowledgeRefresh: knowledgeRefresh,
+                });
+            }
+            const reconciled = reconcileKnowledgeMap(currentKnowledgeMap, scannedKnowledgeMap);
+            const approved = applyKnowledgeSelections(reconciled, [], normalizedActor, now);
+            if (!approved.approval) {
+                throw new WorkflowError('STATE_CORRUPT', 'Plan-integrity dependency Knowledge refresh produced no approval evidence.');
+            }
+            refreshedKnowledgeMap = {
+                ...approved,
+                revision: currentKnowledgeMap.revision + 2,
+                createdAt: currentKnowledgeMap.createdAt,
+                updatedAt: now.toISOString(),
+                approval: { ...approved.approval, authorizationMode: 'corrective-derived' },
+            };
+        }
+        const projectRoot = this.store.projectRoot(task.projectId);
+        const relative = (absolute) => path.relative(projectRoot, absolute).split(path.sep).join('/');
+        applyProjectTransaction({
+            projectRoot,
+            projectId: task.projectId,
+            transactionId: `tx-${createEntityId('TASK', now.getTime()).toLowerCase()}`,
+            kind: 'plan-integrity-dependency-recovery',
+            now,
+            targets: [
+                ...(refreshedKnowledgeMap
+                    ? [{ path: relative(path.join(projectRoot, 'knowledge-map.json')), content: `${JSON.stringify(refreshedKnowledgeMap, null, 2)}\n` }]
+                    : []),
+                {
+                    path: relative(path.join(this.store.taskRoot(task.projectId, task.id), 'state.json')),
+                    content: `${JSON.stringify(nextTask, null, 2)}\n`,
+                },
+            ],
+            validate: () => {
+                const saved = this.store.readTask(task.projectId, task.id);
+                if (saved.revision !== nextTask.revision || saved.systemCommits.at(-1) !== preflight.commitSha) {
+                    throw new WorkflowError('STATE_CORRUPT', 'Plan-integrity dependency recovery Task readback failed.', { taskId });
+                }
+                if (refreshedKnowledgeMap && this.store.readKnowledgeMap(task.projectId).revision !== refreshedKnowledgeMap.revision) {
+                    throw new WorkflowError('STATE_CORRUPT', 'Plan-integrity dependency Knowledge refresh readback failed.', { taskId });
+                }
+            },
+        });
+        return this.store.readTask(task.projectId, task.id);
     }
     milestoneProgress(repository, milestoneId) {
         const snapshot = this.observationSnapshot(repository);
@@ -4171,6 +4361,22 @@ export class WorkflowService {
                     },
                 });
             }
+            const planIntegrityDependencyRecovery = this.planIntegrityDependencyRecoveryPreflight(repositoryRoot, activeTask.id);
+            if (planIntegrityDependencyRecovery.eligible) {
+                return withAdoption({
+                    scope: 'task',
+                    id: activeTask.id,
+                    status: activeTask.status,
+                    action: 'update plan-integrity-dependency-recover',
+                    revision: activeTask.revision,
+                    dependencyProvenanceRecovery: planIntegrityDependencyRecovery,
+                    compatibilityBoundary: {
+                        preservesWorktree: true,
+                        prerequisite: 'A newer package preflight approved the exact failed Step, remediation history, and dirty allowlist before dependency-only transport.',
+                        continuation: 'Register this dependency commit, then follow fresh next to Plan-integrity recovery and corrective replan.',
+                    },
+                });
+            }
             const dependencyRecovery = this.dependencyProvenanceRecoveryPreflight(repositoryRoot, activeTask.id);
             if (dependencyRecovery.eligible) {
                 return withAdoption({
@@ -4473,6 +4679,8 @@ export class WorkflowService {
                 || taskNext?.action === 'task remediation-mode-recover'
                 || taskNext?.action === 'task plan-integrity-recover'
                 || taskNext?.blockedAction === 'task plan-integrity-recover'
+                || taskNext?.action === 'task corrective-yield'
+                || String(taskNext?.action ?? '').startsWith('task corrective-replan')
                 || hardStop
                 || terminalCorrectiveDecision === 'split-required'
                 || terminalCorrectiveDecision === 'stop-escalate') {
@@ -5124,7 +5332,9 @@ export class WorkflowService {
                     stepId: planIntegrityAssessment.stepId,
                     planIntegrityRecovery: {
                         state: 'eligible',
-                        reasonCode: 'MISSING_NPM_SCRIPT_OUTSIDE_ALLOWED_WRITES',
+                        reasonCode: planIntegrityAssessment.evidence?.kind === 'missing-npm-script-outside-allowed-writes'
+                            ? 'MISSING_NPM_SCRIPT_OUTSIDE_ALLOWED_WRITES'
+                            : 'NON_EXECUTABLE_NPM_CHECK_OUTSIDE_ALLOWED_WRITES',
                         expectedRevision: task.revision,
                         requiredActor,
                         evidence: planIntegrityAssessment.evidence,
@@ -5813,7 +6023,7 @@ export class WorkflowService {
             },
         };
     }
-    inspectDependencyProvenanceCandidate(snapshot, task, activeDownstreamProof = null, downstreamProofReplan = null, historicalStepProvenance = null) {
+    inspectDependencyProvenanceCandidate(snapshot, task, activeDownstreamProof = null, downstreamProofReplan = null, historicalStepProvenance = null, planIntegrity = null) {
         const versions = inspectWorkflowVersions(snapshot.identity.repositoryRoot, [task.baseBranch]);
         const now = this.now().getTime();
         return inspectDependencyProvenanceRecovery(snapshot.identity.repositoryRoot, task, {
@@ -5833,7 +6043,7 @@ export class WorkflowService {
                 currentBranch: versions.currentBranch,
                 baseBranch: versions.milestoneBases.find((base) => base.branch === task.baseBranch)?.version ?? null,
             },
-        }, activeDownstreamProof, downstreamProofReplan, historicalStepProvenance);
+        }, activeDownstreamProof, downstreamProofReplan, historicalStepProvenance, planIntegrity);
     }
     inspectHistoricalStepProvenanceCandidate(snapshot, task, options = {}) {
         const now = this.now().getTime();