codex-workflow-v2 2.0.0-alpha.6 → 2.0.0-alpha.6.2

package/dist/src/workflow.js

@@ -7,13 +7,14 @@ import { assertDelegationCanAuthorize, delegationCanAuthorize, hashDelegationPol
 import { assessDiscovery, mergeUnique } from './domain/discovery.js';
 import { pathAllowed, validatePlan } from './domain/validation.js';
 import { WorkflowError } from './errors.js';
+import { inspectLocalDependency } from './diagnostics.js';
 import { bindGraphEvidence, createGraphRefreshRequest, fallbackGraphBinding, inspectGraphBinding, validateGraphRequestCurrent, } from './graph.js';
 import { appendTaskClaim, appendTaskHandback, appendTaskHandoff, assertTaskMutationAllowedByC1, readTaskC1Posture, } from './alpha6/handoff.js';
 import { applyAdoptionPosture, assertAdoptionBaselinePreserved, buildAdoptionPreparation, initializeProjectRegistrationAdoption, readCurrentAdoptionPosture, } from './alpha6/adoption.js';
 import { appendCurrentPlanRiskAudit, appendReboundPlanRiskAudit, readCurrentPlanRiskAudit, validatePlanRiskAuditCandidate, } from './alpha6/plan-risk.js';
-import { appendCorrectiveDecisionEvent, appendRemediationEvent, assertCorrectiveAuditorIndependence, assertGuardedRemediationAttemptAllowed, findFailedGuardedStepRequiringCorrectiveDecision, readCorrectiveDecisionEvents, readRemediationEvents, } from './alpha6/remediation.js';
+import { appendCorrectivePlanAuditRecord, appendCorrectiveDecisionEvent, appendRemediationEvent, assertCorrectiveAuditorIndependence, assertGuardedRemediationAttemptAllowed, findFailedGuardedStepRequiringCorrectiveDecision, hasCorrectivePlanAuditBinding, readCorrectiveDecisionEvents, readRemediationEvents, } from './alpha6/remediation.js';
 import { applyMilestoneScopeChangeTransaction, assertMilestoneMembershipIntegrity, assertMilestoneScopeChangeStatusAllowed, normalizeMilestonePlan, prepareMilestoneScopeChangeCandidate, readMilestoneForScopeChange, readMilestoneWithIntegrity, } from './alpha6/milestone.js';
-import { buildCurrentStrictStepReviewCycle, ensurePendingStrictStepReview, isStepReviewRequired, recordStrictStepReview, } from './alpha6/review.js';
+import { buildCurrentStrictStepReviewCycle, ensurePendingStrictStepReview, isStepReviewRequired, recordStrictStepReview, readReviewerAttestations, } from './alpha6/review.js';
 import { applyKnowledgeSelections, hashKnowledgeMap, inspectKnowledgeMap, normalizeRelativePath, reconcileKnowledgeMap, scanProjectKnowledge, selectKnowledgeSources, } from './memory.js';
 import { canonicalJsonStringify, sha256Hex } from './alpha6/store-sidecars.js';
 import { commitStep, mergeTaskBranch, runChecks, startLocalTaskBranch, syncBaseIntoTask, validateTaskHistory, } from './git.js';
@@ -23,12 +24,15 @@ import { WriterLockManager } from './state/lock.js';
 import { FileStateStore } from './state/store.js';
 import { createEntityId } from './ulid.js';
 import { PACKAGE_VERSION } from './version.js';
+const ALPHA6_CORRECTIVE_RESCUE_HEAD = '5c63798cc7b8fbb5e1c8b26ebf93876bc642295a';
 export class WorkflowService {
     store;
     now;
-    constructor(store = new FileStateStore(), now = () => new Date()) {
+    alpha6CorrectiveRescueHead;
+    constructor(store = new FileStateStore(), now = () => new Date(), alpha6CorrectiveRescueHead = ALPHA6_CORRECTIVE_RESCUE_HEAD) {
         this.store = store;
         this.now = now;
+        this.alpha6CorrectiveRescueHead = alpha6CorrectiveRescueHead;
     }
     context(repository) {
         const identity = resolveRepositoryIdentity(repository);
@@ -564,14 +568,13 @@ export class WorkflowService {
         this.validateKnowledgeTargets(knowledgeMap, plan);
         const task = this.store.readTask(identity.projectId, taskId);
         assertExpectedRevision(task, expectedRevision);
-        if (!['planning', 'awaiting_execution_authorization', 'needs_fix', 'blocked'].includes(task.status)) {
+        if (!['planning', 'awaiting_execution_authorization', 'ready', 'needs_fix', 'blocked'].includes(task.status)) {
             throw new WorkflowError('TRANSITION_BLOCKED', `Cannot update Plan while Task is ${task.status}.`);
         }
         const currentPlanCorrectiveDecisions = task.planHash
             ? readCorrectiveDecisionEvents(this.store, task).filter((event) => event.planHash === task.planHash)
             : [];
         const currentReplanDecisions = currentPlanCorrectiveDecisions.filter((event) => event.decision === 'replan-required');
-        const currentContinueFixDecisions = currentPlanCorrectiveDecisions.filter((event) => event.decision === 'continue-fix');
         const currentHardBlockingDecisions = currentPlanCorrectiveDecisions.filter((event) => event.decision === 'split-required' || event.decision === 'stop-escalate');
         const currentReplanRequiredStepIds = [...new Set(currentReplanDecisions.map((event) => event.stepId))];
         if (currentHardBlockingDecisions.length > 0) {
@@ -592,33 +595,22 @@ export class WorkflowService {
                 requiredAction: 'Resolve the blocked strict review or record a replan-required corrective decision first.',
             });
         }
-        if (currentContinueFixDecisions.length > 0) {
-            throw new WorkflowError('TRANSITION_BLOCKED', `Task ${task.id} already has a current continue-fix corrective decision; use the current Plan retry path instead of issuing another plan-set.`, {
-                taskId: task.id,
-                requiredAction: 'Run the guarded Step under the current Plan retry path, or escalate/cancel instead of issuing another plan-set at the same ordinal.',
-                decisions: currentContinueFixDecisions.map((event) => ({
-                    eventId: event.eventId,
-                    stepId: event.stepId,
-                    triggeringAttemptCount: event.triggeringAttemptCount,
-                })),
-            });
-        }
-        const currentPlanRiskAudit = task.status === 'needs_fix'
-            ? readCurrentPlanRiskAudit(this.store, task)
-            : null;
+        const currentPlanRiskAudit = task.planHash ? readCurrentPlanRiskAudit(this.store, task) : null;
         const failedReviewAttempts = countFailedReviewAttempts(this.store.taskRoot(identity.projectId, taskId));
         if (task.status === 'needs_fix' && task.review.status === 'failed' && failedReviewAttempts >= 2) {
             validateCorrectivePlanAudit(task, correctiveAudit, failedReviewAttempts);
         }
-        const guardedRemediationGate = task.status === 'needs_fix' && currentPlanRiskAudit
+        const guardedRemediationGate = ['needs_fix', 'awaiting_execution_authorization', 'ready'].includes(task.status)
+            && currentPlanRiskAudit
             ? findFailedGuardedStepRequiringCorrectiveDecision(this.store, task, currentPlanRiskAudit)
             : null;
-        if (guardedRemediationGate && currentReplanDecisions.length === 0 && !correctiveAudit) {
-            throw new WorkflowError('TRANSITION_BLOCKED', `Guarded Step ${guardedRemediationGate.stepId} requires a corrective decision before another remediation run can be authorized.`, {
+        if (guardedRemediationGate && !guardedRemediationGate.correctiveDecision) {
+            throw new WorkflowError('TRANSITION_BLOCKED', `Guarded Step ${guardedRemediationGate.stepId} requires a separate corrective decision before a corrective Plan can be applied.`, {
                 taskId: task.id,
                 stepId: guardedRemediationGate.stepId,
                 attemptCount: guardedRemediationGate.attemptCount,
                 requiredSidecar: 'corrective-decisions.jsonl',
+                requiredAction: 'Run task corrective-decision first.',
                 allowedDecision: 'continue-fix',
                 escalationDecisions: ['replan-required', 'split-required', 'stop-escalate'],
             });
@@ -630,25 +622,57 @@ export class WorkflowService {
                 requiredAction: 'Retry task plan-set without corrective-audit input; the recorded replan-required decision is the authorization for this recovery path.',
             });
         }
-        if (guardedRemediationGate && currentReplanDecisions.length === 0 && correctiveAudit?.decision !== 'continue-fix') {
-            throw new WorkflowError('TRANSITION_BLOCKED', `Guarded Step ${guardedRemediationGate.stepId} requires a separate corrective-decision record before execution may continue; plan-set only supports continue-fix.`, {
+        const guardedContinueFixDecision = guardedRemediationGate?.correctiveDecision?.decision === 'continue-fix'
+            ? guardedRemediationGate.correctiveDecision
+            : null;
+        if (task.status === 'ready' && !guardedContinueFixDecision) {
+            throw new WorkflowError('TRANSITION_BLOCKED', `Cannot update Plan while Task is ${task.status}.`);
+        }
+        if (guardedRemediationGate?.correctiveDecision && !guardedContinueFixDecision && currentReplanDecisions.length === 0) {
+            throw new WorkflowError('TRANSITION_BLOCKED', `Corrective decision ${guardedRemediationGate.correctiveDecision.decision} prohibits continue-fix Plan application.`, {
                 taskId: task.id,
                 stepId: guardedRemediationGate.stepId,
-                decision: correctiveAudit?.decision ?? null,
+                decisionEventId: guardedRemediationGate.correctiveDecision.eventId,
             });
         }
-        for (const requirement of task.requirements) {
-            if (!plan.requirements.includes(requirement)) {
-                throw new WorkflowError('TRANSITION_BLOCKED', `Plan omits Task requirement ${requirement}.`);
+        if (guardedContinueFixDecision) {
+            validateGuardedCorrectivePlanAudit(this.store, task, guardedRemediationGate.stepId, guardedContinueFixDecision, correctiveAudit);
+        }
+        if (guardedContinueFixDecision) {
+            if (!sameOrderedStrings(plan.requirements, task.requirements)) {
+                throw new WorkflowError('TRANSITION_BLOCKED', 'Corrective Plan requirements must exactly preserve Task scope.', {
+                    expected: task.requirements,
+                    actual: plan.requirements,
+                });
+            }
+            if (!sameOrderedStrings(plan.acceptance, task.acceptance)) {
+                throw new WorkflowError('TRANSITION_BLOCKED', 'Corrective Plan acceptance must exactly preserve Task scope.', {
+                    expected: task.acceptance,
+                    actual: plan.acceptance,
+                });
             }
         }
-        for (const acceptance of task.acceptance) {
-            if (!plan.acceptance.includes(acceptance)) {
-                throw new WorkflowError('TRANSITION_BLOCKED', `Plan omits Task acceptance ${acceptance}.`);
+        else {
+            for (const requirement of task.requirements) {
+                if (!plan.requirements.includes(requirement)) {
+                    throw new WorkflowError('TRANSITION_BLOCKED', `Plan omits Task requirement ${requirement}.`);
+                }
+            }
+            for (const acceptance of task.acceptance) {
+                if (!plan.acceptance.includes(acceptance)) {
+                    throw new WorkflowError('TRANSITION_BLOCKED', `Plan omits Task acceptance ${acceptance}.`);
+                }
             }
         }
         const root = this.store.taskRoot(identity.projectId, taskId);
         const stagedPlan = this.store.stageArtifact(root, 'plan.md', renderPlan(task, plan));
+        if (guardedContinueFixDecision && stagedPlan.hash === task.planHash) {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Continue-fix requires a changed full corrective Plan.', {
+                taskId: task.id,
+                stepId: guardedRemediationGate.stepId,
+                planHash: task.planHash,
+            });
+        }
         const authorizations = task.authorizations.map((authorization) => authorization.kind === 'execution' && authorization.decision === 'approved'
             ? { ...authorization, decision: 'superseded' }
             : authorization);
@@ -678,9 +702,8 @@ export class WorkflowService {
                 stepId: guardedRemediationGate.stepId,
             });
         }
-        if (correctiveAudit && guardedRemediationGate && currentReplanDecisions.length === 0 && currentPlanRiskAudit) {
-            assertCorrectiveAuditorIndependence(this.store, task, guardedRemediationGate.stepId, correctiveAudit.auditor);
-            appendCorrectiveDecisionEvent(this.store, task, guardedRemediationGate.stepId, correctiveAudit, currentPlanRiskAudit, stagedPlan.hash, this.now());
+        if (guardedContinueFixDecision) {
+            assertNonTargetStepsUnchanged(task, plan, guardedRemediationGate.stepId);
         }
         const candidate = {
             ...task,
@@ -703,12 +726,16 @@ export class WorkflowService {
             evidenceHash: null,
             blockReason: null,
         };
-        if (planRiskAudit)
-            validatePlanRiskAuditCandidate(this.store, candidate, planRiskAudit);
+        const effectivePlanRiskAudit = planRiskAudit ?? (guardedContinueFixDecision ? currentPlanRiskAudit?.audit ?? null : null);
+        if (effectivePlanRiskAudit)
+            validatePlanRiskAuditCandidate(this.store, candidate, effectivePlanRiskAudit);
         const saved = this.store.writeTask(candidate, expectedRevision);
         this.store.publishArtifact(stagedPlan);
-        if (planRiskAudit)
-            appendCurrentPlanRiskAudit(this.store, saved, planRiskAudit, this.now());
+        if (effectivePlanRiskAudit)
+            appendCurrentPlanRiskAudit(this.store, saved, effectivePlanRiskAudit, this.now());
+        if (guardedContinueFixDecision && correctiveAudit) {
+            appendCorrectivePlanAuditRecord(this.store, task, saved, guardedRemediationGate.stepId, guardedContinueFixDecision, correctiveAudit, this.now());
+        }
         if (correctiveAudit && task.status === 'needs_fix' && task.review.status === 'failed') {
             appendCorrectivePlanAudit(this.store.taskRoot(identity.projectId, taskId), task, saved, failedReviewAttempts, correctiveAudit, this.now());
         }
@@ -734,6 +761,11 @@ export class WorkflowService {
         if (activeStep) {
             throw new WorkflowError('TRANSITION_BLOCKED', `Cannot rebind Task Plan knowledge while ${activeStep.id} is in progress.`);
         }
+        const currentPlanRiskAudit = readCurrentPlanRiskAudit(this.store, task);
+        const breakerPlanRiskAudit = currentPlanRiskAudit
+            && findFailedGuardedStepRequiringCorrectiveDecision(this.store, task, currentPlanRiskAudit)
+            ? currentPlanRiskAudit
+            : null;
         const knowledgeMap = this.requireActiveKnowledgeMap(identity.repositoryRoot, identity.projectId);
         const knowledgeMapHash = hashKnowledgeMap(knowledgeMap);
         if (task.knowledgeMapRevision === knowledgeMap.revision &&
@@ -793,6 +825,9 @@ export class WorkflowService {
             blockReason: null,
         }, expectedRevision);
         this.store.publishArtifact(stagedPlan);
+        if (breakerPlanRiskAudit) {
+            appendReboundPlanRiskAudit(this.store, task, saved, breakerPlanRiskAudit, this.now());
+        }
         return saved;
     }
     refreshTaskContext(repository, taskId, expectedTaskRevision, expectedKnowledgeMapRevision, actor, delegationGrantId) {
@@ -814,6 +849,8 @@ export class WorkflowService {
         const inspectedMap = inspectKnowledgeMap(currentMap, scanProjectKnowledge(identity.repositoryRoot, identity.projectId, this.now()));
         const transitions = [];
         const currentPlanRiskAudit = readCurrentPlanRiskAudit(this.store, task);
+        const breakerPlanRiskAuditWillBePreserved = currentPlanRiskAudit
+            && findFailedGuardedStepRequiringCorrectiveDecision(this.store, task, currentPlanRiskAudit) !== null;
         // Validate every delegated transition before the first write so a narrow grant cannot
         // leave the composite operation half-applied.
         this.delegatedAuthorization(identity.projectId, delegationGrantId, 'task.execution_authorize', actor, task);
@@ -835,7 +872,7 @@ export class WorkflowService {
             throw new WorkflowError('TRANSITION_BLOCKED', 'Task context is already current; refresh is a no-op.');
         }
         let refreshedTask = this.rebindTaskKnowledge(repository, taskId, task.revision);
-        if (currentPlanRiskAudit) {
+        if (currentPlanRiskAudit && !breakerPlanRiskAuditWillBePreserved) {
             appendReboundPlanRiskAudit(this.store, task, refreshedTask, currentPlanRiskAudit, this.now());
         }
         transitions.push('task knowledge-rebind');
@@ -1117,9 +1154,9 @@ export class WorkflowService {
                 currentAuditPresent: Boolean(planRiskAudit),
             });
         }
-        if (planRiskAudit && isStepReviewRequired(task, stepId, planRiskAudit.reviewRequiredStepIds)) {
-            assertGuardedRemediationAttemptAllowed(this.store, task, stepId, planRiskAudit);
-        }
+        const remediationGate = planRiskAudit && isStepReviewRequired(task, stepId, planRiskAudit.reviewRequiredStepIds)
+            ? assertGuardedRemediationAttemptAllowed(this.store, task, stepId, planRiskAudit)
+            : null;
         const dirty = changedFiles(context.identity.repositoryRoot);
         if (step.status === 'planned' && dirty.length > 0) {
             throw new WorkflowError('GIT_PRECONDITION_FAILED', `${stepId} must start from a clean checkout.`, {
@@ -1222,17 +1259,31 @@ export class WorkflowService {
                 stepId,
                 expectedRevision: saved.revision,
                 writerToken: lease.token,
+                ...(remediationGate
+                    ? {
+                        remediation: {
+                            attemptOrdinal: remediationGate.nextAttemptOrdinal,
+                            mode: remediationGate.mode,
+                            correctiveDecisionEventId: remediationGate.correctiveDecision?.eventId ?? null,
+                        },
+                    }
+                    : {}),
                 knowledgeMap: knowledgeSummary(knowledgeMap),
                 knowledgeSources: selectKnowledgeSources(knowledgeMap, 'worker', task.knowledgeTargets.map((target) => target.path)),
             },
         };
     }
-    taskContext(repository, taskId, role) {
+    taskContext(repository, taskId, role, allowHistoricalStrictReview = false) {
         const { identity } = this.context(repository);
         const task = this.store.readTask(identity.projectId, taskId);
+        const historicalStrictReview = allowHistoricalStrictReview
+            && role === 'independent-reviewer'
+            && task.steps.some((step) => step.status === 'in_progress' && step.evidence !== null);
         const knowledgeMap = task.knowledgeMapRevision === null
             ? this.requireActiveKnowledgeMap(identity.repositoryRoot, identity.projectId)
-            : this.assertTaskKnowledgeBinding(identity.repositoryRoot, task);
+            : historicalStrictReview
+                ? this.strictReviewKnowledgeMap(identity.repositoryRoot, task)
+                : this.assertTaskKnowledgeBinding(identity.repositoryRoot, task);
         const root = this.store.taskRoot(task.projectId, task.id);
         const planRiskAudit = task.planHash && !['planning', 'merged', 'cancelled'].includes(task.status)
             ? readCurrentPlanRiskAudit(this.store, task)
@@ -1387,7 +1438,161 @@ export class WorkflowService {
         });
         return this.store.writeTask({ ...task, status: 'in_progress', steps, blockReason: null }, expectedRevision);
     }
+    alpha6C1StrictReviewRescuePreflight(repository) {
+        const context = this.context(repository);
+        const dependency = inspectLocalDependency(context.identity.repositoryRoot);
+        const tasks = context.store.listTasks(context.identity.projectId);
+        const dirty = changedFiles(context.identity.repositoryRoot);
+        const currentHead = headCommit(context.identity.repositoryRoot);
+        const now = this.now().getTime();
+        const candidates = [];
+        const malformedCandidates = [];
+        for (const task of tasks) {
+            if (task.status !== 'in_progress')
+                continue;
+            const planRiskAudit = task.planHash ? readCurrentPlanRiskAudit(this.store, task) : null;
+            if (!planRiskAudit)
+                continue;
+            for (const step of task.steps) {
+                if (step.status !== 'in_progress' || !step.evidence)
+                    continue;
+                if (!isStepReviewRequired(task, step.id, planRiskAudit.reviewRequiredStepIds))
+                    continue;
+                try {
+                    const cycle = buildCurrentStrictStepReviewCycle(this.store, task, step.id);
+                    if (cycle.resolution !== 'pending')
+                        continue;
+                    validateTaskHistory(context.identity.repositoryRoot, task);
+                    const storedKnowledgeMap = this.store.readKnowledgeMap(context.identity.projectId);
+                    const knowledgeMap = inspectKnowledgeMap(storedKnowledgeMap, scanProjectKnowledge(context.identity.repositoryRoot, context.identity.projectId, this.now()));
+                    const knowledgeBindingStale = knowledgeMap.status !== 'active'
+                        || task.knowledgeMapRevision !== knowledgeMap.revision
+                        || task.knowledgeMapHash !== hashKnowledgeMap(knowledgeMap);
+                    const posture = readTaskC1Posture(this.store, task);
+                    const lease = context.locks.inspect(task.id);
+                    const claimant = posture.state === 'claimed' ? posture.claimant : null;
+                    const tokenBound = posture.state === 'claimed'
+                        && lease !== null
+                        && posture.writerLeaseTokenHash !== null
+                        && posture.writerLeaseTokenHash === sha256Hex(lease.token);
+                    candidates.push({
+                        taskId: task.id,
+                        taskRevision: task.revision,
+                        stepId: step.id,
+                        completionCommit: step.evidence.commitSha,
+                        currentHead,
+                        knowledgeBindingStale,
+                        claimant,
+                        handoffExpiresAt: posture.state === 'claimed' ? posture.latestEvent.expiresAt : null,
+                        lease: lease
+                            ? {
+                                entityId: lease.entityId,
+                                owner: lease.owner,
+                                pid: lease.pid,
+                                hostname: lease.hostname,
+                                acquiredAt: lease.acquiredAt,
+                                heartbeatAt: lease.heartbeatAt,
+                                expiresAt: lease.expiresAt,
+                                stale: Date.parse(lease.expiresAt) <= now,
+                                tokenBound,
+                            }
+                            : null,
+                    });
+                }
+                catch (error) {
+                    malformedCandidates.push(error instanceof Error ? error.message : String(error));
+                }
+            }
+        }
+        const candidate = candidates.length === 1 ? candidates[0] : null;
+        const unrelatedLeases = context.locks.list().filter((lease) => lease.entityId !== candidate?.taskId);
+        const blockers = [
+            ...(dependency.declared !== '2.0.0-alpha.6'
+                ? ['Project package.json must declare codex-workflow-v2 exactly at 2.0.0-alpha.6.']
+                : []),
+            ...(dirty.length > 0 ? ['Repository checkout is not clean.'] : []),
+            ...(candidates.length !== 1
+                ? [`Expected exactly one pending alpha.6 strict review; found ${candidates.length}.`]
+                : []),
+            ...(candidate && candidate.currentHead !== candidate.completionCommit
+                ? ['HEAD does not match the pending strict review completion commit.']
+                : []),
+            ...(candidate && !candidate.knowledgeBindingStale
+                ? ['The pending strict review is not blocked by a stale Project Knowledge Map.']
+                : []),
+            ...(candidate && candidate.claimant === null
+                ? ['The rescue Task does not have an active claimed C1 posture.']
+                : []),
+            ...(candidate && candidate.lease === null
+                ? ['The claimed C1 rescue Task has no bound writer lease.']
+                : []),
+            ...(candidate?.lease && candidate.claimant !== candidate.lease.owner
+                ? ['The writer lease owner does not match the active C1 claimant.']
+                : []),
+            ...(candidate?.lease && !candidate.lease.tokenBound
+                ? ['The writer lease token does not match the active C1 binding.']
+                : []),
+            ...(unrelatedLeases.length > 0
+                ? ['A writer lease exists outside the exact rescue Task.']
+                : []),
+            ...malformedCandidates.map((message) => `Pending strict review state is invalid: ${message}`),
+        ];
+        const eligible = blockers.length === 0 && candidate !== null && candidate.claimant !== null;
+        return {
+            eligible,
+            mutationFree: true,
+            runnerPackageVersion: PACKAGE_VERSION,
+            requiredProjectPackageVersion: '2.0.0-alpha.6',
+            declaredProjectPackageVersion: dependency.declared,
+            projectId: context.identity.projectId,
+            repositoryRoot: context.identity.repositoryRoot,
+            clean: dirty.length === 0,
+            candidate,
+            blockers,
+            requiredAction: eligible && candidate && candidate.claimant
+                ? {
+                    action: 'update rescue-review',
+                    taskId: candidate.taskId,
+                    stepId: candidate.stepId,
+                    expectedRevision: candidate.taskRevision,
+                    actor: candidate.claimant,
+                    requiresBoundWriterToken: true,
+                }
+                : null,
+        };
+    }
+    alpha6C1StrictReviewRescue(repository, taskId, stepId, expectedRevision, actor, writerToken, runner) {
+        const preflight = this.alpha6C1StrictReviewRescuePreflight(repository);
+        if (!preflight.eligible || !preflight.candidate || !preflight.requiredAction) {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Alpha.6 C1 strict-review rescue preflight is not eligible.', {
+                blockers: preflight.blockers,
+            });
+        }
+        const candidate = preflight.candidate;
+        if (candidate.taskId !== taskId
+            || candidate.stepId !== stepId
+            || candidate.taskRevision !== expectedRevision) {
+            throw new WorkflowError('STATE_CONFLICT', 'Rescue command does not match the exact preflight candidate.', {
+                expected: preflight.requiredAction,
+                actual: { taskId, stepId, expectedRevision, actor },
+            });
+        }
+        if (candidate.claimant !== actor.trim()) {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Rescue actor does not match the active C1 claimant.', {
+                expectedActor: candidate.claimant,
+                actualActor: actor.trim(),
+            });
+        }
+        const lease = this.context(repository).locks.inspect(taskId);
+        if (!lease || lease.token !== writerToken) {
+            throw new WorkflowError('LOCK_TOKEN_INVALID', `Writer token does not own ${taskId}`);
+        }
+        return this.reviewStepWithKnowledgePolicy(repository, taskId, stepId, expectedRevision, runner, actor, writerToken, true);
+    }
     reviewStep(repository, taskId, stepId, expectedRevision, runner, actor, writerToken = null) {
+        return this.reviewStepWithKnowledgePolicy(repository, taskId, stepId, expectedRevision, runner, actor, writerToken, false);
+    }
+    reviewStepWithKnowledgePolicy(repository, taskId, stepId, expectedRevision, runner, actor, writerToken, allowStaleKnowledgeBinding) {
         const context = this.context(repository);
         this.readCurrentAdoptionPostureStrict(context.identity.projectId);
         const task = this.store.readTask(context.identity.projectId, taskId);
@@ -1398,7 +1603,8 @@ export class WorkflowService {
             throw new WorkflowError('TRANSITION_BLOCKED', `Strict Step Review cannot run while task ${taskId} is ${task.status}.`);
         }
         assertTaskBranch(context.identity.repositoryRoot, task);
-        this.assertTaskKnowledgeBinding(context.identity.repositoryRoot, task);
+        if (!allowStaleKnowledgeBinding)
+            this.assertTaskKnowledgeBinding(context.identity.repositoryRoot, task);
         const planRiskAudit = readCurrentPlanRiskAudit(this.store, task);
         if (!planRiskAudit || !isStepReviewRequired(task, stepId, planRiskAudit.reviewRequiredStepIds)) {
             throw new WorkflowError('TRANSITION_BLOCKED', `Step ${stepId} is not marked for strict review by the current Plan Risk Audit.`, {
@@ -1459,7 +1665,7 @@ export class WorkflowService {
             return this.store.writeTask(applyStrictStepReviewResolution(task, stepId, currentCycle.resolution), expectedRevision);
         }
         ensurePendingStrictStepReview(this.store, task, stepId, this.now());
-        const envelope = this.taskContext(repository, taskId, 'independent-reviewer');
+        const envelope = this.taskContext(repository, taskId, 'independent-reviewer', allowStaleKnowledgeBinding);
         const launch = launchStrictStepReviewer(context.identity.repositoryRoot, task, this.store.taskRoot(task.projectId, task.id), envelope, stepId, step.evidence, runner);
         const recorded = recordStrictStepReview(this.store, task, stepId, {
             review: launch.review,
@@ -1567,7 +1773,7 @@ export class WorkflowService {
         assertExpectedRevision(task, expectedRevision);
         this.proveOptionalWriterLeaseToken(this.context(repository), taskId, writerToken);
         this.assertTaskMutationAllowedByHandoff(task, actor ?? null, writerToken);
-        if (task.status !== 'needs_fix' && task.status !== 'blocked') {
+        if (!['needs_fix', 'awaiting_execution_authorization', 'ready'].includes(task.status)) {
             throw new WorkflowError('TRANSITION_BLOCKED', `Task ${taskId} cannot record a corrective decision while ${task.status}.`);
         }
         const planRiskAudit = readCurrentPlanRiskAudit(this.store, task);
@@ -1590,25 +1796,45 @@ export class WorkflowService {
                 stepId,
             });
         }
-        if (task.status === 'needs_fix') {
-            if (step.status !== 'failed') {
-                throw new WorkflowError('TRANSITION_BLOCKED', `Corrective decision for ${stepId} requires a currently failed guarded Step while task ${taskId} is needs_fix.`, {
-                    taskId,
-                    stepId,
-                    stepStatus: step.status,
-                });
-            }
+        if (step.status !== 'failed') {
+            throw new WorkflowError('TRANSITION_BLOCKED', `Corrective decision for ${stepId} requires a currently failed guarded Step.`, {
+                taskId,
+                stepId,
+                taskStatus: task.status,
+                stepStatus: step.status,
+            });
         }
-        else {
-            const currentCycle = buildCurrentStrictStepReviewCycle(this.store, task, stepId);
-            if (step.status !== 'in_progress' || !step.evidence || currentCycle.resolution !== 'unverified') {
-                throw new WorkflowError('TRANSITION_BLOCKED', `Corrective decision for ${stepId} requires a blocked unverified guarded Step with current evidence.`, {
-                    taskId,
-                    stepId,
-                    stepStatus: step.status,
-                    resolution: currentCycle.resolution,
-                });
-            }
+        const remediationEvents = readRemediationEvents(this.store, task).filter((event) => event.stepId === stepId);
+        if (remediationEvents.length >= 3) {
+            throw new WorkflowError('TRANSITION_BLOCKED', `Guarded Step ${stepId} reached the hard stop after its third failed remediation review.`, {
+                taskId,
+                stepId,
+                failedAttemptCount: remediationEvents.length,
+                allowedDecisions: ['split-required', 'stop-escalate'],
+            });
+        }
+        if (remediationEvents.length !== 2) {
+            throw new WorkflowError('TRANSITION_BLOCKED', `Corrective decision for ${stepId} requires exactly two guarded failures.`, {
+                taskId,
+                stepId,
+                attemptCount: remediationEvents.length,
+            });
+        }
+        const existingDecision = readCorrectiveDecisionEvents(this.store, task)
+            .find((event) => event.stepId === stepId && event.triggeringAttemptCount === 3) ?? null;
+        if (existingDecision) {
+            throw new WorkflowError('STATE_CONFLICT', `Corrective decision for ${stepId} already exists.`, {
+                taskId,
+                stepId,
+                decisionEventId: existingDecision.eventId,
+            });
+        }
+        const root = this.store.taskRoot(task.projectId, task.id);
+        if (this.store.hashArtifact(root, 'brief.md') !== task.briefHash || this.store.hashArtifact(root, 'plan.md') !== task.planHash) {
+            throw new WorkflowError('STATE_CORRUPT', 'Corrective decision requires unchanged Brief and exact current Plan bindings.', {
+                taskId,
+                stepId,
+            });
         }
         assertCorrectiveAuditorIndependence(this.store, task, stepId, correctiveAudit.auditor);
         return appendCorrectiveDecisionEvent(this.store, task, stepId, correctiveAudit, planRiskAudit, task.planHash, this.now());
@@ -1845,6 +2071,243 @@ export class WorkflowService {
             adoption,
         };
     }
+    alpha6CorrectiveRescuePreflight(repository) {
+        const identity = resolveRepositoryIdentity(repository);
+        const locks = new WriterLockManager(this.store.lockRoot(identity.projectId), this.now, { ensureRoot: false });
+        const dependency = inspectLocalDependency(identity.repositoryRoot);
+        const tasks = this.store.listTasks(identity.projectId);
+        const leases = locks.list();
+        const dirty = changedFiles(identity.repositoryRoot);
+        const currentHead = headCommit(identity.repositoryRoot);
+        const candidates = [];
+        const malformed = [];
+        for (const task of tasks) {
+            if (task.revision !== 14 || task.status !== 'ready')
+                continue;
+            const step = task.steps.find((entry) => entry.id === 'STEP-001') ?? null;
+            if (!step || step.status !== 'failed' || !task.planHash)
+                continue;
+            try {
+                const root = this.store.taskRoot(task.projectId, task.id);
+                if (this.store.hashArtifact(root, 'brief.md') !== task.briefHash) {
+                    throw new WorkflowError('STATE_CORRUPT', 'Brief artifact changed after the recovery boundary.');
+                }
+                const discovery = this.store.readDiscovery(task.projectId, task.discoveryId);
+                if (sha256Hex(renderBrief(discovery, task.title)) !== task.briefHash) {
+                    throw new WorkflowError('STATE_CORRUPT', 'Recovery Task Brief no longer matches its immutable Discovery scope.');
+                }
+                if (this.store.hashArtifact(root, 'plan.md') !== task.planHash) {
+                    throw new WorkflowError('STATE_CORRUPT', 'Plan artifact does not match the recovery Task binding.');
+                }
+                const planRiskAudit = readCurrentPlanRiskAudit(this.store, task);
+                if (!planRiskAudit || !planRiskAudit.reviewRequiredStepIds.includes(step.id)) {
+                    throw new WorkflowError('STATE_CORRUPT', 'Recovery Step is not guarded by the exact current Plan Risk Audit.');
+                }
+                const allRemediationEvents = readRemediationEvents(this.store, task);
+                const remediationEvents = allRemediationEvents.filter((event) => event.stepId === step.id);
+                if (allRemediationEvents.length !== 2
+                    || remediationEvents.length !== allRemediationEvents.length
+                    || remediationEvents.some((event, index) => event.attemptOrdinal !== index + 1
+                        || event.mode !== 'ordinary'
+                        || event.failureKind !== 'review-failed'
+                        || event.failureEvidence.reviewEventHash === null
+                        || event.failureEvidence.reviewerAttestationHash === null)) {
+                    throw new WorkflowError('STATE_CORRUPT', 'Recovery requires exactly two ordinary verified strict-review failures.');
+                }
+                const failureIdentities = new Set(remediationEvents.map((event) => [
+                    event.failureEvidence.completionCommit,
+                    event.failureEvidence.reviewEventHash,
+                    event.failureEvidence.reviewerAttestationHash,
+                ].join('\0')));
+                if (failureIdentities.size !== 2) {
+                    throw new WorkflowError('STATE_CORRUPT', 'Recovery strict-review failures are not distinct.');
+                }
+                const attestations = readReviewerAttestations(this.store, task);
+                if (remediationEvents.some((event) => {
+                    const attestation = attestations.find((entry) => entry.eventHash === event.failureEvidence.reviewerAttestationHash);
+                    return !attestation || attestation.isolationResult !== 'verified';
+                })) {
+                    throw new WorkflowError('STATE_CORRUPT', 'Recovery strict-review failures lack verified reviewer isolation.');
+                }
+                if (readCorrectiveDecisionEvents(this.store, task).some((event) => event.stepId === step.id)) {
+                    throw new WorkflowError('STATE_CORRUPT', 'Recovery Task already has a corrective decision.');
+                }
+                const posture = readTaskC1Posture(this.store, task);
+                if (posture.state !== 'claimed' || !posture.writerLeaseTokenHash) {
+                    throw new WorkflowError('STATE_CORRUPT', 'Recovery Task requires claimed C1 with a bound writer lease token.');
+                }
+                const lease = leases.find((entry) => entry.entityId === task.id) ?? null;
+                if (!lease
+                    || lease.owner !== posture.claimant
+                    || sha256Hex(lease.token) !== posture.writerLeaseTokenHash) {
+                    throw new WorkflowError('STATE_CORRUPT', 'Recovery lease does not exactly match the C1 claimant/token binding.');
+                }
+                const { token: _secret, ...publicLease } = lease;
+                let milestoneScopeHash = null;
+                if (task.milestoneId) {
+                    const milestone = this.store.readMilestone(task.projectId, task.milestoneId);
+                    const matchingMemberships = milestone.memberships.filter((entry) => entry.taskId === task.id);
+                    if (matchingMemberships.length !== 1 || !milestone.taskIds.includes(task.id)) {
+                        throw new WorkflowError('STATE_CORRUPT', 'Recovery Task no longer matches exact Milestone membership scope.');
+                    }
+                    milestoneScopeHash = milestoneScopeDigest(milestone);
+                }
+                candidates.push({
+                    taskId: task.id,
+                    taskRevision: 14,
+                    taskStatus: 'ready',
+                    stepId: 'STEP-001',
+                    stepStatus: 'failed',
+                    attemptCount: 2,
+                    briefHash: task.briefHash,
+                    planHash: task.planHash,
+                    claimant: posture.claimant,
+                    lease: {
+                        ...publicLease,
+                        stale: Date.parse(lease.expiresAt) <= this.now().getTime(),
+                        tokenBound: true,
+                    },
+                    milestoneScopeHash,
+                });
+            }
+            catch (error) {
+                malformed.push(error instanceof Error ? error.message : String(error));
+            }
+        }
+        const candidate = candidates.length === 1 ? candidates[0] : null;
+        const blockers = [
+            ...(dependency.declared !== '2.0.0-alpha.6'
+                ? ['Project package.json must declare codex-workflow-v2 exactly at 2.0.0-alpha.6.']
+                : []),
+            ...(dirty.length > 0 ? ['Repository checkout is not clean.'] : []),
+            ...(currentHead !== this.alpha6CorrectiveRescueHead
+                ? [`HEAD must exactly equal ${this.alpha6CorrectiveRescueHead}.`]
+                : []),
+            ...(candidates.length !== 1
+                ? [`Expected exactly one alpha.6 corrective recovery candidate; found ${candidates.length}.`]
+                : []),
+            ...(candidate && leases.some((lease) => lease.entityId !== candidate.taskId)
+                ? ['An unrelated writer lease exists outside the recovery Task.']
+                : []),
+            ...malformed.map((message) => `Corrective recovery candidate is invalid: ${message}`),
+        ];
+        return {
+            eligible: blockers.length === 0 && candidate !== null,
+            mutationFree: true,
+            runnerPackageVersion: PACKAGE_VERSION,
+            requiredProjectPackageVersion: '2.0.0-alpha.6',
+            declaredProjectPackageVersion: dependency.declared,
+            requiredHead: this.alpha6CorrectiveRescueHead,
+            currentHead,
+            clean: dirty.length === 0,
+            candidate,
+            blockers,
+        };
+    }
+    alpha6CorrectiveRescueApply(repository, taskId, expectedRevision, actor, writerToken, plan, decisionAudit, correctivePlanAudit) {
+        const identity = resolveRepositoryIdentity(repository);
+        const locks = new WriterLockManager(this.store.lockRoot(identity.projectId), this.now);
+        const task = this.store.readTask(identity.projectId, taskId);
+        assertExpectedRevision(task, expectedRevision);
+        const posture = readTaskC1Posture(this.store, task);
+        const lease = locks.inspect(taskId);
+        // Authentication is deliberately completed before heartbeat. A wrong actor/token must
+        // not refresh a stale lease or create any observable recovery mutation.
+        if (posture.state !== 'claimed'
+            || actor.trim() !== posture.claimant
+            || !lease
+            || lease.owner !== posture.claimant
+            || lease.token !== writerToken
+            || !posture.writerLeaseTokenHash
+            || sha256Hex(writerToken) !== posture.writerLeaseTokenHash) {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Corrective rescue actor/token does not match the claimed C1 lease binding.', {
+                taskId,
+                actor: actor.trim(),
+                claimant: posture.state === 'claimed' ? posture.claimant : null,
+            });
+        }
+        const preflight = this.alpha6CorrectiveRescuePreflight(repository);
+        if (!preflight.eligible || preflight.candidate?.taskId !== taskId || expectedRevision !== 14) {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Corrective rescue preflight is not eligible for the requested Task.', {
+                taskId,
+                expectedRevision,
+                blockers: preflight.blockers,
+            });
+        }
+        validatePlan(plan);
+        const knowledgeMap = this.assertKnowledgeMapBinding(identity.repositoryRoot, identity.projectId, plan.knowledgeMapRevision, plan.knowledgeMapHash);
+        this.validateKnowledgeTargets(knowledgeMap, plan);
+        if (!sameOrderedStrings(plan.requirements, task.requirements)
+            || !sameOrderedStrings(plan.acceptance, task.acceptance)) {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Corrective rescue Plan must preserve requirements and acceptance exactly.');
+        }
+        assertNonTargetStepsUnchanged(task, plan, 'STEP-001');
+        if (decisionAudit.decision !== 'continue-fix') {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Corrective rescue only supports an independent continue-fix decision.');
+        }
+        assertCorrectiveAuditorIndependence(this.store, task, 'STEP-001', decisionAudit.auditor);
+        if (correctivePlanAudit.auditor.trim() === decisionAudit.auditor.trim()) {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Corrective rescue Plan auditor must be independent from the decision auditor.');
+        }
+        if (!decisionAudit.auditor.trim()
+            || !decisionAudit.summary.trim()
+            || !correctivePlanAudit.auditor.trim()
+            || !correctivePlanAudit.summary.trim()
+            || correctivePlanAudit.decision !== 'continue-fix'
+            || decisionAudit.reviewedFindingIds.length === 0
+            || correctivePlanAudit.reviewedFindingIds.length === 0) {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Corrective rescue audits must independently cover the exact strict-review finding.');
+        }
+        assertCorrectiveAuditorIndependence(this.store, task, 'STEP-001', correctivePlanAudit.auditor);
+        const currentPlanRiskAudit = readCurrentPlanRiskAudit(this.store, task);
+        if (!currentPlanRiskAudit) {
+            throw new WorkflowError('STATE_CORRUPT', 'Corrective rescue requires the exact current Plan Risk Audit.');
+        }
+        const stagedPlan = this.store.stageArtifact(this.store.taskRoot(task.projectId, task.id), 'plan.md', renderPlan(task, plan));
+        if (stagedPlan.hash === task.planHash) {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Corrective rescue requires a changed full corrective Plan.');
+        }
+        const completedIds = task.steps
+            .filter((candidate) => candidate.status === 'completed')
+            .map((candidate) => candidate.id);
+        const previewSteps = plan.steps.map((step) => preserveCompletedStep(task, step) ?? ({
+            ...step,
+            status: dependenciesComplete(step, completedIds) ? 'planned' : 'blocked',
+            evidence: null,
+        }));
+        validatePlanRiskAuditCandidate(this.store, {
+            ...task,
+            status: 'awaiting_execution_authorization',
+            planHash: stagedPlan.hash,
+            planObjective: plan.objective,
+            risks: plan.risks,
+            knowledgeImpact: plan.knowledgeImpact,
+            knowledgeImpactReason: plan.knowledgeImpactReason,
+            knowledgeTargets: plan.knowledgeTargets,
+            knowledgeMapRevision: plan.knowledgeMapRevision,
+            knowledgeMapHash: plan.knowledgeMapHash,
+            graphUse: plan.graphUse,
+            steps: previewSteps,
+        }, currentPlanRiskAudit.audit);
+        const milestoneScopeBefore = task.milestoneId
+            ? milestoneScopeDigest(this.store.readMilestone(task.projectId, task.milestoneId))
+            : null;
+        const refreshedLease = locks.heartbeat(taskId, writerToken);
+        const decision = appendCorrectiveDecisionEvent(this.store, task, 'STEP-001', decisionAudit, currentPlanRiskAudit, task.planHash, this.now());
+        validateGuardedCorrectivePlanAudit(this.store, task, 'STEP-001', decision, correctivePlanAudit);
+        const saved = this.setTaskPlan(repository, taskId, expectedRevision, plan, correctivePlanAudit, null);
+        if (this.store.hashArtifact(this.store.taskRoot(task.projectId, task.id), 'brief.md') !== preflight.candidate.briefHash) {
+            throw new WorkflowError('STATE_CORRUPT', 'Corrective rescue changed the immutable Brief.');
+        }
+        const milestoneScopeAfter = task.milestoneId
+            ? milestoneScopeDigest(this.store.readMilestone(task.projectId, task.milestoneId))
+            : null;
+        if (milestoneScopeAfter !== milestoneScopeBefore) {
+            throw new WorkflowError('STATE_CORRUPT', 'Corrective rescue changed Milestone scope.');
+        }
+        const { token: _secret, ...publicLease } = refreshedLease;
+        return { task: saved, decision, lease: { ...publicLease, tokenRetained: true } };
+    }
     scanKnowledgeMap(repository) {
         const { identity } = this.context(repository);
         const scanned = scanProjectKnowledge(identity.repositoryRoot, identity.projectId, this.now());
@@ -2132,6 +2595,25 @@ export class WorkflowService {
             ? this.delegatedApprovalOptions(projectId, transition, task)
             : [];
         const failedReviewAttempts = countFailedReviewAttempts(this.store.taskRoot(projectId, task.id));
+        const guardedFailedSteps = planRiskAudit
+            ? task.steps.filter((step) => step.status === 'failed' && planRiskAudit.reviewRequiredStepIds.includes(step.id))
+            : [];
+        const breakerSteps = guardedFailedSteps.map((step) => ({
+            step,
+            attemptCount: readRemediationEvents(this.store, task).filter((event) => event.stepId === step.id).length,
+        })).filter((entry) => entry.attemptCount >= 2);
+        if (breakerSteps.length > 1) {
+            throw new WorkflowError('STATE_CORRUPT', 'Multiple guarded failed Steps simultaneously carry remediation-breaker posture.', {
+                taskId: task.id,
+                stepIds: breakerSteps.map((entry) => entry.step.id),
+            });
+        }
+        const breakerStep = breakerSteps[0] ?? null;
+        const guardedCorrectiveGate = breakerStep && breakerStep.attemptCount === 2 && planRiskAudit
+            ? findFailedGuardedStepRequiringCorrectiveDecision(this.store, task, planRiskAudit)
+            : null;
+        const correctivePlanRequired = guardedCorrectiveGate?.correctiveDecision?.decision === 'continue-fix'
+            && !hasCorrectivePlanAuditBinding(this.store, task, guardedCorrectiveGate.correctiveDecision);
         const next = nextForTask(task);
         const handoffPosture = readTaskC1Posture(this.store, task);
         const strictStepReviewStep = planRiskAudit
@@ -2204,7 +2686,53 @@ export class WorkflowService {
                     },
                 }
                 : {}),
-            ...(delegatedApprovalOptions.length > 0 ? { delegatedApprovalOptions } : {}),
+            ...(guardedCorrectiveGate
+                ? guardedCorrectiveGate.correctiveDecision === null
+                    ? {
+                        action: 'task corrective-decision',
+                        stepId: guardedCorrectiveGate.stepId,
+                        correctiveDecisionGate: {
+                            attemptCount: guardedCorrectiveGate.attemptCount,
+                            auditorMustDifferFromLatestStrictReviewer: true,
+                            allowedDecision: 'continue-fix',
+                            escalationDecisions: ['replan-required', 'split-required', 'stop-escalate'],
+                            humanApprovalRequired: false,
+                        },
+                    }
+                    : correctivePlanRequired
+                        ? {
+                            action: 'task plan-set with independent corrective audit',
+                            stepId: guardedCorrectiveGate.stepId,
+                            correctivePlanGate: {
+                                attemptCount: guardedCorrectiveGate.attemptCount,
+                                decisionEventId: guardedCorrectiveGate.correctiveDecision.eventId,
+                                fullPlanRequired: true,
+                                auditFileRequired: true,
+                                auditorMustDifferFromDecisionAuditor: true,
+                                auditorMustDifferFromLatestStrictReviewer: true,
+                                allowedDecision: 'continue-fix',
+                            },
+                        }
+                        : guardedCorrectiveGate.correctiveDecision.decision !== 'continue-fix'
+                            ? {
+                                action: 'task corrective-hard-stop',
+                                stepId: guardedCorrectiveGate.stepId,
+                                correctiveDecision: guardedCorrectiveGate.correctiveDecision.decision,
+                            }
+                            : {}
+                : {}),
+            ...(breakerStep?.attemptCount && breakerStep.attemptCount >= 3
+                ? {
+                    action: 'task corrective-hard-stop',
+                    stepId: breakerStep.step.id,
+                    correctiveHardStop: {
+                        failedAttemptCount: breakerStep.attemptCount,
+                        continueFixAllowed: false,
+                        allowedDecisions: ['split-required', 'stop-escalate'],
+                    },
+                }
+                : {}),
+            ...(delegatedApprovalOptions.length > 0 && !breakerStep ? { delegatedApprovalOptions } : {}),
         };
         if (handoffPosture.state === 'pending') {
             return {
@@ -2371,6 +2899,28 @@ export class WorkflowService {
         }
         return inspected;
     }
+    strictReviewKnowledgeMap(repositoryRoot, task) {
+        const stored = this.store.readKnowledgeMap(task.projectId);
+        const inspected = inspectKnowledgeMap(stored, scanProjectKnowledge(repositoryRoot, task.projectId, this.now()));
+        if (inspected.status === 'active' && inspected.approval)
+            return inspected;
+        const storedHash = hashKnowledgeMap(stored);
+        if (stored.status === 'active'
+            && stored.approval
+            && task.knowledgeMapRevision === stored.revision
+            && task.knowledgeMapHash === storedHash
+            && stored.approval.mapHash === storedHash) {
+            return stored;
+        }
+        throw new WorkflowError('TRANSITION_BLOCKED', 'Strict Step Review has neither a current active Knowledge Map nor its exact historical Task binding.', {
+            taskId: task.id,
+            inspectedStatus: inspected.status,
+            taskKnowledgeMapRevision: task.knowledgeMapRevision,
+            storedKnowledgeMapRevision: stored.revision,
+            taskKnowledgeMapHash: task.knowledgeMapHash,
+            storedKnowledgeMapHash: storedHash,
+        });
+    }
     inspectAdoptionPreparation(identity, tasks, milestones) {
         const locks = new WriterLockManager(this.store.lockRoot(identity.projectId), this.now);
         const currentPosture = readCurrentAdoptionPosture(this.store, identity.projectId);
@@ -2698,6 +3248,67 @@ function validateCorrectivePlanAudit(task, audit, failedReviewAttempts) {
         throw new WorkflowError('TRANSITION_BLOCKED', `Corrective Auditor decision ${audit.decision} requires coordinator/user redirection before implementation continues.`, { decision: audit.decision, summary: audit.summary });
     }
 }
+function validateGuardedCorrectivePlanAudit(store, task, stepId, decision, audit) {
+    if (!audit) {
+        throw new WorkflowError('TRANSITION_BLOCKED', `Guarded Step ${stepId} requires a full corrective Plan with an independent corrective audit.`, {
+            taskId: task.id,
+            stepId,
+            decisionEventId: decision.eventId,
+            requiredAction: 'Pass the full Plan and --corrective-audit-file to task plan-set.',
+        });
+    }
+    if (audit.decision !== 'continue-fix' || !audit.auditor.trim() || !audit.summary.trim()) {
+        throw new WorkflowError('INVALID_ARGUMENT', 'Corrective Plan audit must independently approve continue-fix with auditor and summary.');
+    }
+    if (audit.auditor.trim() === decision.auditor.trim()) {
+        throw new WorkflowError('TRANSITION_BLOCKED', 'Corrective Plan auditor must be distinct from the corrective-decision auditor.', {
+            taskId: task.id,
+            stepId,
+            decisionAuditor: decision.auditor,
+            planAuditor: audit.auditor.trim(),
+        });
+    }
+    assertCorrectiveAuditorIndependence(store, task, stepId, audit.auditor);
+    const reviewed = new Set(audit.reviewedFindingIds);
+    if (reviewed.size !== audit.reviewedFindingIds.length || audit.reviewedFindingIds.some((id) => !id.trim())) {
+        throw new WorkflowError('INVALID_ARGUMENT', 'Corrective Plan audit finding IDs must be non-empty and unique.');
+    }
+    const missing = decision.coveredFindingIds.filter((id) => !reviewed.has(id));
+    if (missing.length > 0) {
+        throw new WorkflowError('TRANSITION_BLOCKED', 'Corrective Plan audit does not cover every finding in the corrective decision.', {
+            taskId: task.id,
+            stepId,
+            missingFindingIds: missing,
+        });
+    }
+}
+function sameOrderedStrings(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function assertNonTargetStepsUnchanged(task, plan, targetStepId) {
+    const stripRuntime = (step) => stripStepRuntime(step);
+    const previous = task.steps.filter((step) => step.id !== targetStepId).map(stripRuntime);
+    const replacement = plan.steps.filter((step) => step.id !== targetStepId);
+    if (JSON.stringify(previous) !== JSON.stringify(replacement)) {
+        throw new WorkflowError('TRANSITION_BLOCKED', 'Corrective Plan must preserve every non-target Step exactly.', {
+            taskId: task.id,
+            targetStepId,
+        });
+    }
+}
+function milestoneScopeDigest(milestone) {
+    return sha256Hex(canonicalJsonStringify({
+        id: milestone.id,
+        outcome: milestone.outcome,
+        successSignal: milestone.successSignal,
+        acceptance: milestone.acceptance,
+        checks: milestone.checks,
+        taskIds: milestone.taskIds,
+        memberships: milestone.memberships,
+        membershipRevision: milestone.membershipRevision,
+        planHash: milestone.planHash,
+    }));
+}
 function appendCorrectivePlanAudit(taskRoot, previous, saved, failedReviewAttempts, audit, now) {
     appendFileSync(path.join(taskRoot, 'corrective-plan-audits.jsonl'), `${JSON.stringify({
         recordedAt: now.toISOString(),