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

package/dist/src/workflow.js

@@ -3,18 +3,19 @@ import { createHash } from 'node:crypto';
 import path from 'node:path';
 import { PROTOCOL_VERSION, STATE_SCHEMA_VERSION, } from './contracts.js';
 import { renderBrief, renderPlan, renderResult } from './artifacts.js';
-import { assertDelegationCanAuthorize, delegationCanAuthorize, hashDelegationPolicy, prepareDelegationGrantGate, } from './delegation.js';
+import { assertDelegationCanAuthorize, hashDelegationPolicy, prepareDelegationGrantGate, } from './delegation.js';
 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 { inspectLocalDependency } from './diagnostics.js';
+import { appendTaskClaim, appendTaskHandback, appendTaskHandoff, assertTaskMutationAllowedByC1, defaultTaskWorkerActor, 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 { appendCorrectivePlanAuditRecord, appendCorrectiveDecisionEvent, appendRemediationEvent, assertCorrectiveAuditorIndependence, assertGuardedRemediationAttemptAllowed, findFailedGuardedStepRequiringCorrectiveDecision, hasCorrectivePlanAuditBinding, readCorrectiveDecisionEvents, readRemediationEvents, } from './alpha6/remediation.js';
+import { appendCorrectiveDecisionEvent, appendRemediationEvent, assertCorrectiveAuditorIndependence, assertGuardedRemediationAttemptAllowed, defaultCorrectiveAuditorActor, findCurrentGuardedRemediationPosture, findFailedGuardedStepRequiringCorrectiveDecision, readGuardedRemediationPostureForStep, readCorrectiveDecisionEvents, readRemediationEvents, } from './alpha6/remediation.js';
 import { applyMilestoneScopeChangeTransaction, assertMilestoneMembershipIntegrity, assertMilestoneScopeChangeStatusAllowed, normalizeMilestonePlan, prepareMilestoneScopeChangeCandidate, readMilestoneForScopeChange, readMilestoneWithIntegrity, } from './alpha6/milestone.js';
-import { buildCurrentStrictStepReviewCycle, ensurePendingStrictStepReview, isStepReviewRequired, recordStrictStepReview, readReviewerAttestations, } from './alpha6/review.js';
+import { buildCurrentStrictStepReviewCycle, ensurePendingStrictStepReview, isStepReviewRequired, recordStrictStepReview, } from './alpha6/review.js';
+import { applyMilestoneAutonomyContract, assertAutonomousPlanEvolution, prepareMilestoneAutonomyContract, readMilestoneAutonomyEvents, requireActiveMilestoneAutonomy, } from './alpha7/autonomy.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';
@@ -24,15 +25,12 @@ 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;
-    alpha6CorrectiveRescueHead;
-    constructor(store = new FileStateStore(), now = () => new Date(), alpha6CorrectiveRescueHead = ALPHA6_CORRECTIVE_RESCUE_HEAD) {
+    constructor(store = new FileStateStore(), now = () => new Date()) {
         this.store = store;
         this.now = now;
-        this.alpha6CorrectiveRescueHead = alpha6CorrectiveRescueHead;
     }
     context(repository) {
         const identity = resolveRepositoryIdentity(repository);
@@ -186,7 +184,12 @@ export class WorkflowService {
         if (!title.trim())
             throw new WorkflowError('INVALID_ARGUMENT', 'Task title is required.');
         if (milestoneId) {
-            const milestone = this.readMilestoneCurrent(identity.projectId, milestoneId);
+            // A Milestone is assembled from independently materialized Task discoveries. During
+            // that bounded assembly window the reverse-membership set is intentionally incomplete;
+            // execution remains unavailable until one complete initial Milestone Plan classifies
+            // every linked Task. The scope-change reader preserves every other integrity check while
+            // allowing exactly that repairable reverse gap.
+            const milestone = this.readMilestoneScopeChangeCurrent(identity.projectId, milestoneId);
             if (milestone.status === 'accepted' || milestone.status === 'cancelled') {
                 throw new WorkflowError('TRANSITION_BLOCKED', `Milestone ${milestoneId} is ${milestone.status}.`);
             }
@@ -405,6 +408,64 @@ export class WorkflowService {
             readTask: (taskId) => this.store.readTask(identity.projectId, taskId),
         });
     }
+    prepareMilestoneAutonomy(repository, milestoneId, expectedRevision, principal, delegate, expiresAt) {
+        const { identity } = this.context(repository);
+        const milestone = this.readMilestoneCurrent(identity.projectId, milestoneId);
+        assertExpectedRevision(milestone, expectedRevision);
+        return prepareMilestoneAutonomyContract({
+            projectId: identity.projectId,
+            milestone,
+            principal,
+            delegate,
+            expiresAt,
+            now: this.now(),
+        });
+    }
+    grantMilestoneAutonomy(repository, milestoneId, expectedRevision, principal, delegate, expiresAt, confirmationCode) {
+        const { identity } = this.context(repository);
+        const milestone = this.readMilestoneCurrent(identity.projectId, milestoneId);
+        assertExpectedRevision(milestone, expectedRevision);
+        return applyMilestoneAutonomyContract({
+            store: this.store,
+            projectId: identity.projectId,
+            milestone,
+            principal,
+            delegate,
+            expiresAt,
+            confirmationCode,
+            now: this.now(),
+        });
+    }
+    evolveMilestonePlanAutonomously(repository, milestoneId, expectedRevision, plan, actor) {
+        const { identity } = this.context(repository);
+        const milestone = this.readMilestoneScopeChangeCurrent(identity.projectId, milestoneId);
+        assertExpectedRevision(milestone, expectedRevision);
+        assertMilestoneScopeChangeStatusAllowed(milestone);
+        const autonomy = requireActiveMilestoneAutonomy({
+            store: this.store,
+            projectId: identity.projectId,
+            milestone,
+            actor,
+            now: this.now(),
+        });
+        validateMilestonePlan(plan);
+        assertAutonomousPlanEvolution(milestone, plan, autonomy.contract);
+        const prepared = prepareMilestoneScopeChangeCandidate({
+            milestone,
+            plan,
+            readTask: (taskId) => this.store.readTask(identity.projectId, taskId),
+            actor,
+            autonomyContractEventHash: autonomy.contract.eventHash,
+        });
+        return applyMilestoneScopeChangeTransaction({
+            store: this.store,
+            milestone,
+            expectedRevision,
+            prepared,
+            now: this.now(),
+            readTask: (taskId) => this.store.readTask(identity.projectId, taskId),
+        });
+    }
     authorizeMilestone(repository, milestoneId, expectedRevision, actor, reason = '', delegationGrantId = null) {
         const { identity } = this.context(repository);
         const milestone = this.readMilestoneCurrent(identity.projectId, milestoneId);
@@ -568,13 +629,14 @@ export class WorkflowService {
         this.validateKnowledgeTargets(knowledgeMap, plan);
         const task = this.store.readTask(identity.projectId, taskId);
         assertExpectedRevision(task, expectedRevision);
-        if (!['planning', 'awaiting_execution_authorization', 'ready', 'needs_fix', 'blocked'].includes(task.status)) {
+        if (!['planning', 'awaiting_execution_authorization', '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) {
@@ -595,22 +657,33 @@ export class WorkflowService {
                 requiredAction: 'Resolve the blocked strict review or record a replan-required corrective decision first.',
             });
         }
-        const currentPlanRiskAudit = task.planHash ? readCurrentPlanRiskAudit(this.store, task) : null;
+        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 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 = ['needs_fix', 'awaiting_execution_authorization', 'ready'].includes(task.status)
-            && currentPlanRiskAudit
+        const guardedRemediationGate = task.status === 'needs_fix' && currentPlanRiskAudit
             ? findFailedGuardedStepRequiringCorrectiveDecision(this.store, task, currentPlanRiskAudit)
             : null;
-        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.`, {
+        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.`, {
                 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'],
             });
@@ -622,57 +695,25 @@ export class WorkflowService {
                 requiredAction: 'Retry task plan-set without corrective-audit input; the recorded replan-required decision is the authorization for this recovery path.',
             });
         }
-        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.`, {
+        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.`, {
                 taskId: task.id,
                 stepId: guardedRemediationGate.stepId,
-                decisionEventId: guardedRemediationGate.correctiveDecision.eventId,
+                decision: correctiveAudit?.decision ?? null,
             });
         }
-        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 requirement of task.requirements) {
+            if (!plan.requirements.includes(requirement)) {
+                throw new WorkflowError('TRANSITION_BLOCKED', `Plan omits Task requirement ${requirement}.`);
             }
         }
-        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}.`);
-                }
+        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);
@@ -702,8 +743,9 @@ export class WorkflowService {
                 stepId: guardedRemediationGate.stepId,
             });
         }
-        if (guardedContinueFixDecision) {
-            assertNonTargetStepsUnchanged(task, plan, 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());
         }
         const candidate = {
             ...task,
@@ -726,16 +768,12 @@ export class WorkflowService {
             evidenceHash: null,
             blockReason: null,
         };
-        const effectivePlanRiskAudit = planRiskAudit ?? (guardedContinueFixDecision ? currentPlanRiskAudit?.audit ?? null : null);
-        if (effectivePlanRiskAudit)
-            validatePlanRiskAuditCandidate(this.store, candidate, effectivePlanRiskAudit);
+        if (planRiskAudit)
+            validatePlanRiskAuditCandidate(this.store, candidate, planRiskAudit);
         const saved = this.store.writeTask(candidate, expectedRevision);
         this.store.publishArtifact(stagedPlan);
-        if (effectivePlanRiskAudit)
-            appendCurrentPlanRiskAudit(this.store, saved, effectivePlanRiskAudit, this.now());
-        if (guardedContinueFixDecision && correctiveAudit) {
-            appendCorrectivePlanAuditRecord(this.store, task, saved, guardedRemediationGate.stepId, guardedContinueFixDecision, correctiveAudit, this.now());
-        }
+        if (planRiskAudit)
+            appendCurrentPlanRiskAudit(this.store, saved, planRiskAudit, 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());
         }
@@ -761,11 +799,6 @@ 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 &&
@@ -825,9 +858,6 @@ 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) {
@@ -849,21 +879,29 @@ 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;
+        const currentPlanArtifactHash = task.planHash
+            ? this.store.hashArtifact(this.store.taskRoot(identity.projectId, task.id), 'plan.md')
+            : null;
+        const refreshAssessment = assessDelegatedKnowledgeRefresh(currentMap, inspectedMap, task, currentPlanArtifactHash);
         // 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);
         let knowledgeMap = currentMap;
         if (inspectedMap.status !== 'active' || !inspectedMap.approval) {
-            if (currentMap.status !== 'active' || !currentMap.approval || inspectedMap.status !== 'stale') {
-                throw new WorkflowError('TRANSITION_BLOCKED', 'Automatic Task context refresh requires a previously approved map with content-only drift.', { currentStatus: currentMap.status, inspectedStatus: inspectedMap.status });
+            if (currentMap.status !== 'active' || !currentMap.approval) {
+                throw new WorkflowError('TRANSITION_BLOCKED', 'Automatic Task context refresh requires a previously approved map with safe delegated drift.', { currentStatus: currentMap.status, inspectedStatus: inspectedMap.status });
+            }
+            assertDelegatedKnowledgeRefresh(refreshAssessment);
+            if (inspectedMap.status !== 'stale') {
+                throw new WorkflowError('TRANSITION_BLOCKED', 'Safe delegated Knowledge drift must reconcile to a stale candidate before approval.', { currentStatus: currentMap.status, inspectedStatus: inspectedMap.status });
+            }
+            if (refreshAssessment.mode === 'delegated-plan-bounded-supporting-source') {
+                this.assertPlanBoundedSupportingSourceGrant(identity.projectId, delegationGrantId, actor, task);
             }
-            assertContentOnlyKnowledgeRefresh(currentMap, inspectedMap);
-            this.delegatedAuthorization(identity.projectId, delegationGrantId, 'project_memory.approve', actor, inspectedMap);
+            this.delegatedAuthorization(identity.projectId, delegationGrantId, 'project_memory.approve', actor, inspectedMap, task.id);
             knowledgeMap = this.reconcileKnowledgeMap(repository, currentMap.revision);
             transitions.push('project-memory reconcile');
-            knowledgeMap = this.approveKnowledgeMap(repository, knowledgeMap.revision, [], actor, delegationGrantId);
+            knowledgeMap = this.approveKnowledgeMapForTaskRefresh(repository, knowledgeMap.revision, [], actor, delegationGrantId, task.id);
             transitions.push('project-memory approve');
         }
         const knowledgeMapHash = hashKnowledgeMap(knowledgeMap);
@@ -872,15 +910,18 @@ 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 && !breakerPlanRiskAuditWillBePreserved) {
+        if (currentPlanRiskAudit) {
             appendReboundPlanRiskAudit(this.store, task, refreshedTask, currentPlanRiskAudit, this.now());
         }
         transitions.push('task knowledge-rebind');
-        refreshedTask = this.authorizeTask(repository, taskId, refreshedTask.revision, actor, 'Delegated content-only context refresh.', delegationGrantId);
+        refreshedTask = this.authorizeTask(repository, taskId, refreshedTask.revision, actor, refreshAssessment.mode === 'delegated-plan-bounded-supporting-source'
+            ? 'Delegated Plan-bounded supporting-source context refresh.'
+            : 'Delegated content-only context refresh.', delegationGrantId);
         transitions.push('task execution authorize');
         return {
-            mode: 'delegated-content-only',
+            mode: refreshAssessment.mode,
             transitions,
+            addedSources: refreshAssessment.addedSources,
             knowledgeMap,
             task: refreshedTask,
         };
@@ -1154,9 +1195,9 @@ export class WorkflowService {
                 currentAuditPresent: Boolean(planRiskAudit),
             });
         }
-        const remediationGate = planRiskAudit && isStepReviewRequired(task, stepId, planRiskAudit.reviewRequiredStepIds)
-            ? assertGuardedRemediationAttemptAllowed(this.store, task, stepId, planRiskAudit)
-            : null;
+        if (planRiskAudit && isStepReviewRequired(task, stepId, planRiskAudit.reviewRequiredStepIds)) {
+            assertGuardedRemediationAttemptAllowed(this.store, task, stepId, planRiskAudit);
+        }
         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.`, {
@@ -1259,25 +1300,15 @@ 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, allowHistoricalStrictReview = false) {
+    taskContext(repository, taskId, role) {
         const { identity } = this.context(repository);
         const task = this.store.readTask(identity.projectId, taskId);
-        const historicalStrictReview = allowHistoricalStrictReview
-            && role === 'independent-reviewer'
+        const historicalStrictReview = 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)
@@ -1314,7 +1345,7 @@ export class WorkflowService {
         if (role === 'technical-planner') {
             return {
                 ...common,
-                objective: `Produce an execution-ready Plan for ${task.title}. Perform an explicit risk review before plan-set: migrations, concurrency, restart/replay, crash windows, and external-provider behavior require failure-specific checks in the original Plan.${planRiskReviewScope}`,
+                objective: `Produce an execution-ready Plan for ${task.title}. Perform an explicit risk review before plan-set: migrations, concurrency, restart/replay, crash windows, and external-provider behavior require failure-specific checks and executable proof obligations in the original Plan.${planRiskReviewScope}`,
                 resultSchema: {
                     type: 'object',
                     required: ['objective', 'requirements', 'acceptance', 'risks', 'steps'],
@@ -1325,6 +1356,7 @@ export class WorkflowService {
                     'Concurrency or cursor/state ownership is planned without deterministic race checks.',
                     'Restart, replay, or crash recovery is claimed without restart/crash-window evidence.',
                     'An external provider is used without failure-injection and hidden-default verification.',
+                    'A guarded failure mode lacks a hostile counterexample, expected safe result, or exact executable evidence command.',
                     'The safe risk slice crosses persistence, recovery orchestration, and executable composition and should be split.',
                 ],
             };
@@ -1438,161 +1470,7 @@ 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);
@@ -1603,8 +1481,6 @@ export class WorkflowService {
             throw new WorkflowError('TRANSITION_BLOCKED', `Strict Step Review cannot run while task ${taskId} is ${task.status}.`);
         }
         assertTaskBranch(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.`, {
@@ -1620,6 +1496,13 @@ export class WorkflowService {
                 stepStatus: step.status,
             });
         }
+        // A strict review is bound to the immutable completion commit, Task Plan, and the
+        // Knowledge Map revision that authorized the Step. Project knowledge commonly becomes
+        // stale because the completion commit itself changes a classified source. Requiring the
+        // *current* map here creates a deadlock: review cannot run before rebind, while rebind is
+        // intentionally forbidden until the in-progress Step becomes terminal. The pending
+        // strict-review binding below validates the historical Task context; a current-map rebind
+        // remains mandatory after the review finalizes the Step and before another Step can run.
         validateTaskHistory(context.identity.repositoryRoot, task);
         if (!isClean(context.identity.repositoryRoot)) {
             throw new WorkflowError('GIT_PRECONDITION_FAILED', 'Strict Step Review requires a clean Task checkout.', {
@@ -1665,7 +1548,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', allowStaleKnowledgeBinding);
+        const envelope = this.taskContext(repository, taskId, 'independent-reviewer');
         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,
@@ -1773,7 +1656,7 @@ export class WorkflowService {
         assertExpectedRevision(task, expectedRevision);
         this.proveOptionalWriterLeaseToken(this.context(repository), taskId, writerToken);
         this.assertTaskMutationAllowedByHandoff(task, actor ?? null, writerToken);
-        if (!['needs_fix', 'awaiting_execution_authorization', 'ready'].includes(task.status)) {
+        if (!['ready', 'needs_fix', 'blocked'].includes(task.status)) {
             throw new WorkflowError('TRANSITION_BLOCKED', `Task ${taskId} cannot record a corrective decision while ${task.status}.`);
         }
         const planRiskAudit = readCurrentPlanRiskAudit(this.store, task);
@@ -1789,51 +1672,24 @@ export class WorkflowService {
                 stepId,
             });
         }
-        const step = requireStep(task, stepId);
         if (!isStepReviewRequired(task, stepId, planRiskAudit.reviewRequiredStepIds)) {
             throw new WorkflowError('TRANSITION_BLOCKED', `Step ${stepId} is not guarded by the current Plan Risk Audit and cannot receive a corrective decision.`, {
                 taskId,
                 stepId,
             });
         }
-        if (step.status !== 'failed') {
-            throw new WorkflowError('TRANSITION_BLOCKED', `Corrective decision for ${stepId} requires a currently failed guarded Step.`, {
+        const posture = readGuardedRemediationPostureForStep(this.store, task, stepId, planRiskAudit);
+        if (!posture) {
+            const step = requireStep(task, stepId);
+            const currentCycle = step.status === 'in_progress' && step.evidence
+                ? buildCurrentStrictStepReviewCycle(this.store, task, stepId).resolution
+                : null;
+            throw new WorkflowError('TRANSITION_BLOCKED', `Corrective decision for ${stepId} requires a failed guarded Step or a blocked unverified strict-review retry posture.`, {
                 taskId,
                 stepId,
                 taskStatus: task.status,
                 stepStatus: step.status,
-            });
-        }
-        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,
+                resolution: currentCycle,
             });
         }
         assertCorrectiveAuditorIndependence(this.store, task, stepId, correctiveAudit.auditor);
@@ -2071,243 +1927,109 @@ 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 = [];
+    alpha6StrictReviewRescuePreflight(repository) {
+        const context = this.context(repository);
+        const dependency = inspectLocalDependency(context.identity.repositoryRoot);
+        const tasks = context.store.listTasks(context.identity.projectId);
+        const leases = context.locks.list();
+        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 dirty = changedFiles(context.identity.repositoryRoot);
+        const currentHead = headCommit(context.identity.repositoryRoot);
+        const pendingCandidates = [];
+        const malformedCandidates = [];
         for (const task of tasks) {
-            if (task.revision !== 14 || task.status !== 'ready')
+            if (task.status !== 'in_progress')
                 continue;
-            const step = task.steps.find((entry) => entry.id === 'STEP-001') ?? null;
-            if (!step || step.status !== 'failed' || !task.planHash)
+            const planRiskAudit = task.planHash ? readCurrentPlanRiskAudit(this.store, task) : null;
+            if (!planRiskAudit)
                 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.');
+            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);
+                    let knowledgeBindingStale = false;
+                    try {
+                        const storedKnowledgeMap = this.store.readKnowledgeMap(context.identity.projectId);
+                        const knowledgeMap = inspectKnowledgeMap(storedKnowledgeMap, scanProjectKnowledge(context.identity.repositoryRoot, context.identity.projectId, this.now()));
+                        knowledgeBindingStale = knowledgeMap.status !== 'active'
+                            || task.knowledgeMapRevision !== knowledgeMap.revision
+                            || task.knowledgeMapHash !== hashKnowledgeMap(knowledgeMap);
                     }
-                    milestoneScopeHash = milestoneScopeDigest(milestone);
+                    catch {
+                        knowledgeBindingStale = true;
+                    }
+                    pendingCandidates.push({
+                        taskId: task.id,
+                        taskRevision: task.revision,
+                        stepId: step.id,
+                        completionCommit: step.evidence.commitSha,
+                        currentHead,
+                        knowledgeBindingStale,
+                    });
+                }
+                catch (error) {
+                    malformedCandidates.push(error instanceof Error ? error.message : String(error));
                 }
-                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 candidate = pendingCandidates.length === 1 ? pendingCandidates[0] : null;
+        const candidateLeaseIds = new Set(candidate ? [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.'] : []),
-            ...(currentHead !== this.alpha6CorrectiveRescueHead
-                ? [`HEAD must exactly equal ${this.alpha6CorrectiveRescueHead}.`]
+            ...(activeLeases.length > 0 ? ['At least one writer lease is active.'] : []),
+            ...(pendingCandidates.length !== 1
+                ? [`Expected exactly one pending alpha.6 strict review; found ${pendingCandidates.length}.`]
                 : []),
-            ...(candidates.length !== 1
-                ? [`Expected exactly one alpha.6 corrective recovery candidate; found ${candidates.length}.`]
+            ...(candidate && candidate.currentHead !== candidate.completionCommit
+                ? ['HEAD does not match the pending strict review completion commit.']
                 : []),
-            ...(candidate && leases.some((lease) => lease.entityId !== candidate.taskId)
-                ? ['An unrelated writer lease exists outside the recovery Task.']
+            ...(staleLeases.some((lease) => !candidateLeaseIds.has(lease.entityId))
+                ? ['A stale writer lease exists outside the rescue Task.']
                 : []),
-            ...malformed.map((message) => `Corrective recovery candidate is invalid: ${message}`),
+            ...malformedCandidates.map((message) => `Pending strict review state is invalid: ${message}`),
         ];
+        const eligible = blockers.length === 0 && candidate !== null;
+        const requiredActions = eligible
+            ? [
+                ...staleLeases.map((lease) => ({
+                    action: 'locks repair',
+                    entityId: lease.entityId,
+                })),
+                {
+                    action: 'task step-review',
+                    taskId: candidate.taskId,
+                    stepId: candidate.stepId,
+                    expectedRevision: candidate.taskRevision,
+                },
+            ]
+            : [];
         return {
-            eligible: blockers.length === 0 && candidate !== null,
+            eligible,
             mutationFree: true,
             runnerPackageVersion: PACKAGE_VERSION,
             requiredProjectPackageVersion: '2.0.0-alpha.6',
             declaredProjectPackageVersion: dependency.declared,
-            requiredHead: this.alpha6CorrectiveRescueHead,
-            currentHead,
+            projectId: context.identity.projectId,
+            repositoryRoot: context.identity.repositoryRoot,
             clean: dirty.length === 0,
+            activeLeases,
+            staleLeases,
             candidate,
             blockers,
+            requiredActions,
         };
     }
-    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());
@@ -2332,11 +2054,14 @@ export class WorkflowService {
         return inspectKnowledgeMap(current, scanned);
     }
     approveKnowledgeMap(repository, expectedRevision, selections, actor, delegationGrantId = null) {
+        return this.approveKnowledgeMapForTaskRefresh(repository, expectedRevision, selections, actor, delegationGrantId, null);
+    }
+    approveKnowledgeMapForTaskRefresh(repository, expectedRevision, selections, actor, delegationGrantId, autonomyTaskId) {
         const { identity } = this.context(repository);
         const current = this.store.readKnowledgeMap(identity.projectId);
         assertExpectedRevision(current, expectedRevision);
         const inspected = inspectKnowledgeMap(current, scanProjectKnowledge(identity.repositoryRoot, identity.projectId, this.now()));
-        const delegation = this.delegatedAuthorization(identity.projectId, delegationGrantId, 'project_memory.approve', actor, inspected);
+        const delegation = this.delegatedAuthorization(identity.projectId, delegationGrantId, 'project_memory.approve', actor, inspected, autonomyTaskId);
         const approved = applyKnowledgeSelections(inspected, selections, actor, this.now());
         if (!approved.approval) {
             throw new WorkflowError('STATE_CORRUPT', 'Knowledge Map approval was not recorded.');
@@ -2405,11 +2130,20 @@ export class WorkflowService {
         const milestonesById = new Map(status.milestones.map((milestone) => [milestone.id, milestone]));
         const activeTask = status.tasks.find((task) => taskIsActionableFromRepositoryNext(task, milestonesById));
         if (activeTask) {
+            const activePlanRiskAudit = activeTask.planHash
+                ? readCurrentPlanRiskAudit(this.store, activeTask)
+                : null;
+            const taskNext = activeTask.status === 'planning'
+                ? null
+                : this.nextForTaskWithDelegation(status.projectId, activeTask, activePlanRiskAudit);
+            // Pending strict review is completion work for the already-recorded commit. It must
+            // outrank Project Knowledge refresh/rebind; otherwise the active Step makes the rebind
+            // returned by `next` impossible to execute.
+            if (taskNext?.action === 'task step-review') {
+                return withAdoption(taskNext);
+            }
             if (!taskCanRebindKnowledge(activeTask) && activeTask.status !== 'planning') {
-                const planRiskAudit = activeTask.planHash
-                    ? readCurrentPlanRiskAudit(this.store, activeTask)
-                    : null;
-                return withAdoption(this.nextForTaskWithDelegation(status.projectId, activeTask, planRiskAudit));
+                return withAdoption(taskNext);
             }
             const knowledgeMap = this.knowledgeMapStatus(repository);
             if (knowledgeMap.status !== 'active' || !knowledgeMap.approval) {
@@ -2418,11 +2152,14 @@ export class WorkflowService {
                     ? this.delegatedApprovalOptions(status.projectId, 'project_memory.approve', knowledgeMap)
                     : [];
                 const storedKnowledgeMap = this.store.readKnowledgeMap(status.projectId);
-                const contextRefreshOptions = action === 'project-memory reconcile'
-                    && storedKnowledgeMap.status === 'active'
+                const refreshAssessment = storedKnowledgeMap.status === 'active'
                     && storedKnowledgeMap.approval
-                    && isContentOnlyKnowledgeRefresh(storedKnowledgeMap, knowledgeMap)
-                    ? this.delegatedContextRefreshOptions(status.projectId, activeTask, knowledgeMap)
+                    ? assessDelegatedKnowledgeRefresh(storedKnowledgeMap, knowledgeMap, activeTask, activeTask.planHash
+                        ? this.store.hashArtifact(this.store.taskRoot(status.projectId, activeTask.id), 'plan.md')
+                        : null)
+                    : null;
+                const contextRefreshOptions = action === 'project-memory reconcile' && refreshAssessment?.eligible
+                    ? this.delegatedContextRefreshOptions(status.projectId, activeTask, knowledgeMap, refreshAssessment.mode)
                     : [];
                 return withAdoption({
                     scope: 'project-memory',
@@ -2435,11 +2172,21 @@ export class WorkflowService {
                         ? {
                             contextRefresh: {
                                 action: 'task context-refresh',
-                                mode: 'delegated-content-only',
+                                mode: refreshAssessment.mode,
+                                addedSources: refreshAssessment.addedSources,
                                 options: contextRefreshOptions,
                             },
                         }
                         : {}),
+                    ...(refreshAssessment && !refreshAssessment.eligible
+                        ? {
+                            contextRefreshBlocked: {
+                                reason: 'Knowledge drift is outside the atomic delegated refresh predicate.',
+                                unsafeDifferences: refreshAssessment.unsafeDifferences,
+                                requiredAction: 'Inspect and approve the Knowledge Map through the ordinary human flow.',
+                            },
+                        }
+                        : {}),
                 });
             }
             const knowledgeMapHash = hashKnowledgeMap(knowledgeMap);
@@ -2457,10 +2204,7 @@ export class WorkflowService {
                     knowledgeMapHash,
                 });
             }
-            const planRiskAudit = activeTask.planHash && activeTask.status !== 'planning'
-                ? readCurrentPlanRiskAudit(this.store, activeTask)
-                : null;
-            return withAdoption(this.nextForTaskWithDelegation(status.projectId, activeTask, planRiskAudit));
+            return withAdoption(taskNext ?? this.nextForTaskWithDelegation(status.projectId, activeTask, null));
         }
         const activeMilestone = status.milestones.find((milestone) => !['accepted', 'cancelled'].includes(milestone.status));
         if (activeMilestone) {
@@ -2545,7 +2289,7 @@ export class WorkflowService {
         }
         return withAdoption({ scope: 'repository', status: 'idle', action: 'discovery start' });
     }
-    delegatedAuthorization(projectId, grantId, transition, actor, target) {
+    delegatedAuthorization(projectId, grantId, transition, actor, target, autonomyTaskId = null) {
         if (!grantId) {
             if (actor.trim().startsWith('agent:')) {
                 throw new WorkflowError('TRANSITION_BLOCKED', 'An agent actor requires an explicit delegated approval grant.');
@@ -2553,6 +2297,52 @@ export class WorkflowService {
             return null;
         }
         const grant = this.store.readDelegation(projectId, grantId);
+        if (grant.scope.kind === 'milestone') {
+            const autonomyContract = readMilestoneAutonomyEvents(this.store, projectId, grant.scope.id)
+                .find((event) => event.delegationGrantId === grant.id) ?? null;
+            if (autonomyContract) {
+                const contextTask = target.kind === 'knowledge-map' && autonomyTaskId
+                    ? this.store.readTask(projectId, autonomyTaskId)
+                    : null;
+                const milestone = target.kind === 'milestone'
+                    ? target
+                    : target.kind === 'task' && target.milestoneId === grant.scope.id
+                        ? this.store.readMilestone(projectId, grant.scope.id)
+                        : contextTask?.milestoneId === grant.scope.id
+                            ? this.store.readMilestone(projectId, grant.scope.id)
+                            : null;
+                if (!milestone) {
+                    throw new WorkflowError('TRANSITION_BLOCKED', 'Milestone autonomy grant cannot authorize this target.');
+                }
+                const activeAutonomy = requireActiveMilestoneAutonomy({
+                    store: this.store,
+                    projectId,
+                    milestone,
+                    actor,
+                    now: this.now(),
+                });
+                if (activeAutonomy.grant.id !== grant.id) {
+                    throw new WorkflowError('TRANSITION_BLOCKED', 'Milestone autonomy grant has been superseded.');
+                }
+                if (target.kind === 'knowledge-map') {
+                    if (transition !== 'project_memory.approve'
+                        || !contextTask
+                        || !taskCanRebindKnowledge(contextTask)) {
+                        throw new WorkflowError('TRANSITION_BLOCKED', 'Milestone autonomy may approve Project Memory only inside a content-only Task context refresh.');
+                    }
+                    if (!grant.transitions.includes(transition)) {
+                        throw new WorkflowError('TRANSITION_BLOCKED', `Delegation ${grant.id} does not allow ${transition}.`);
+                    }
+                    return {
+                        grantId: grant.id,
+                        policyHash: grant.policyHash,
+                        principal: grant.principal,
+                        delegate: grant.delegate,
+                        transition,
+                    };
+                }
+            }
+        }
         return assertDelegationCanAuthorize(grant, transition, actor, target, this.now());
     }
     assertHandoffGrant(projectId, task, targetActor, grantId) {
@@ -2584,6 +2374,23 @@ export class WorkflowService {
                 grantExpiresAt: grant.expiresAt,
             });
         }
+        if (grant.scope.kind === 'milestone') {
+            const autonomyContract = readMilestoneAutonomyEvents(this.store, projectId, grant.scope.id)
+                .find((event) => event.delegationGrantId === grant.id) ?? null;
+            if (autonomyContract) {
+                const milestone = this.store.readMilestone(projectId, grant.scope.id);
+                const activeAutonomy = requireActiveMilestoneAutonomy({
+                    store: this.store,
+                    projectId,
+                    milestone,
+                    actor: targetActor,
+                    now: this.now(),
+                });
+                if (activeAutonomy.grant.id !== grant.id) {
+                    throw new WorkflowError('TRANSITION_BLOCKED', 'Milestone autonomy grant has been superseded.');
+                }
+            }
+        }
     }
     nextForTaskWithDelegation(projectId, task, planRiskAudit = null) {
         const transition = task.status === 'awaiting_execution_authorization'
@@ -2595,25 +2402,9 @@ 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)
+        const guardedCorrectivePosture = planRiskAudit
+            ? findCurrentGuardedRemediationPosture(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
@@ -2645,7 +2436,79 @@ export class WorkflowService {
                         requiredActor: handoffPosture.claimant,
                     },
                 }
-                : {};
+                : task.milestoneId && next.action === 'task start'
+                    ? {
+                        action: 'task handoff-prepare',
+                        blockedAction: next.action,
+                        c1Handoff: {
+                            state: 'required',
+                            recommendedTargetActor: defaultTaskWorkerActor(task.id),
+                            targetActorDerived: true,
+                        },
+                    }
+                    : {};
+        let guardedCorrectiveOverlay = {};
+        if (!strictStepReviewStep && guardedCorrectivePosture) {
+            switch (guardedCorrectivePosture.posture) {
+                case 'decision-required':
+                    guardedCorrectiveOverlay = {
+                        action: 'task corrective-decision',
+                        stepId: guardedCorrectivePosture.stepId,
+                        correctiveDecisionGate: {
+                            attemptCount: guardedCorrectivePosture.attemptCount,
+                            recommendedAuditor: defaultCorrectiveAuditorActor(task.id),
+                            auditorDerived: true,
+                            auditorMustDifferFromLatestStrictReviewer: true,
+                            allowedDecision: 'continue-fix',
+                            escalationDecisions: ['replan-required', 'split-required', 'stop-escalate'],
+                            humanApprovalRequired: false,
+                        },
+                    };
+                    break;
+                case 'hard-stop':
+                    guardedCorrectiveOverlay = {
+                        action: 'task corrective-decision',
+                        stepId: guardedCorrectivePosture.stepId,
+                        correctiveDecisionGate: {
+                            attemptCount: guardedCorrectivePosture.attemptCount,
+                            recommendedAuditor: defaultCorrectiveAuditorActor(task.id),
+                            auditorDerived: true,
+                            auditorMustDifferFromLatestStrictReviewer: true,
+                            allowedDecisions: ['split-required', 'stop-escalate'],
+                            hardStop: true,
+                            humanApprovalRequired: false,
+                        },
+                    };
+                    break;
+                case 'replan-required':
+                    guardedCorrectiveOverlay = {
+                        action: 'task plan-set',
+                        stepId: guardedCorrectivePosture.stepId,
+                        correctiveDecisionGate: {
+                            attemptCount: guardedCorrectivePosture.attemptCount,
+                            decision: guardedCorrectivePosture.correctiveDecision?.decision ?? null,
+                            decisionEventId: guardedCorrectivePosture.correctiveDecision?.eventId ?? null,
+                            requiredAction: 'Record an actual new Plan posture before another remediation run.',
+                        },
+                    };
+                    break;
+                case 'split-required':
+                case 'stop-escalate':
+                    guardedCorrectiveOverlay = {
+                        action: 'doctor',
+                        stepId: guardedCorrectivePosture.stepId,
+                        correctiveDecisionGate: {
+                            attemptCount: guardedCorrectivePosture.attemptCount,
+                            decision: guardedCorrectivePosture.correctiveDecision?.decision ?? null,
+                            decisionEventId: guardedCorrectivePosture.correctiveDecision?.eventId ?? null,
+                            humanApprovalRequired: false,
+                        },
+                    };
+                    break;
+                default:
+                    break;
+            }
+        }
         const result = {
             ...next,
             ...handoffOverlay,
@@ -2686,53 +2549,8 @@ export class WorkflowService {
                     },
                 }
                 : {}),
-            ...(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 } : {}),
+            ...guardedCorrectiveOverlay,
+            ...(delegatedApprovalOptions.length > 0 ? { delegatedApprovalOptions } : {}),
         };
         if (handoffPosture.state === 'pending') {
             return {
@@ -2745,7 +2563,16 @@ export class WorkflowService {
     }
     delegatedApprovalOptions(projectId, transition, target) {
         return this.store.listDelegations(projectId)
-            .filter((grant) => delegationCanAuthorize(grant, transition, target, this.now()))
+            .filter((grant) => {
+            try {
+                return Boolean(this.delegatedAuthorization(projectId, grant.id, transition, grant.delegate, target));
+            }
+            catch (error) {
+                if (error instanceof WorkflowError && error.code === 'TRANSITION_BLOCKED')
+                    return false;
+                throw error;
+            }
+        })
             .map((grant) => ({
             grantId: grant.id,
             principal: grant.principal,
@@ -2756,10 +2583,22 @@ export class WorkflowService {
             policyHash: grant.policyHash,
         }));
     }
-    delegatedContextRefreshOptions(projectId, task, knowledgeMap) {
+    delegatedContextRefreshOptions(projectId, task, knowledgeMap, mode) {
         return this.store.listDelegations(projectId)
-            .filter((grant) => delegationCanAuthorize(grant, 'project_memory.approve', knowledgeMap, this.now()))
-            .filter((grant) => delegationCanAuthorize(grant, 'task.execution_authorize', task, this.now()))
+            .filter((grant) => {
+            try {
+                if (mode === 'delegated-plan-bounded-supporting-source') {
+                    this.assertPlanBoundedSupportingSourceGrant(projectId, grant.id, grant.delegate, task);
+                }
+                return Boolean(this.delegatedAuthorization(projectId, grant.id, 'project_memory.approve', grant.delegate, knowledgeMap, task.id)
+                    && this.delegatedAuthorization(projectId, grant.id, 'task.execution_authorize', grant.delegate, task));
+            }
+            catch (error) {
+                if (error instanceof WorkflowError && error.code === 'TRANSITION_BLOCKED')
+                    return false;
+                throw error;
+            }
+        })
             .map((grant) => ({
             grantId: grant.id,
             principal: grant.principal,
@@ -2771,6 +2610,23 @@ export class WorkflowService {
             policyHash: grant.policyHash,
         }));
     }
+    assertPlanBoundedSupportingSourceGrant(projectId, grantId, actor, task) {
+        const grant = this.store.readDelegation(projectId, grantId);
+        if (!task.milestoneId || grant.scope.kind !== 'milestone' || grant.scope.id !== task.milestoneId) {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Plan-bounded supporting-source refresh requires the active Task Milestone autonomy grant.', { taskId: task.id, taskMilestoneId: task.milestoneId, grantScope: grant.scope });
+        }
+        const milestone = this.store.readMilestone(projectId, task.milestoneId);
+        const autonomy = requireActiveMilestoneAutonomy({
+            store: this.store,
+            projectId,
+            milestone,
+            actor,
+            now: this.now(),
+        });
+        if (autonomy.grant.id !== grant.id) {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Milestone autonomy grant has been superseded.');
+        }
+    }
     assertDelegationScopeExists(projectId, policy) {
         if (policy.scope.kind === 'task') {
             this.store.readTask(projectId, policy.scope.id);
@@ -3248,67 +3104,6 @@ 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(),
@@ -3320,11 +3115,6 @@ function appendCorrectivePlanAudit(taskRoot, previous, saved, failedReviewAttemp
         ...audit,
     })}\n`, { encoding: 'utf8', mode: 0o600 });
 }
-function assertContentOnlyKnowledgeRefresh(approved, inspected) {
-    if (!isContentOnlyKnowledgeRefresh(approved, inspected)) {
-        throw new WorkflowError('TRANSITION_BLOCKED', 'Automatic Task context refresh is limited to content-hash drift. Knowledge sources, categories, scopes, authorities, gaps, or conflicts changed.', { requiredAction: 'Run project-memory reconcile, inspect the classification diff, and approve it explicitly.' });
-    }
-}
 function isContentOnlyKnowledgeRefresh(approved, inspected) {
     const classification = (map) => JSON.stringify({
         entries: map.entries.map((entry) => ({
@@ -3340,6 +3130,107 @@ function isContentOnlyKnowledgeRefresh(approved, inspected) {
     });
     return classification(approved) === classification(inspected);
 }
+function assertDelegatedKnowledgeRefresh(assessment) {
+    if (assessment.eligible)
+        return;
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Knowledge drift is outside the atomic delegated context-refresh predicate: it is neither content-hash drift nor an exact Plan-bounded supporting-source addition.', {
+        unsafeDifferences: assessment.unsafeDifferences,
+        requiredAction: 'Run project-memory reconcile, inspect the classification diff, and approve it explicitly.',
+    });
+}
+function assessDelegatedKnowledgeRefresh(approved, inspected, task, currentPlanArtifactHash) {
+    if (isContentOnlyKnowledgeRefresh(approved, inspected)) {
+        return {
+            eligible: true,
+            mode: 'delegated-content-only',
+            addedSources: [],
+            unsafeDifferences: [],
+        };
+    }
+    const unsafeDifferences = [];
+    const sourceKey = (source) => `${source.category}\0${source.path}\0${source.scope}`;
+    const approvedByKey = new Map(approved.entries.map((source) => [sourceKey(source), source]));
+    const inspectedByKey = new Map(inspected.entries.map((source) => [sourceKey(source), source]));
+    const inspectedByPath = new Map(inspected.entries.map((source) => [source.path, source]));
+    for (const source of approved.entries) {
+        const candidate = inspectedByKey.get(sourceKey(source));
+        if (!candidate) {
+            const samePath = inspectedByPath.get(source.path);
+            unsafeDifferences.push(samePath
+                ? `Existing source ${source.path} changed category or scope from ${source.category}/${source.scope} to ${samePath.category}/${samePath.scope}.`
+                : `Previously approved source was removed: ${source.path}.`);
+            continue;
+        }
+        if (candidate.authority !== source.authority) {
+            unsafeDifferences.push(`Existing source ${source.path} changed authority from ${source.authority} to ${candidate.authority}.`);
+        }
+        if (candidate.id !== source.id || candidate.discoveredBy !== source.discoveredBy) {
+            unsafeDifferences.push(`Existing source ${source.path} changed classification identity.`);
+        }
+    }
+    const addedSources = inspected.entries.filter((source) => !approvedByKey.has(sourceKey(source)));
+    const currentExecutionAuthorization = [...task.authorizations].reverse().find((authorization) => authorization.kind === 'execution'
+        && authorization.decision === 'approved'
+        && authorization.planHash === task.planHash
+        && authorization.briefHash === task.briefHash);
+    if (!task.planHash || !currentExecutionAuthorization) {
+        unsafeDifferences.push('The current Task Plan was not execution-authorized before Knowledge drift.');
+    }
+    if (!task.planHash || currentPlanArtifactHash !== task.planHash) {
+        unsafeDifferences.push('The current Task Plan artifact does not match its authorized state binding.');
+    }
+    if (task.knowledgeImpact !== 'create') {
+        unsafeDifferences.push(`Task Plan knowledgeImpact is ${task.knowledgeImpact ?? 'unset'}, not create.`);
+    }
+    const declaredTargets = new Set();
+    for (const target of task.knowledgeTargets) {
+        let normalized;
+        try {
+            normalized = normalizeRelativePath(target.path);
+        }
+        catch {
+            unsafeDifferences.push(`Task Plan Knowledge target is not an exact repository-relative path: ${target.path}.`);
+            continue;
+        }
+        if (normalized !== target.path || /[*?\[\]{}]/.test(target.path) || target.path.endsWith('/')) {
+            unsafeDifferences.push(`Task Plan Knowledge target is wildcard, directory-like, or not normalized: ${target.path}.`);
+            continue;
+        }
+        declaredTargets.add(`${target.category}\0${target.path}`);
+    }
+    if (addedSources.length === 0) {
+        unsafeDifferences.push('No new Knowledge source matches the Plan-bounded addition path.');
+    }
+    for (const source of addedSources) {
+        if (source.authority !== 'supporting') {
+            unsafeDifferences.push(`New source ${source.path} has forbidden ${source.authority} authority.`);
+        }
+        if (!declaredTargets.has(`${source.category}\0${source.path}`)) {
+            unsafeDifferences.push(`New source ${source.path} (${source.category}) was not declared by the authorized Task Plan.`);
+        }
+    }
+    if (JSON.stringify(approved.gaps) !== JSON.stringify(inspected.gaps)) {
+        unsafeDifferences.push('Project Knowledge gaps changed.');
+    }
+    if (JSON.stringify(approved.conflicts) !== JSON.stringify(inspected.conflicts)) {
+        unsafeDifferences.push('Project Knowledge conflicts changed.');
+    }
+    if (inspected.conflicts.length > 0) {
+        unsafeDifferences.push('The inspected Project Knowledge Map contains conflicts.');
+    }
+    return {
+        eligible: unsafeDifferences.length === 0,
+        mode: 'delegated-plan-bounded-supporting-source',
+        addedSources: addedSources.map(({ id, path: sourcePath, category, scope, authority }) => ({
+            id,
+            path: sourcePath,
+            category,
+            scope,
+            authority,
+        })),
+        unsafeDifferences: [...new Set(unsafeDifferences)],
+    };
+}
 function validateMilestonePlan(plan) {
     if (!plan.outcome.trim())
         throw new WorkflowError('INVALID_ARGUMENT', 'Milestone outcome is required.');