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

package/dist/src/workflow.js

@@ -8,6 +8,7 @@ import { inspectHistoricalStepProvenanceRecovery, omittedStepEvidenceCommits, }
 import { renderBrief, renderPlan, renderResult } from './artifacts.js';
 import { assertDelegationCanAuthorize, hashDelegationPolicy, prepareDelegationGrantGate, } from './delegation.js';
 import { assessDiscovery, mergeUnique } from './domain/discovery.js';
+import { normalizePlanKnowledgeBinding, readVerifiedPlanArtifact } from './domain/plan-semantics.js';
 import { deriveCompletedStepCarryover, normalizePlanStepDefinition, } from './domain/completed-step-carryover.js';
 import { pathAllowed, validatePlan } from './domain/validation.js';
 import { WorkflowError } from './errors.js';
@@ -17,8 +18,9 @@ import { inspectLocalDependency, inspectWorkflowVersions } from './diagnostics.j
 import { appendTaskClaim, appendTaskHandback, appendTaskHandoff, appendTaskWriterCredentialReplacement, assertTaskClaimAllowed, assertTaskMutationAllowedByC1, defaultTaskWorkerActor, prepareTaskCorrectiveYield, readTaskC1Posture, } from './alpha6/handoff.js';
 import { assessDownstreamProofCarryover, assessDownstreamProofReplanRecovery, assessDownstreamProofRecovery, downstreamProofInvalidationSidecar, downstreamProofReplanRecoverySidecar, prepareDownstreamProofInvalidation, prepareDownstreamProofReplanRecovery, readDownstreamProofInvalidations, readDownstreamProofReplanRecoveries, hashDirtyWorktree, } from './alpha6/downstream-proof.js';
 import { applyAdoptionPosture, assertAdoptionBaselinePreserved, buildAdoptionPreparation, initializeProjectRegistrationAdoption, readCurrentAdoptionPosture, } from './alpha6/adoption.js';
-import { appendCurrentPlanRiskAudit, appendReboundPlanRiskAudit, readCurrentPlanRiskAudit, readPlanRiskAuditEvents, validatePlanRiskAuditCandidate, } from './alpha6/plan-risk.js';
-import { appendCorrectiveDecisionEvent, appendPlanIntegrityRecoveryDecision, appendRemediationModeRecovery, appendStopEscalateOverride, assertCorrectiveAuditorIndependence, assertGuardedRemediationAttemptAllowed, defaultCorrectiveAuditorActor, effectiveStepAllowedWrites, findCurrentGuardedRemediationPosture, findRemediationModeRecoveryCandidate, findFailedGuardedStepRequiringCorrectiveDecision, readGuardedRemediationPostureForStep, readCorrectiveDecisionEvents, readRemediationEvents, deriveRollingCauseDecision, prepareRemediationEvent, prepareStopEscalateOverride, stopEscalateOverrideDecisionEventIds, } from './alpha6/remediation.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 { 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';
 import { assertMechanicalFeasibilityFresh, evaluateMechanicalFeasibility, hashMechanicalFeasibilityEvidence, } from './alpha6/mechanical-feasibility.js';
@@ -28,7 +30,7 @@ import { buildCurrentStrictStepReviewCycle, countUnverifiedStrictStepReviews, en
 import { applyMilestoneAutonomyContract, assertAutonomousPlanEvolution, prepareMilestoneAutonomyContract, readMilestoneAutonomyEvents, requireActiveMilestoneAutonomy, } from './alpha7/autonomy.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 { canonicalJsonStringify, prepareSidecarAppend, sha256Hex } from './alpha6/store-sidecars.js';
 import { ensureDirectory } from './fs-utils.js';
 import { commitStep, mergeTaskBranch, runChecks, startLocalTaskBranch, syncBaseIntoTask, validateTaskHistory, } from './git.js';
 import { changedFiles, currentBranch, gitIsAncestor, headCommit, isClean, resolveRepositoryIdentity, runGit, } from './repository.js';
@@ -47,9 +49,11 @@ const MAX_STRICT_REVIEW_INFRASTRUCTURE_FAILURES = 2;
 export class WorkflowService {
     store;
     now;
-    constructor(store = new FileStateStore(), now = () => new Date()) {
+    transactionHooks;
+    constructor(store = new FileStateStore(), now = () => new Date(), transactionHooks = {}) {
         this.store = store;
         this.now = now;
+        this.transactionHooks = transactionHooks;
     }
     #mutationContext(repository) {
         const identity = resolveRepositoryIdentity(repository);
@@ -1601,6 +1605,10 @@ export class WorkflowService {
         this.validateKnowledgeTargets(knowledgeMap, plan);
         const task = this.store.readTask(identity.projectId, taskId);
         assertExpectedRevision(task, expectedRevision);
+        const preExecutionReplan = readCurrentPreExecutionReplan(this.store, task);
+        const preExecutionReplanAudits = preExecutionReplan
+            ? resolvePreExecutionReplanAudits(this.store, task, preExecutionReplan)
+            : null;
         const correctiveDecisionEvents = task.planHash ? readCorrectiveDecisionEvents(this.store, task) : [];
         const currentPlanCorrectiveDecisions = task.planHash
             ? correctiveDecisionEvents.filter((event) => event.planHash === task.planHash)
@@ -1747,6 +1755,9 @@ export class WorkflowService {
         }
         const root = this.store.taskRoot(identity.projectId, taskId);
         const preparedPlan = prepareCorrectiveReplanCandidate(task, plan);
+        const changesPlanSemantics = !task.planHash
+            || normalizePlanKnowledgeBinding(preparedPlan.planBytes, 'candidate').semanticHash
+                !== normalizePlanKnowledgeBinding(readVerifiedPlanArtifact(root, task.planHash, task.planHash), 'current').semanticHash;
         const authorizations = task.authorizations.map((authorization) => authorization.kind === 'execution' && authorization.decision === 'approved'
             ? { ...authorization, decision: 'superseded' }
             : authorization);
@@ -1764,6 +1775,83 @@ export class WorkflowService {
                 ...(task.invalidatedStepCommits ?? []),
                 ...omittedStepEvidenceCommits(task, plannedSteps),
             ])];
+        if (preExecutionReplan && preExecutionReplanAudits) {
+            const replanC1Posture = readTaskC1Posture(this.store, task);
+            const replanWriterLease = inspectRawWriterLease(this.store.lockRoot(task.projectId), task.id, this.store.root);
+            if (replanC1Posture.state !== 'none' || replanWriterLease) {
+                throw new WorkflowError('TRANSITION_BLOCKED', 'Pre-execution replacement Plan requires no C1 posture or writer lease.', {
+                    taskId: task.id,
+                    c1Posture: replanC1Posture.state,
+                    writerLeasePresent: replanWriterLease !== null,
+                });
+            }
+            if (!planRiskAudit) {
+                throw new WorkflowError('TRANSITION_BLOCKED', 'Pre-execution replan requires an atomic replacement Plan Risk Audit.');
+            }
+            if (task.planObjective !== plan.objective
+                || canonicalJsonStringify(task.requirements) !== canonicalJsonStringify(plan.requirements)
+                || canonicalJsonStringify(task.acceptance) !== canonicalJsonStringify(plan.acceptance)) {
+                throw new WorkflowError('TRANSITION_BLOCKED', 'Pre-execution replan cannot change Task objective, requirements, or acceptance.', {
+                    taskId: task.id,
+                });
+            }
+            if (!changesPlanSemantics) {
+                throw new WorkflowError('TRANSITION_BLOCKED', 'Pre-execution replan requires a semantic Plan change.', { taskId: task.id });
+            }
+            const candidateSteps = new Map(plan.steps.map((step) => [step.id, step]));
+            const missingStepIds = task.steps.filter((step) => !candidateSteps.has(step.id)).map((step) => step.id);
+            if (missingStepIds.length > 0) {
+                throw new WorkflowError('TRANSITION_BLOCKED', 'Pre-execution replan must retain every existing Step identifier.', {
+                    taskId: task.id,
+                    missingStepIds,
+                });
+            }
+            const completedStepIds = task.steps.filter((step) => step.status === 'completed').map((step) => step.id);
+            const lostCompletedStepIds = completedStepIds.filter((stepId) => !retainedCompletedSteps.has(stepId));
+            if (lostCompletedStepIds.length > 0) {
+                throw new WorkflowError('TRANSITION_BLOCKED', 'Pre-execution replan must preserve the exact completed Step subgraph and evidence.', {
+                    taskId: task.id,
+                    lostCompletedStepIds,
+                });
+            }
+            const weakenedForbiddenScope = task.steps.flatMap((step) => {
+                const candidate = candidateSteps.get(step.id);
+                const missing = step.forbiddenScope.filter((scope) => !candidate.forbiddenScope.includes(scope));
+                return missing.length > 0 ? [{ stepId: step.id, missing }] : [];
+            });
+            if (weakenedForbiddenScope.length > 0) {
+                throw new WorkflowError('TRANSITION_BLOCKED', 'Pre-execution replan cannot weaken existing forbiddenScope boundaries.', {
+                    taskId: task.id,
+                    weakenedForbiddenScope,
+                });
+            }
+            const missingRisks = task.risks.filter((risk) => !plan.risks.includes(risk));
+            if (missingRisks.length > 0) {
+                throw new WorkflowError('TRANSITION_BLOCKED', 'Pre-execution replan cannot suppress existing Plan risks.', {
+                    taskId: task.id,
+                    missingRisks,
+                });
+            }
+            assertPlanRiskSafetyPreserved(preExecutionReplanAudits.obstructionAudit, planRiskAudit, 'Replacement Plan Risk Audit');
+            const candidateEdgeKeys = new Set((plan.productionEdges ?? []).map((edge) => canonicalJsonStringify(edge)));
+            const missingProductionEdges = (task.productionEdges ?? [])
+                .filter((edge) => !candidateEdgeKeys.has(canonicalJsonStringify(edge)));
+            if ((task.requiresProductionEdges === true && plan.requiresProductionEdges !== true)
+                || missingProductionEdges.length > 0) {
+                throw new WorkflowError('TRANSITION_BLOCKED', 'Pre-execution replan cannot weaken production-edge authority.', {
+                    taskId: task.id,
+                    missingProductionEdges,
+                });
+            }
+            if (!isClean(identity.repositoryRoot) || headCommit(identity.repositoryRoot) !== preExecutionReplan.sourceHeadCommit) {
+                throw new WorkflowError('GIT_PRECONDITION_FAILED', 'Pre-execution replacement Plan requires the exact clean recorded HEAD.', {
+                    taskId: task.id,
+                    expectedHead: preExecutionReplan.sourceHeadCommit,
+                    actualHead: headCommit(identity.repositoryRoot),
+                    changedFiles: changedFiles(identity.repositoryRoot),
+                });
+            }
+        }
         if (task.status === 'needs_fix' &&
             task.review.status === 'failed' &&
             plannedSteps.every((step) => step.status === 'completed')) {
@@ -1787,7 +1875,7 @@ export class WorkflowService {
                         : []),
                     ...(rawWriterLease ? ['task.rolling-replan.no-writer-lease'] : []),
                     ...(c1Posture.state !== 'none' ? ['task.rolling-replan.no-c1-claim'] : []),
-                    ...(preparedPlan.planHash === task.planHash
+                    ...(!changesPlanSemantics
                         ? ['task.rolling-replan.semantic-plan-change']
                         : []),
                     ...(!preparedPlan.stepIds.includes(correctiveReplanPosture.stepId)
@@ -1860,6 +1948,61 @@ export class WorkflowService {
         };
         if (planRiskAudit)
             validatePlanRiskAuditCandidate(this.store, candidate, planRiskAudit);
+        if (preExecutionReplan && preExecutionReplanAudits && planRiskAudit) {
+            const now = this.now();
+            const resultTask = {
+                ...candidate,
+                revision: task.revision + 1,
+                updatedAt: now.toISOString(),
+            };
+            const preparedAuditBase = buildCandidatePlanRiskAuditEvent(this.store, resultTask, planRiskAudit, now.toISOString(), now.getTime());
+            const preparedAudit = prepareSidecarAppend(readPlanRiskAuditEvents(this.store, task), preparedAuditBase.event);
+            const projectRoot = this.store.projectRoot(task.projectId);
+            const relative = (absolute) => path.relative(projectRoot, absolute).split(path.sep).join('/');
+            const versionFile = path.join(root, '.versions', `plan.md.${preparedPlan.planHash}`);
+            if (existsSync(versionFile) && sha256Hex(readFileSync(versionFile)) !== preparedPlan.planHash) {
+                throw new WorkflowError('STATE_CORRUPT', 'Immutable replacement Plan version is corrupt.', {
+                    taskId: task.id,
+                    planHash: preparedPlan.planHash,
+                });
+            }
+            applyProjectTransaction({
+                projectRoot,
+                projectId: task.projectId,
+                transactionId: `tx-${createEntityId('TASK', now.getTime()).toLowerCase()}`,
+                kind: 'preexecution-replacement-plan-set',
+                now,
+                targets: [
+                    { path: relative(path.join(root, 'state.json')), content: `${JSON.stringify(resultTask, null, 2)}\n` },
+                    { path: relative(path.join(root, 'plan.md')), content: preparedPlan.planBytes },
+                    { path: relative(versionFile), content: preparedPlan.planBytes },
+                    { path: relative(path.join(root, 'plan-risk-audits.jsonl')), content: preparedAudit.content },
+                ],
+                ...(this.transactionHooks.afterPreExecutionReplanTargetWrite
+                    ? { afterTargetWrite: this.transactionHooks.afterPreExecutionReplanTargetWrite }
+                    : {}),
+                validate: () => {
+                    const saved = this.store.readTask(task.projectId, task.id);
+                    const currentAudit = readCurrentPlanRiskAudit(this.store, saved, { requireCurrentTaskRevision: true });
+                    if (saved.revision !== resultTask.revision
+                        || saved.status !== 'awaiting_execution_authorization'
+                        || saved.planHash !== preparedPlan.planHash
+                        || this.store.hashArtifact(root, 'plan.md') !== preparedPlan.planHash
+                        || sha256Hex(readFileSync(versionFile)) !== preparedPlan.planHash
+                        || currentAudit?.audit.eventHash !== preparedAudit.event.eventHash
+                        || hashCompletedSteps(saved) !== preExecutionReplan.completedStepsHash
+                        || readCurrentPreExecutionReplan(this.store, saved) !== null
+                        || saved.authorizations.some((authorization) => authorization.kind === 'execution' && authorization.decision === 'approved')) {
+                        throw new WorkflowError('STATE_CORRUPT', 'Pre-execution replacement Plan transaction readback failed.', {
+                            taskId: task.id,
+                        });
+                    }
+                    if (saved.baseCommit)
+                        validateTaskHistory(identity.repositoryRoot, saved);
+                },
+            });
+            return this.store.readTask(task.projectId, task.id);
+        }
         const stagedPlan = this.store.stageArtifact(root, 'plan.md', preparedPlan.planBytes);
         if (stagedPlan.hash !== preparedPlan.planHash) {
             throw new WorkflowError('STATE_CORRUPT', 'Prepared candidate Plan hash changed during staging.', {
@@ -2068,6 +2211,9 @@ export class WorkflowService {
         this.readCurrentAdoptionPostureStrict(identity.projectId);
         const task = this.store.readTask(identity.projectId, taskId);
         assertExpectedRevision(task, expectedRevision);
+        if (readCurrentPreExecutionReplan(this.store, task)) {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Pre-execution replan requires a semantic replacement Plan before execution authorization.', { taskId, requiredAction: 'task plan-set' });
+        }
         if (task.status !== 'awaiting_execution_authorization' || !task.planHash) {
             throw new WorkflowError('TRANSITION_BLOCKED', `Task ${taskId} is not awaiting execution authorization.`);
         }
@@ -2125,9 +2271,143 @@ export class WorkflowService {
         this.readCurrentAdoptionPostureStrict(identity.projectId);
         const task = this.store.readTask(identity.projectId, taskId);
         assertExpectedRevision(task, expectedRevision);
+        if (readCurrentPreExecutionReplan(this.store, task)) {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Pre-execution replan requires task plan-set; the blocking audit cannot be replaced in place.', { taskId, requiredAction: 'task plan-set' });
+        }
         this.assertTaskKnowledgeBinding(identity.repositoryRoot, task);
         return appendCurrentPlanRiskAudit(this.store, task, input, this.now());
     }
+    recordPreExecutionReplan(repository, taskId, expectedRevision, actor, reason, binding, input) {
+        const context = this.#mutationContext(repository);
+        this.readCurrentAdoptionPostureStrict(context.identity.projectId);
+        const task = this.store.readTask(context.identity.projectId, taskId);
+        assertExpectedRevision(task, expectedRevision);
+        if (readCurrentPreExecutionReplan(this.store, task)) {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Task already has a pending pre-execution replan.', {
+                taskId,
+                requiredAction: 'task plan-set',
+            });
+        }
+        if (task.status !== 'ready' || task.steps.some((step) => ['in_progress', 'failed'].includes(step.status))) {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Pre-execution replan requires a ready Task with no Step in progress or failed.', {
+                taskId,
+                status: task.status,
+            });
+        }
+        if (!isClean(context.identity.repositoryRoot)) {
+            throw new WorkflowError('GIT_PRECONDITION_FAILED', 'Pre-execution replan requires a clean checkout.', {
+                changedFiles: changedFiles(context.identity.repositoryRoot),
+            });
+        }
+        const c1Posture = readTaskC1Posture(this.store, task);
+        const writerLease = context.locks.inspect(task.id);
+        if (c1Posture.state !== 'none' || writerLease) {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Pre-execution replan requires a clean authority boundary without C1 or writer lease.', {
+                taskId,
+                c1Posture: c1Posture.state,
+                writerLeasePresent: writerLease !== null,
+            });
+        }
+        this.assertTaskKnowledgeBinding(context.identity.repositoryRoot, task);
+        if (task.baseCommit) {
+            validateTaskHistory(context.identity.repositoryRoot, task);
+        }
+        else if (task.workspaceOwner !== null || task.taskBranch !== null
+            || task.steps.some((step) => step.status === 'completed')) {
+            throw new WorkflowError('STATE_CORRUPT', 'Unstarted pre-execution replan Task has inconsistent execution history.', {
+                taskId,
+            });
+        }
+        const authorization = this.assertExecutionAuthorizationFresh(task, context.identity.repositoryRoot);
+        const sourceAudit = readCurrentPlanRiskAudit(this.store, task, { requireCurrentTaskRevision: false });
+        if (!sourceAudit || !['approved', 'approved-with-rationale'].includes(sourceAudit.audit.decision)) {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Pre-execution replan requires the current positive Plan Risk Audit.');
+        }
+        const currentHead = headCommit(context.identity.repositoryRoot);
+        const actualBinding = {
+            expectedBriefHash: task.briefHash,
+            expectedPlanHash: task.planHash,
+            expectedPlanRiskAuditEventHash: sourceAudit.audit.eventHash,
+            expectedHeadCommit: currentHead,
+        };
+        if (canonicalJsonStringify(binding) !== canonicalJsonStringify(actualBinding)) {
+            throw new WorkflowError('STATE_CONFLICT', 'Pre-execution replan source binding is stale.', {
+                expected: binding,
+                actual: actualBinding,
+            });
+        }
+        if (input.decision !== 'stop-escalate') {
+            throw new WorkflowError('INVALID_ARGUMENT', 'Pre-execution replan requires a stop-escalate Plan Risk Audit.');
+        }
+        if (actor.trim() !== input.auditor.trim() || input.planner.trim() !== sourceAudit.audit.planner) {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Pre-execution replan must be recorded by the independent auditor against the original planner.', {
+                actor: actor.trim(),
+                auditor: input.auditor.trim(),
+                expectedPlanner: sourceAudit.audit.planner,
+                actualPlanner: input.planner.trim(),
+            });
+        }
+        assertPlanRiskSafetyPreserved(sourceAudit.audit, input, 'Pre-execution replan audit');
+        const now = this.now();
+        const preparedAuditBase = buildPlanRiskAuditEvent(this.store, task, input, now.toISOString(), now.getTime());
+        const preparedAudit = prepareSidecarAppend(readPlanRiskAuditEvents(this.store, task), preparedAuditBase.event);
+        const preparedMarker = preparePreExecutionReplanEvent(this.store, task, {
+            sourceAudit: sourceAudit.audit,
+            obstructionAudit: preparedAudit.event,
+            authorization,
+            sourceHeadCommit: currentHead,
+            actor,
+            reason,
+        }, now);
+        const resultTask = {
+            ...task,
+            revision: task.revision + 1,
+            updatedAt: now.toISOString(),
+            status: 'awaiting_execution_authorization',
+            authorizations: task.authorizations.map((candidate) => candidate.kind === 'execution' && candidate.decision === 'approved'
+                ? { ...candidate, decision: 'superseded' }
+                : candidate),
+            blockReason: reason.trim(),
+        };
+        const projectRoot = this.store.projectRoot(task.projectId);
+        const taskRoot = this.store.taskRoot(task.projectId, task.id);
+        const relative = (absolute) => path.relative(projectRoot, absolute).split(path.sep).join('/');
+        applyProjectTransaction({
+            projectRoot,
+            projectId: task.projectId,
+            transactionId: `tx-${createEntityId('TASK', now.getTime()).toLowerCase()}`,
+            kind: 'preexecution-plan-authority-withdrawal',
+            now,
+            targets: [
+                { path: relative(path.join(taskRoot, 'plan-risk-audits.jsonl')), content: preparedAudit.content },
+                { path: relative(path.join(taskRoot, preExecutionReplanSidecar())), content: preparedMarker.postimage },
+                { path: relative(path.join(taskRoot, 'state.json')), content: `${JSON.stringify(resultTask, null, 2)}\n` },
+            ],
+            validate: () => {
+                const saved = this.store.readTask(task.projectId, task.id);
+                const latestAudit = readPlanRiskAuditEvents(this.store, saved).at(-1) ?? null;
+                const marker = readCurrentPreExecutionReplan(this.store, saved);
+                if (saved.revision !== resultTask.revision
+                    || saved.status !== 'awaiting_execution_authorization'
+                    || saved.planHash !== task.planHash
+                    || latestAudit?.eventHash !== preparedAudit.event.eventHash
+                    || marker?.eventHash !== preparedMarker.event.eventHash
+                    || saved.authorizations.some((candidate) => candidate.kind === 'execution' && candidate.decision === 'approved')
+                    || hashCompletedSteps(saved) !== preparedMarker.event.completedStepsHash
+                    || headCommit(context.identity.repositoryRoot) !== currentHead
+                    || !isClean(context.identity.repositoryRoot)) {
+                    throw new WorkflowError('STATE_CORRUPT', 'Pre-execution replan transaction readback failed.', { taskId });
+                }
+                if (saved.baseCommit)
+                    validateTaskHistory(context.identity.repositoryRoot, saved);
+            },
+        });
+        return {
+            task: this.store.readTask(task.projectId, task.id),
+            audit: preparedAudit.event,
+            event: preparedMarker.event,
+        };
+    }
     showTaskHandoff(repository, taskId) {
         const { identity } = this.#mutationContext(repository);
         const task = this.store.readTask(identity.projectId, taskId);
@@ -2141,6 +2421,12 @@ export class WorkflowService {
         const context = this.#mutationContext(repository);
         const task = this.store.readTask(context.identity.projectId, taskId);
         assertExpectedRevision(task, expectedRevision);
+        if (readCurrentPreExecutionReplan(this.store, task)) {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Task ownership cannot change while a pre-execution replan is pending.', {
+                taskId,
+                requiredAction: 'task plan-set',
+            });
+        }
         const normalizedActor = actor.trim();
         if (!normalizedActor) {
             throw new WorkflowError('INVALID_ARGUMENT', 'Handoff actor is required.');
@@ -2748,7 +3034,7 @@ export class WorkflowService {
             const resultingHistory = !preparedRemediation || preparedRemediation.postimage === null
                 ? stepHistory
                 : [...stepHistory, preparedRemediation.event];
-            const rollingCauseDecision = deriveRollingCauseDecision(resultingHistory);
+            const rollingCauseDecision = deriveCurrentCauseDecisionForTask(this.store, task, stepId, resultingHistory);
             const c1Posture = readTaskC1Posture(this.store, task);
             const preparedYield = rollingCauseDecision === 'root-cause-replan' && c1Posture.state === 'claimed'
                 ? prepareTaskCorrectiveYield(this.store, paused, {
@@ -3062,7 +3348,7 @@ export class WorkflowService {
         const resultingHistory = preparedRemediation.postimage === null
             ? stepHistory
             : [...stepHistory, preparedRemediation.event];
-        const rollingCauseDecision = deriveRollingCauseDecision(resultingHistory);
+        const rollingCauseDecision = deriveCurrentCauseDecisionForTask(this.store, task, stepId, resultingHistory);
         const resolved = applyStrictStepReviewResolution(task, stepId, 'failed', summary);
         const paused = {
             ...resolved,
@@ -3086,7 +3372,7 @@ export class WorkflowService {
             ? prepareTaskCorrectiveYield(this.store, paused, {
                 actor: c1Posture.claimant,
                 writerToken: reviewLease.token,
-                reason: `Yield execution authority after repeated authoritative cause ${preparedRemediation.event.eventId}.`,
+                reason: `Yield execution authority after authoritative replan cause ${preparedRemediation.event.eventId}.`,
                 eventId: `HOF-${sha256Hex([
                     'strict-review-root-cause-replan-pause-v1',
                     task.id,
@@ -3809,6 +4095,9 @@ export class WorkflowService {
         const now = this.now().getTime();
         const activeLeases = leases.filter((lease) => Date.parse(lease.expiresAt) > now);
         const staleLeases = leases.filter((lease) => Date.parse(lease.expiresAt) <= now);
+        const pendingPreExecutionReplanTaskIds = tasks
+            .filter((task) => readCurrentPreExecutionReplan(this.store, task) !== null)
+            .map((task) => task.id);
         const activeMilestones = milestones.filter((milestone) => !['accepted', 'cancelled'].includes(milestone.status));
         const inspectedVersions = inspectWorkflowVersions(snapshot.identity.repositoryRoot, activeMilestones.map((milestone) => milestone.baseBranch));
         const milestoneBases = inspectedVersions.milestoneBases.map((base) => ({
@@ -3836,6 +4125,9 @@ export class WorkflowService {
             ...(runningSteps.length > 0 ? ['At least one Worker Step is in progress.'] : []),
             ...(activeLeases.length > 0 ? ['At least one writer lease is active.'] : []),
             ...(staleLeases.length > 0 ? ['At least one stale writer lease requires explicit repair.'] : []),
+            ...(pendingPreExecutionReplanTaskIds.length > 0
+                ? [`Complete the pending pre-execution Plan replacement and reauthorization first: ${pendingPreExecutionReplanTaskIds.join(', ')}.`]
+                : []),
             ...versionBlockers,
             ...observationPreflightBlockers(snapshot.observation),
         ];
@@ -3861,10 +4153,12 @@ export class WorkflowService {
                 milestoneBases,
             },
             dependencyTransport: {
-                safe: versionBlockers.length === 0,
-                requiredAction: versionBlockers.length === 0
-                    ? null
-                    : 'Land only package.json/package-lock.json dependency changes on every active Milestone base; do not transport unrelated product commits.',
+                safe: versionBlockers.length === 0 && pendingPreExecutionReplanTaskIds.length === 0,
+                requiredAction: pendingPreExecutionReplanTaskIds.length > 0
+                    ? 'Complete each pending pre-execution task plan-set and reauthorization before changing Workflow dependency HEAD.'
+                    : versionBlockers.length === 0
+                        ? null
+                        : 'Land only package.json/package-lock.json dependency changes on every active Milestone base; do not transport unrelated product commits.',
             },
             adoption: snapshot.adoption,
             observation: snapshot.observation,
@@ -5071,6 +5365,11 @@ export class WorkflowService {
                         throw error;
                     const blockingDecision = error.details.decision;
                     const blockingAudit = readPlanRiskAuditEvents(this.store, activeTask).at(-1) ?? null;
+                    const preExecutionReplan = readCurrentPreExecutionReplan(this.store, activeTask);
+                    const verifiedPreExecutionReplan = preExecutionReplan
+                        && blockingAudit?.eventHash === preExecutionReplan.obstructionPlanRiskAuditEventHash
+                        ? resolvePreExecutionReplanAudits(this.store, activeTask, preExecutionReplan)
+                        : null;
                     const existingRemediationEvent = blockingAudit && activeTask.milestoneId
                         ? [...readMilestoneScopeChangeEvents(this.store, status.projectId, activeTask.milestoneId)]
                             .reverse()
@@ -5104,50 +5403,34 @@ export class WorkflowService {
                     const eligibleRemediationPredecessorTaskIds = [...remediationAncestorIds]
                         .filter((candidateTaskId) => tasksById.get(candidateTaskId)?.status === 'merged')
                         .sort();
-                    planRiskAuditRecovery = blockingDecision === 'stop-escalate' && auditedRemediationEligible
+                    planRiskAuditRecovery = verifiedPreExecutionReplan && preExecutionReplan
                         ? {
                             scope: 'task',
                             id: activeTask.id,
                             status: activeTask.status,
-                            action: existingRemediationTask?.status === 'merged'
-                                ? 'task plan-set'
-                                : existingRemediationTask
-                                    ? 'doctor'
-                                    : remediationDiscovery?.status === 'ready_to_materialize'
-                                        ? 'milestone remediation-materialize'
-                                        : remediationDiscovery
-                                            ? 'discovery update'
-                                            : 'discovery start',
+                            action: 'task plan-set',
                             blockedAction: 'task authorize',
                             revision: activeTask.revision,
-                            planRiskAuditDecision: {
-                                state: 'recorded-blocking',
-                                decision: blockingDecision,
-                                reason: error.message,
-                                requiredAction: 'Materialize one audited additive remediation Task, merge it, then replace the rejected Plan.',
+                            preExecutionReplan: {
+                                state: 'recorded',
+                                eventId: preExecutionReplan.eventId,
+                                eventHash: preExecutionReplan.eventHash,
+                                sourcePlanHash: preExecutionReplan.sourcePlanHash,
+                                sourceHeadCommit: preExecutionReplan.sourceHeadCommit,
+                                obstructionPlanRiskAuditEventId: preExecutionReplan.obstructionPlanRiskAuditEventId,
+                                obstructionPlanRiskAuditEventHash: preExecutionReplan.obstructionPlanRiskAuditEventHash,
+                                preservesTaskScope: true,
+                                preservesCompletedStepAuthority: true,
+                                requiredAction: 'Replace the obstructed implementation Plan through ordinary task plan-set.',
                             },
-                            auditedRemediation: {
-                                state: existingRemediationTask?.status === 'merged'
-                                    ? 'merged-replan-required'
-                                    : existingRemediationTask
-                                        ? 'materialized-not-merged'
-                                        : remediationDiscovery?.status === 'ready_to_materialize'
-                                            ? 'ready-to-materialize'
-                                            : 'discovery-required',
-                                humanApprovalRequired: false,
-                                blockedTaskId: activeTask.id,
-                                blockedTaskRevision: activeTask.revision,
-                                milestoneId: remediationMilestone.id,
-                                milestoneRevision: remediationMilestone.revision,
-                                planRiskAuditEventId: blockingAudit?.eventId ?? null,
-                                planRiskAuditEventHash: blockingAudit?.eventHash ?? null,
-                                discoveryId: remediationDiscovery?.id ?? null,
-                                discoveryRevision: remediationDiscovery?.revision ?? null,
-                                remediationTaskId: existingRemediationTask?.id ?? null,
-                                remediationTaskStatus: existingRemediationTask?.status ?? null,
-                                requiredPredecessorTaskIds: [...(remediationMembership.dependsOnTaskIds ?? [])],
-                                eligibleMergedAncestorTaskIds: eligibleRemediationPredecessorTaskIds,
-                                command: existingRemediationTask?.status === 'merged'
+                            taskPlanContract: this.taskPlanContract(status.projectId, activeTask),
+                        }
+                        : blockingDecision === 'stop-escalate' && auditedRemediationEligible
+                            ? {
+                                scope: 'task',
+                                id: activeTask.id,
+                                status: activeTask.status,
+                                action: existingRemediationTask?.status === 'merged'
                                     ? 'task plan-set'
                                     : existingRemediationTask
                                         ? 'doctor'
@@ -5156,46 +5439,84 @@ export class WorkflowService {
                                             : remediationDiscovery
                                                 ? 'discovery update'
                                                 : 'discovery start',
-                                boundedEffect: 'append-one-required-remediation-task-and-add-one-blocked-task-dependency',
-                                preservesMilestoneSemantics: true,
-                            },
-                            taskPlanContract: this.taskPlanContract(status.projectId, activeTask),
-                        }
-                        : blockingDecision === 'stop-escalate' || blockingDecision === 'split-required'
-                            ? {
-                                scope: 'task',
-                                id: activeTask.id,
-                                status: activeTask.status,
-                                action: blockingDecision === 'stop-escalate' ? 'task plan-set' : 'doctor',
                                 blockedAction: 'task authorize',
                                 revision: activeTask.revision,
                                 planRiskAuditDecision: {
                                     state: 'recorded-blocking',
                                     decision: blockingDecision,
                                     reason: error.message,
-                                    requiredAction: blockingDecision === 'stop-escalate'
-                                        ? 'Replace the rejected Step Plan before requesting fresh authorization.'
-                                        : 'Resolve the required cross-Task split through an explicit Milestone topology decision.',
+                                    requiredAction: 'Materialize one audited additive remediation Task, merge it, then replace the rejected Plan.',
                                 },
-                                ...(blockingDecision === 'stop-escalate'
-                                    ? { taskPlanContract: this.taskPlanContract(status.projectId, activeTask) }
-                                    : {}),
-                            }
-                            : {
-                                scope: 'task',
-                                id: activeTask.id,
-                                status: activeTask.status,
-                                action: 'task plan-risk-audit',
-                                revision: activeTask.revision,
-                                planRiskAuditRecovery: {
-                                    state: 'required',
-                                    reason: error.message,
-                                    currentBriefHash: activeTask.briefHash,
-                                    currentPlanHash: activeTask.planHash,
-                                    knowledgeMapRevision: activeTask.knowledgeMapRevision,
-                                    knowledgeMapHash: activeTask.knowledgeMapHash,
+                                auditedRemediation: {
+                                    state: existingRemediationTask?.status === 'merged'
+                                        ? 'merged-replan-required'
+                                        : existingRemediationTask
+                                            ? 'materialized-not-merged'
+                                            : remediationDiscovery?.status === 'ready_to_materialize'
+                                                ? 'ready-to-materialize'
+                                                : 'discovery-required',
+                                    humanApprovalRequired: false,
+                                    blockedTaskId: activeTask.id,
+                                    blockedTaskRevision: activeTask.revision,
+                                    milestoneId: remediationMilestone.id,
+                                    milestoneRevision: remediationMilestone.revision,
+                                    planRiskAuditEventId: blockingAudit?.eventId ?? null,
+                                    planRiskAuditEventHash: blockingAudit?.eventHash ?? null,
+                                    discoveryId: remediationDiscovery?.id ?? null,
+                                    discoveryRevision: remediationDiscovery?.revision ?? null,
+                                    remediationTaskId: existingRemediationTask?.id ?? null,
+                                    remediationTaskStatus: existingRemediationTask?.status ?? null,
+                                    requiredPredecessorTaskIds: [...(remediationMembership.dependsOnTaskIds ?? [])],
+                                    eligibleMergedAncestorTaskIds: eligibleRemediationPredecessorTaskIds,
+                                    command: existingRemediationTask?.status === 'merged'
+                                        ? 'task plan-set'
+                                        : existingRemediationTask
+                                            ? 'doctor'
+                                            : remediationDiscovery?.status === 'ready_to_materialize'
+                                                ? 'milestone remediation-materialize'
+                                                : remediationDiscovery
+                                                    ? 'discovery update'
+                                                    : 'discovery start',
+                                    boundedEffect: 'append-one-required-remediation-task-and-add-one-blocked-task-dependency',
+                                    preservesMilestoneSemantics: true,
                                 },
-                            };
+                                taskPlanContract: this.taskPlanContract(status.projectId, activeTask),
+                            }
+                            : blockingDecision === 'stop-escalate' || blockingDecision === 'split-required'
+                                ? {
+                                    scope: 'task',
+                                    id: activeTask.id,
+                                    status: activeTask.status,
+                                    action: blockingDecision === 'stop-escalate' ? 'task plan-set' : 'doctor',
+                                    blockedAction: 'task authorize',
+                                    revision: activeTask.revision,
+                                    planRiskAuditDecision: {
+                                        state: 'recorded-blocking',
+                                        decision: blockingDecision,
+                                        reason: error.message,
+                                        requiredAction: blockingDecision === 'stop-escalate'
+                                            ? 'Replace the rejected Step Plan before requesting fresh authorization.'
+                                            : 'Resolve the required cross-Task split through an explicit Milestone topology decision.',
+                                    },
+                                    ...(blockingDecision === 'stop-escalate'
+                                        ? { taskPlanContract: this.taskPlanContract(status.projectId, activeTask) }
+                                        : {}),
+                                }
+                                : {
+                                    scope: 'task',
+                                    id: activeTask.id,
+                                    status: activeTask.status,
+                                    action: 'task plan-risk-audit',
+                                    revision: activeTask.revision,
+                                    planRiskAuditRecovery: {
+                                        state: 'required',
+                                        reason: error.message,
+                                        currentBriefHash: activeTask.briefHash,
+                                        currentPlanHash: activeTask.planHash,
+                                        knowledgeMapRevision: activeTask.knowledgeMapRevision,
+                                        knowledgeMapHash: activeTask.knowledgeMapHash,
+                                    },
+                                };
                 }
             }
             const taskNext = activeTask.status === 'planning'
@@ -6071,8 +6392,8 @@ export class WorkflowService {
                                 ...(task.steps.find((step) => step.id === guardedCorrectivePosture.stepId)?.status !== 'failed'
                                     ? [`${guardedCorrectivePosture.stepId} must remain failed.`]
                                     : []),
-                                ...(writerLease ? ['No active or stale writer lease may remain after the failure pause.'] : []),
-                                ...(rollingC1Posture.state !== 'none'
+                                ...(writerLease && rollingC1Posture.state !== 'claimed' ? ['No active or stale writer lease may remain after the failure pause.'] : []),
+                                ...(rollingC1Posture.state !== 'none' && rollingC1Posture.state !== 'claimed'
                                     ? ['No C1 claim may remain after the root-cause failure pause.']
                                     : []),
                             ];
@@ -6089,7 +6410,7 @@ export class WorkflowService {
                                     },
                                 }
                                 : {
-                                    action: 'task plan-set',
+                                    action: rollingC1Posture.state === 'claimed' ? 'task corrective-yield' : 'task plan-set',
                                     blockedAction: 'task run',
                                     stepId: guardedCorrectivePosture.stepId,
                                     rollingWave: {
@@ -6236,9 +6557,42 @@ export class WorkflowService {
                     },
                 }
             : {};
+        const preExecutionReplanBlockers = task.status === 'ready'
+            ? [
+                ...(task.steps.some((step) => step.status === 'in_progress') ? ['No Step may be in progress.'] : []),
+                ...(task.steps.some((step) => step.status === 'failed') ? ['No failed Step may require corrective recovery.'] : []),
+                ...(handoffPosture.state !== 'none' ? ['No C1 claim or pending handoff may exist.'] : []),
+                ...(inspectRawWriterLease(this.store.lockRoot(task.projectId), task.id, this.store.root)
+                    ? ['No active or stale writer lease may exist.']
+                    : []),
+                ...(!isClean(repositoryRoot) ? ['Repository checkout must be clean.'] : []),
+                ...(!planRiskAudit || !['approved', 'approved-with-rationale'].includes(planRiskAudit.audit.decision)
+                    ? ['A current positive Plan Risk Audit is required.']
+                    : []),
+            ]
+            : [];
+        const preExecutionReplanOption = task.status === 'ready' && task.planHash && planRiskAudit
+            ? {
+                command: 'task preexecution-replan',
+                state: preExecutionReplanBlockers.length === 0 ? 'eligible' : 'blocked',
+                expectedRevision: task.revision,
+                expectedBriefHash: task.briefHash,
+                expectedPlanHash: task.planHash,
+                expectedPlanRiskAuditEventHash: planRiskAudit.audit.eventHash,
+                expectedHeadCommit: headCommit(repositoryRoot),
+                auditDecision: 'stop-escalate',
+                actorMustEqualAuditAuditor: true,
+                humanApprovalRequired: false,
+                boundedEffect: 'record-current-plan-obstruction-and-withdraw-execution-authorization',
+                preservesTaskScope: true,
+                preservesCompletedStepAuthority: true,
+                blockers: preExecutionReplanBlockers,
+            }
+            : null;
         const result = {
             ...next,
             ...handoffOverlay,
+            ...(preExecutionReplanOption ? { preExecutionReplanOption } : {}),
             ...(strictStepReviewStep
                 ? {
                     action: 'task step-review',
@@ -6414,6 +6768,9 @@ export class WorkflowService {
         };
     }
     assertTaskContextChangeAllowed(task) {
+        if (readCurrentPreExecutionReplan(this.store, task)) {
+            throw new WorkflowError('TRANSITION_BLOCKED', `Task ${task.id} has a pending pre-execution replan; replace the implementation Plan before changing context.`, { taskId: task.id, requiredAction: 'task plan-set' });
+        }
         if (task.status === 'needs_fix' && !task.steps.some((step) => step.status === 'failed')) {
             throw new WorkflowError('TRANSITION_BLOCKED', `Task ${task.id} requires a replacement Step Plan; Project Knowledge cannot rebind or refresh the stale Plan.`, {
                 taskId: task.id,
@@ -7623,6 +7980,83 @@ function taskHasStarted(task) {
         'merged',
     ].includes(task.status);
 }
+function resolvePreExecutionReplanAudits(store, task, marker) {
+    const audits = readPlanRiskAuditEvents(store, task);
+    const sourceAudit = audits.find((audit) => audit.eventId === marker.sourcePlanRiskAuditEventId
+        && audit.eventHash === marker.sourcePlanRiskAuditEventHash) ?? null;
+    const obstructionAudit = audits.find((audit) => audit.eventId === marker.obstructionPlanRiskAuditEventId
+        && audit.eventHash === marker.obstructionPlanRiskAuditEventHash) ?? null;
+    const sourceAuthorization = task.authorizations.find((authorization) => authorization.kind === 'execution'
+        && authorization.decision === 'superseded'
+        && hashExecutionAuthorization({ ...authorization, decision: 'approved' }) === marker.sourceExecutionAuthorizationHash);
+    if (!sourceAudit || !obstructionAudit || audits.at(-1)?.eventHash !== obstructionAudit.eventHash
+        || !['approved', 'approved-with-rationale'].includes(sourceAudit.decision)
+        || obstructionAudit.decision !== 'stop-escalate'
+        || sourceAudit.planHash !== task.planHash || obstructionAudit.planHash !== task.planHash
+        || !sourceAuthorization) {
+        throw new WorkflowError('STATE_CORRUPT', 'Pre-execution replan provenance chain is incomplete or inconsistent.', {
+            taskId: task.id,
+            eventId: marker.eventId,
+        });
+    }
+    return { sourceAudit, obstructionAudit };
+}
+function assertPlanRiskSafetyPreserved(source, candidate, label) {
+    const candidateByStep = new Map(candidate.stepClassifications.map((classification) => [classification.stepId, classification]));
+    const missing = [];
+    for (const sourceClassification of source.stepClassifications) {
+        const candidateClassification = candidateByStep.get(sourceClassification.stepId);
+        if (!candidateClassification) {
+            missing.push({ stepId: sourceClassification.stepId, field: 'classification', values: [] });
+            continue;
+        }
+        const preserveStrings = (field, sourceValues, candidateValues) => {
+            const absent = sourceValues.filter((value) => !candidateValues.includes(value));
+            if (absent.length > 0)
+                missing.push({ stepId: sourceClassification.stepId, field, values: absent });
+        };
+        preserveStrings('categories', sourceClassification.categories, candidateClassification.categories);
+        preserveStrings('failureModes', sourceClassification.failureModes, candidateClassification.failureModes);
+        preserveStrings('requiredEvidence', sourceClassification.requiredEvidence, candidateClassification.requiredEvidence);
+        if (sourceClassification.reviewRequired && !candidateClassification.reviewRequired) {
+            missing.push({ stepId: sourceClassification.stepId, field: 'reviewRequired', values: [true] });
+        }
+        const proofBinding = (proof) => canonicalJsonStringify({ failureMode: proof.failureMode, evidence: proof.evidence });
+        const candidateProofs = new Set((candidateClassification.proofObligations ?? []).map(proofBinding));
+        const absentProofs = (sourceClassification.proofObligations ?? [])
+            .filter((proof) => !candidateProofs.has(proofBinding(proof)));
+        if (absentProofs.length > 0) {
+            missing.push({ stepId: sourceClassification.stepId, field: 'proofObligations', values: absentProofs });
+        }
+    }
+    if (missing.length > 0) {
+        throw new WorkflowError('TRANSITION_BLOCKED', `${label} cannot suppress existing guarded risk or proof authority.`, {
+            missing,
+        });
+    }
+    const sourceProofText = new Map(source.stepClassifications.flatMap((classification) => (classification.proofObligations ?? []).map((proof) => [
+        canonicalJsonStringify({ stepId: classification.stepId, failureMode: proof.failureMode, evidence: proof.evidence }),
+        canonicalJsonStringify({ counterexample: proof.counterexample, expectedResult: proof.expectedResult }),
+    ])));
+    const revisedProofText = candidate.stepClassifications.some((classification) => (classification.proofObligations ?? []).some((proof) => {
+        const binding = canonicalJsonStringify({
+            stepId: classification.stepId,
+            failureMode: proof.failureMode,
+            evidence: proof.evidence,
+        });
+        const previous = sourceProofText.get(binding);
+        return previous !== undefined
+            && previous !== canonicalJsonStringify({ counterexample: proof.counterexample, expectedResult: proof.expectedResult });
+    }));
+    if (revisedProofText && (candidate.decision !== 'approved-with-rationale'
+        || candidate.summary.trim() === source.summary.trim())) {
+        throw new WorkflowError('TRANSITION_BLOCKED', `${label} may revise proof prose only with approved-with-rationale and a new audit summary.`, {
+            sourceSummary: source.summary,
+            candidateSummary: candidate.summary,
+            candidateDecision: candidate.decision,
+        });
+    }
+}
 function taskCanRebindKnowledge(task) {
     return [
         'awaiting_execution_authorization',