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

package/dist/src/workflow.js

@@ -1,15 +1,24 @@
-import { appendFileSync, readFileSync } from 'node:fs';
+import { appendFileSync, existsSync, lstatSync, readFileSync, readdirSync } from 'node:fs';
 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 { assessDiscovery, mergeUnique } from './domain/discovery.js';
 import { pathAllowed, validatePlan } from './domain/validation.js';
 import { WorkflowError } from './errors.js';
 import { bindGraphEvidence, createGraphRefreshRequest, fallbackGraphBinding, inspectGraphBinding, validateGraphRequestCurrent, } from './graph.js';
+import { appendTaskClaim, appendTaskHandback, appendTaskHandoff, assertTaskMutationAllowedByC1, readTaskC1Posture, } from './alpha6/handoff.js';
+import { applyAdoptionPosture, assertAdoptionBaselinePreserved, buildAdoptionPreparation, initializeProjectRegistrationAdoption, readCurrentAdoptionPosture, } from './alpha6/adoption.js';
+import { appendCurrentPlanRiskAudit, appendReboundPlanRiskAudit, readCurrentPlanRiskAudit, validatePlanRiskAuditCandidate, } from './alpha6/plan-risk.js';
+import { appendCorrectiveDecisionEvent, appendRemediationEvent, assertCorrectiveAuditorIndependence, assertGuardedRemediationAttemptAllowed, findFailedGuardedStepRequiringCorrectiveDecision, readCorrectiveDecisionEvents, readRemediationEvents, } from './alpha6/remediation.js';
+import { applyMilestoneScopeChangeTransaction, assertMilestoneMembershipIntegrity, assertMilestoneScopeChangeStatusAllowed, normalizeMilestonePlan, prepareMilestoneScopeChangeCandidate, readMilestoneForScopeChange, readMilestoneWithIntegrity, } from './alpha6/milestone.js';
+import { buildCurrentStrictStepReviewCycle, ensurePendingStrictStepReview, isStepReviewRequired, recordStrictStepReview, } from './alpha6/review.js';
 import { applyKnowledgeSelections, hashKnowledgeMap, inspectKnowledgeMap, normalizeRelativePath, reconcileKnowledgeMap, scanProjectKnowledge, selectKnowledgeSources, } from './memory.js';
+import { canonicalJsonStringify, sha256Hex } from './alpha6/store-sidecars.js';
 import { commitStep, mergeTaskBranch, runChecks, startLocalTaskBranch, syncBaseIntoTask, validateTaskHistory, } from './git.js';
 import { changedFiles, currentBranch, gitIsAncestor, headCommit, isClean, resolveRepositoryIdentity, runGit, } from './repository.js';
+import { launchStrictStepReviewer } from './reviewer.js';
 import { WriterLockManager } from './state/lock.js';
 import { FileStateStore } from './state/store.js';
 import { createEntityId } from './ulid.js';
@@ -23,6 +32,18 @@ export class WorkflowService {
     }
     context(repository) {
         const identity = resolveRepositoryIdentity(repository);
+        const projectFile = path.join(this.store.projectRoot(identity.projectId), 'project.json');
+        const projectAlreadyRegistered = existsSync(projectFile);
+        if (!projectAlreadyRegistered) {
+            initializeProjectRegistrationAdoption(this.store, {
+                projectId: identity.projectId,
+                repositoryIdentity: identity,
+                packageVersion: PACKAGE_VERSION,
+                protocolVersion: PROTOCOL_VERSION,
+                stateSchemaVersion: STATE_SCHEMA_VERSION,
+                now: this.now(),
+            });
+        }
         this.store.registerProject(identity);
         return {
             identity,
@@ -30,6 +51,70 @@ export class WorkflowService {
             locks: new WriterLockManager(this.store.lockRoot(identity.projectId), this.now),
         };
     }
+    prepareDelegation(repository, input) {
+        const { identity } = this.context(repository);
+        const gate = prepareDelegationGrantGate(identity.projectId, input, this.now());
+        this.assertDelegationScopeExists(identity.projectId, gate.policy);
+        return gate;
+    }
+    grantDelegation(repository, input, confirmationCode) {
+        const { identity } = this.context(repository);
+        const gate = prepareDelegationGrantGate(identity.projectId, input, this.now());
+        this.assertDelegationScopeExists(identity.projectId, gate.policy);
+        if (confirmationCode.trim() !== gate.confirmationCode) {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Delegation confirmation does not match the exact project and policy.', { projectId: identity.projectId, policyHash: gate.policyHash });
+        }
+        const duplicate = this.store.listDelegations(identity.projectId)
+            .find((grant) => grant.policyHash === gate.policyHash);
+        if (duplicate) {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'This exact delegation policy was already issued.', {
+                grantId: duplicate.id,
+                status: duplicate.status,
+            });
+        }
+        const timestamp = this.now().toISOString();
+        return this.store.writeDelegation({
+            schemaVersion: STATE_SCHEMA_VERSION,
+            revision: 0,
+            id: createEntityId('DGR', this.now().getTime()),
+            projectId: identity.projectId,
+            createdAt: timestamp,
+            updatedAt: timestamp,
+            kind: 'delegation-grant',
+            status: 'active',
+            principal: gate.policy.principal,
+            delegate: gate.policy.delegate,
+            scope: gate.policy.scope,
+            transitions: gate.policy.transitions,
+            expiresAt: gate.policy.expiresAt,
+            policyHash: gate.policyHash,
+            revokedAt: null,
+            revokedBy: null,
+            revokeReason: null,
+        }, null);
+    }
+    revokeDelegation(repository, grantId, expectedRevision, actor, reason) {
+        const { identity } = this.context(repository);
+        const grant = this.store.readDelegation(identity.projectId, grantId);
+        assertExpectedRevision(grant, expectedRevision);
+        if (grant.status !== 'active') {
+            throw new WorkflowError('TRANSITION_BLOCKED', `Delegation ${grantId} is already ${grant.status}.`);
+        }
+        if (actor.trim() !== grant.principal) {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Only the recorded principal may revoke a delegation.', {
+                principal: grant.principal,
+            });
+        }
+        if (!reason.trim())
+            throw new WorkflowError('INVALID_ARGUMENT', 'Delegation revocation requires a reason.');
+        return this.store.writeDelegation({
+            ...grant,
+            status: 'revoked',
+            revokedAt: this.now().toISOString(),
+            revokedBy: grant.principal,
+            revokeReason: reason.trim(),
+        }, expectedRevision);
+    }
     startDiscovery(repository, input) {
         if (!input.goal.trim())
             throw new WorkflowError('INVALID_ARGUMENT', 'Discovery requires a substantive goal.');
@@ -97,7 +182,7 @@ export class WorkflowService {
         if (!title.trim())
             throw new WorkflowError('INVALID_ARGUMENT', 'Task title is required.');
         if (milestoneId) {
-            const milestone = this.store.readMilestone(identity.projectId, milestoneId);
+            const milestone = this.readMilestoneCurrent(identity.projectId, milestoneId);
             if (milestone.status === 'accepted' || milestone.status === 'cancelled') {
                 throw new WorkflowError('TRANSITION_BLOCKED', `Milestone ${milestoneId} is ${milestone.status}.`);
             }
@@ -206,17 +291,29 @@ export class WorkflowService {
     }
     setMilestonePlan(repository, milestoneId, expectedRevision, plan) {
         const { identity } = this.context(repository);
-        const milestone = this.store.readMilestone(identity.projectId, milestoneId);
+        const milestone = this.readMilestoneScopeChangeCurrent(identity.projectId, milestoneId);
         assertExpectedRevision(milestone, expectedRevision);
         if (!['planning', 'awaiting_execution_authorization', 'active', 'blocked'].includes(milestone.status)) {
             throw new WorkflowError('TRANSITION_BLOCKED', `Cannot update Milestone Plan while ${milestone.status}.`);
         }
+        if (milestone.status !== 'planning'
+            || milestone.planHash !== null
+            || milestone.membershipRevision !== 0
+            || milestone.taskIds.length > 0
+            || milestone.memberships.length > 0) {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Milestone Plan is no longer in the initial empty planning posture. Use explicit scope-change prepare/apply.', {
+                milestoneId,
+                revision: milestone.revision,
+                requiredAction: 'prepareMilestoneScopeChange -> applyMilestoneScopeChange',
+            });
+        }
         validateMilestonePlan(plan);
-        const taskIds = plan.memberships.map((membership) => membership.taskId);
+        const normalized = normalizeMilestonePlan(plan);
+        const taskIds = normalized.taskIds;
         if (new Set(taskIds).size !== taskIds.length) {
             throw new WorkflowError('INVALID_ARGUMENT', 'Milestone memberships must have unique Task IDs.');
         }
-        for (const membership of plan.memberships) {
+        for (const membership of normalized.memberships) {
             const task = this.store.readTask(identity.projectId, membership.taskId);
             if (task.milestoneId !== milestoneId) {
                 throw new WorkflowError('TRANSITION_BLOCKED', `Task ${task.id} is not linked to Milestone ${milestoneId}.`);
@@ -231,22 +328,18 @@ export class WorkflowService {
                 throw new WorkflowError('TRANSITION_BLOCKED', `Started Task ${task.id} cannot be removed from a Milestone.`);
             }
         }
-        const root = this.store.milestoneRoot(identity.projectId, milestoneId);
-        const normalized = {
-            outcome: plan.outcome.trim(),
-            successSignal: plan.successSignal.trim(),
-            acceptance: [...plan.acceptance],
-            memberships: plan.memberships.map((membership) => ({
-                ...membership,
-                reason: membership.reason.trim(),
-            })),
-            checks: [...plan.checks],
-        };
-        const stagedPlan = this.store.stageArtifact(root, 'plan.json', JSON.stringify(normalized, null, 2));
         const authorizations = milestone.authorizations.map((authorization) => authorization.kind === 'execution' && authorization.decision === 'approved'
             ? { ...authorization, decision: 'superseded' }
             : authorization);
-        const saved = this.store.writeMilestone({
+        const root = this.store.milestoneRoot(identity.projectId, milestoneId);
+        const stagedPlan = this.store.stageArtifact(root, 'plan.json', JSON.stringify({
+            outcome: normalized.outcome,
+            successSignal: normalized.successSignal,
+            acceptance: normalized.acceptance,
+            memberships: normalized.memberships,
+            checks: normalized.checks,
+        }, null, 2));
+        const candidate = {
             ...milestone,
             status: 'awaiting_execution_authorization',
             outcome: normalized.outcome,
@@ -262,13 +355,55 @@ export class WorkflowService {
             evidenceHash: null,
             acceptedHead: null,
             cancellationReason: null,
-        }, expectedRevision);
+        };
+        assertMilestoneMembershipIntegrity(candidate, (taskId) => this.store.readTask(identity.projectId, taskId), {}, () => this.store.listTasks(identity.projectId));
+        const saved = this.store.writeMilestone(candidate, expectedRevision);
         this.store.publishArtifact(stagedPlan);
         return saved;
     }
-    authorizeMilestone(repository, milestoneId, expectedRevision, actor, reason = '') {
+    prepareMilestoneScopeChange(repository, milestoneId, expectedRevision, plan, actor) {
+        const { identity } = this.context(repository);
+        const milestone = this.readMilestoneScopeChangeCurrent(identity.projectId, milestoneId);
+        assertExpectedRevision(milestone, expectedRevision);
+        assertMilestoneScopeChangeStatusAllowed(milestone);
+        const prepared = this.prepareMilestoneScopeChangeCandidate(identity.projectId, milestone, plan, actor);
+        return {
+            milestoneId: prepared.milestoneId,
+            revision: prepared.expectedRevision,
+            actor: prepared.actor,
+            candidatePlanHash: prepared.candidatePlanHash,
+            candidateMembershipRevision: prepared.candidateMembershipRevision,
+            confirmationCodeBindingHash: prepared.confirmationCodeBindingHash,
+            confirmationCode: prepared.confirmationCode,
+            after: prepared.after,
+        };
+    }
+    applyMilestoneScopeChange(repository, milestoneId, expectedRevision, plan, actor, confirmationCode) {
         const { identity } = this.context(repository);
-        const milestone = this.store.readMilestone(identity.projectId, milestoneId);
+        const milestone = this.readMilestoneScopeChangeCurrent(identity.projectId, milestoneId);
+        assertExpectedRevision(milestone, expectedRevision);
+        assertMilestoneScopeChangeStatusAllowed(milestone);
+        const prepared = this.prepareMilestoneScopeChangeCandidate(identity.projectId, milestone, plan, actor);
+        if (confirmationCode.trim() !== prepared.confirmationCode) {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Milestone scope-change confirmation does not match the current Milestone state and requested scope.', {
+                milestoneId,
+                revision: milestone.revision,
+                actor: prepared.actor,
+                confirmationCodeBindingHash: prepared.confirmationCodeBindingHash,
+            });
+        }
+        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);
         assertExpectedRevision(milestone, expectedRevision);
         if (milestone.status !== 'awaiting_execution_authorization' || !milestone.planHash) {
             throw new WorkflowError('TRANSITION_BLOCKED', `Milestone ${milestoneId} is not awaiting authorization.`);
@@ -278,6 +413,7 @@ export class WorkflowService {
         if (planHash !== milestone.planHash) {
             throw new WorkflowError('TRANSITION_BLOCKED', 'Milestone Plan changed after it was recorded.');
         }
+        const delegation = this.delegatedAuthorization(identity.projectId, delegationGrantId, 'milestone.execution_authorize', actor, milestone);
         const event = {
             kind: 'execution',
             decision: 'approved',
@@ -289,12 +425,14 @@ export class WorkflowService {
             evidenceHash: null,
             headCommit: runGit(identity.repositoryRoot, ['rev-parse', milestone.baseBranch]),
             reason,
+            authorizationMode: delegation ? 'delegated' : 'human',
+            ...(delegation ? { delegation } : {}),
         };
         return this.store.writeMilestone({ ...milestone, status: 'active', planHash, authorizations: [...milestone.authorizations, event] }, expectedRevision);
     }
     validateMilestone(repository, milestoneId, expectedRevision) {
         const { identity } = this.context(repository);
-        const milestone = this.store.readMilestone(identity.projectId, milestoneId);
+        const milestone = this.readMilestoneCurrent(identity.projectId, milestoneId);
         assertExpectedRevision(milestone, expectedRevision);
         if (!['active', 'awaiting_final_acceptance'].includes(milestone.status)) {
             throw new WorkflowError('TRANSITION_BLOCKED', `Milestone ${milestoneId} cannot be validated while ${milestone.status}.`);
@@ -355,9 +493,9 @@ export class WorkflowService {
         this.store.publishArtifact(stagedResult);
         return saved;
     }
-    acceptMilestone(repository, milestoneId, expectedRevision, actor, confirmationCode) {
+    acceptMilestone(repository, milestoneId, expectedRevision, actor, confirmationCode, delegationGrantId = null) {
         const { identity } = this.context(repository);
-        const milestone = this.store.readMilestone(identity.projectId, milestoneId);
+        const milestone = this.readMilestoneCurrent(identity.projectId, milestoneId);
         assertExpectedRevision(milestone, expectedRevision);
         if (milestone.status !== 'awaiting_final_acceptance' || !milestone.resultHash || !milestone.evidenceHash) {
             throw new WorkflowError('TRANSITION_BLOCKED', `Milestone ${milestoneId} is not ready for acceptance.`);
@@ -384,6 +522,7 @@ export class WorkflowService {
                 revision: milestone.revision,
             });
         }
+        const delegation = this.delegatedAuthorization(identity.projectId, delegationGrantId, 'milestone.final_accept', normalizedActor, milestone);
         const event = {
             kind: 'final_acceptance',
             decision: 'approved',
@@ -395,6 +534,8 @@ export class WorkflowService {
             evidenceHash,
             headCommit: currentHead,
             reason: `Confirmed with ${gate.confirmationCode}.`,
+            authorizationMode: delegation ? 'delegated' : 'human',
+            ...(delegation ? { delegation } : {}),
         };
         return this.store.writeMilestone({
             ...milestone,
@@ -409,23 +550,93 @@ export class WorkflowService {
         if (!reason.trim())
             throw new WorkflowError('INVALID_ARGUMENT', 'Milestone cancellation requires a reason.');
         const { identity } = this.context(repository);
-        const milestone = this.store.readMilestone(identity.projectId, milestoneId);
+        const milestone = this.readMilestoneCurrent(identity.projectId, milestoneId);
         assertExpectedRevision(milestone, expectedRevision);
         if (['accepted', 'cancelled'].includes(milestone.status)) {
             throw new WorkflowError('TRANSITION_BLOCKED', `Milestone ${milestoneId} is ${milestone.status}.`);
         }
         return this.store.writeMilestone({ ...milestone, status: 'cancelled', cancellationReason: reason.trim() }, expectedRevision);
     }
-    setTaskPlan(repository, taskId, expectedRevision, plan) {
+    setTaskPlan(repository, taskId, expectedRevision, plan, correctiveAudit = null, planRiskAudit = null) {
         validatePlan(plan);
         const { identity } = this.context(repository);
         const knowledgeMap = this.assertKnowledgeMapBinding(identity.repositoryRoot, identity.projectId, plan.knowledgeMapRevision, plan.knowledgeMapHash);
         this.validateKnowledgeTargets(knowledgeMap, plan);
         const task = this.store.readTask(identity.projectId, taskId);
         assertExpectedRevision(task, expectedRevision);
-        if (!['planning', 'awaiting_execution_authorization', 'needs_fix'].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) {
+            throw new WorkflowError('TRANSITION_BLOCKED', `Task ${task.id} has current corrective decisions that prohibit normal plan updates.`, {
+                taskId: task.id,
+                requiredAction: 'Escalate or split the work according to the recorded corrective decision.',
+                decisions: currentHardBlockingDecisions.map((event) => ({
+                    eventId: event.eventId,
+                    stepId: event.stepId,
+                    decision: event.decision,
+                })),
+            });
+        }
+        if (task.status === 'blocked' && currentReplanDecisions.length === 0) {
+            throw new WorkflowError('TRANSITION_BLOCKED', `Cannot update Plan while Task ${task.id} is blocked unless the current Plan already carries a replan-required corrective decision.`, {
+                taskId: task.id,
+                status: task.status,
+                requiredAction: 'Resolve the blocked strict review or record a replan-required corrective decision first.',
+            });
+        }
+        if (currentContinueFixDecisions.length > 0) {
+            throw new WorkflowError('TRANSITION_BLOCKED', `Task ${task.id} already has a current continue-fix corrective decision; use the current Plan retry path instead of issuing another plan-set.`, {
+                taskId: task.id,
+                requiredAction: 'Run the guarded Step under the current Plan retry path, or escalate/cancel instead of issuing another plan-set at the same ordinal.',
+                decisions: currentContinueFixDecisions.map((event) => ({
+                    eventId: event.eventId,
+                    stepId: event.stepId,
+                    triggeringAttemptCount: event.triggeringAttemptCount,
+                })),
+            });
+        }
+        const currentPlanRiskAudit = task.status === 'needs_fix'
+            ? readCurrentPlanRiskAudit(this.store, task)
+            : null;
+        const failedReviewAttempts = countFailedReviewAttempts(this.store.taskRoot(identity.projectId, taskId));
+        if (task.status === 'needs_fix' && task.review.status === 'failed' && failedReviewAttempts >= 2) {
+            validateCorrectivePlanAudit(task, correctiveAudit, failedReviewAttempts);
+        }
+        const guardedRemediationGate = task.status === 'needs_fix' && currentPlanRiskAudit
+            ? findFailedGuardedStepRequiringCorrectiveDecision(this.store, task, currentPlanRiskAudit)
+            : null;
+        if (guardedRemediationGate && currentReplanDecisions.length === 0 && !correctiveAudit) {
+            throw new WorkflowError('TRANSITION_BLOCKED', `Guarded Step ${guardedRemediationGate.stepId} requires a corrective decision before another remediation run can be authorized.`, {
+                taskId: task.id,
+                stepId: guardedRemediationGate.stepId,
+                attemptCount: guardedRemediationGate.attemptCount,
+                requiredSidecar: 'corrective-decisions.jsonl',
+                allowedDecision: 'continue-fix',
+                escalationDecisions: ['replan-required', 'split-required', 'stop-escalate'],
+            });
+        }
+        if (currentReplanDecisions.length > 0 && correctiveAudit) {
+            throw new WorkflowError('TRANSITION_BLOCKED', `Task ${task.id} already has a current replan-required corrective decision; submit the replacement Plan without recording another decision in plan-set.`, {
+                taskId: task.id,
+                decision: correctiveAudit.decision,
+                requiredAction: 'Retry task plan-set without corrective-audit input; the recorded replan-required decision is the authorization for this recovery path.',
+            });
+        }
+        if (guardedRemediationGate && currentReplanDecisions.length === 0 && correctiveAudit?.decision !== 'continue-fix') {
+            throw new WorkflowError('TRANSITION_BLOCKED', `Guarded Step ${guardedRemediationGate.stepId} requires a separate corrective-decision record before execution may continue; plan-set only supports continue-fix.`, {
+                taskId: task.id,
+                stepId: guardedRemediationGate.stepId,
+                decision: correctiveAudit?.decision ?? null,
+            });
+        }
         for (const requirement of task.requirements) {
             if (!plan.requirements.includes(requirement)) {
                 throw new WorkflowError('TRANSITION_BLOCKED', `Plan omits Task requirement ${requirement}.`);
@@ -454,7 +665,24 @@ export class WorkflowService {
             plannedSteps.every((step) => step.status === 'completed')) {
             throw new WorkflowError('TRANSITION_BLOCKED', 'A failed review requires at least one new or changed remediation Step.');
         }
-        const saved = this.store.writeTask({
+        if (currentReplanRequiredStepIds.some((stepId) => !plannedSteps.some((step) => step.id === stepId))) {
+            throw new WorkflowError('TRANSITION_BLOCKED', `Replacement Plan under replan-required must retain every guarded Step targeted by the current corrective decision; removing or renaming one would reset remediation history.`, {
+                taskId: task.id,
+                requiredStepIds: currentReplanRequiredStepIds,
+                plannedStepIds: plannedSteps.map((step) => step.id),
+            });
+        }
+        if (guardedRemediationGate && currentReplanDecisions.length === 0 && !plannedSteps.some((step) => step.id === guardedRemediationGate.stepId)) {
+            throw new WorkflowError('TRANSITION_BLOCKED', `Continue-fix must retain guarded Step ${guardedRemediationGate.stepId}; removing or renaming it would reset the remediation breaker.`, {
+                taskId: task.id,
+                stepId: guardedRemediationGate.stepId,
+            });
+        }
+        if (correctiveAudit && guardedRemediationGate && currentReplanDecisions.length === 0 && currentPlanRiskAudit) {
+            assertCorrectiveAuditorIndependence(this.store, task, guardedRemediationGate.stepId, correctiveAudit.auditor);
+            appendCorrectiveDecisionEvent(this.store, task, guardedRemediationGate.stepId, correctiveAudit, currentPlanRiskAudit, stagedPlan.hash, this.now());
+        }
+        const candidate = {
             ...task,
             status: 'awaiting_execution_authorization',
             planHash: stagedPlan.hash,
@@ -474,8 +702,16 @@ export class WorkflowService {
             resultHash: null,
             evidenceHash: null,
             blockReason: null,
-        }, expectedRevision);
+        };
+        if (planRiskAudit)
+            validatePlanRiskAuditCandidate(this.store, candidate, planRiskAudit);
+        const saved = this.store.writeTask(candidate, expectedRevision);
         this.store.publishArtifact(stagedPlan);
+        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());
+        }
         return saved;
     }
     rebindTaskKnowledge(repository, taskId, expectedRevision) {
@@ -559,8 +795,62 @@ export class WorkflowService {
         this.store.publishArtifact(stagedPlan);
         return saved;
     }
-    authorizeTask(repository, taskId, expectedRevision, actor, reason = '') {
+    refreshTaskContext(repository, taskId, expectedTaskRevision, expectedKnowledgeMapRevision, actor, delegationGrantId) {
+        if (!delegationGrantId) {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Task context refresh combines approval transitions and therefore requires an explicit delegated approval grant.');
+        }
+        const { identity } = this.context(repository);
+        const task = this.store.readTask(identity.projectId, taskId);
+        const currentMap = this.store.readKnowledgeMap(identity.projectId);
+        assertExpectedRevision(task, expectedTaskRevision);
+        assertExpectedRevision(currentMap, expectedKnowledgeMapRevision);
+        if (!taskCanRebindKnowledge(task)) {
+            throw new WorkflowError('TRANSITION_BLOCKED', `Cannot refresh Task context while Task is ${task.status}.`);
+        }
+        const activeStep = task.steps.find((step) => step.status === 'in_progress');
+        if (activeStep) {
+            throw new WorkflowError('TRANSITION_BLOCKED', `Cannot refresh Task context while ${activeStep.id} is in progress.`);
+        }
+        const inspectedMap = inspectKnowledgeMap(currentMap, scanProjectKnowledge(identity.repositoryRoot, identity.projectId, this.now()));
+        const transitions = [];
+        const currentPlanRiskAudit = readCurrentPlanRiskAudit(this.store, task);
+        // 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 });
+            }
+            assertContentOnlyKnowledgeRefresh(currentMap, inspectedMap);
+            this.delegatedAuthorization(identity.projectId, delegationGrantId, 'project_memory.approve', actor, inspectedMap);
+            knowledgeMap = this.reconcileKnowledgeMap(repository, currentMap.revision);
+            transitions.push('project-memory reconcile');
+            knowledgeMap = this.approveKnowledgeMap(repository, knowledgeMap.revision, [], actor, delegationGrantId);
+            transitions.push('project-memory approve');
+        }
+        const knowledgeMapHash = hashKnowledgeMap(knowledgeMap);
+        if (task.knowledgeMapRevision === knowledgeMap.revision
+            && task.knowledgeMapHash === knowledgeMapHash) {
+            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) {
+            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);
+        transitions.push('task execution authorize');
+        return {
+            mode: 'delegated-content-only',
+            transitions,
+            knowledgeMap,
+            task: refreshedTask,
+        };
+    }
+    authorizeTask(repository, taskId, expectedRevision, actor, reason = '', delegationGrantId = null) {
         const { identity } = this.context(repository);
+        this.readCurrentAdoptionPostureStrict(identity.projectId);
         const task = this.store.readTask(identity.projectId, taskId);
         assertExpectedRevision(task, expectedRevision);
         if (task.status !== 'awaiting_execution_authorization' || !task.planHash) {
@@ -570,6 +860,8 @@ export class WorkflowService {
         const root = this.store.taskRoot(identity.projectId, taskId);
         const briefHash = this.store.hashArtifact(root, 'brief.md');
         const planHash = this.store.hashArtifact(root, 'plan.md');
+        readCurrentPlanRiskAudit(this.store, task, { requireCurrentTaskRevision: true });
+        const delegation = this.delegatedAuthorization(identity.projectId, delegationGrantId, 'task.execution_authorize', actor, task);
         const event = {
             kind: 'execution',
             decision: 'approved',
@@ -581,18 +873,169 @@ export class WorkflowService {
             evidenceHash: null,
             headCommit: null,
             reason,
+            authorizationMode: delegation ? 'delegated' : 'human',
+            ...(delegation ? { delegation } : {}),
         };
         return this.store.writeTask({ ...task, status: 'ready', briefHash, planHash, authorizations: [...task.authorizations, event] }, expectedRevision);
     }
+    recordPlanRiskAudit(repository, taskId, expectedRevision, input) {
+        const { identity } = this.context(repository);
+        this.readCurrentAdoptionPostureStrict(identity.projectId);
+        const task = this.store.readTask(identity.projectId, taskId);
+        assertExpectedRevision(task, expectedRevision);
+        this.assertTaskKnowledgeBinding(identity.repositoryRoot, task);
+        return appendCurrentPlanRiskAudit(this.store, task, input, this.now());
+    }
+    showTaskHandoff(repository, taskId) {
+        const { identity } = this.context(repository);
+        const task = this.store.readTask(identity.projectId, taskId);
+        return {
+            task,
+            posture: readTaskC1Posture(this.store, task),
+            claimTokenAvailable: false,
+        };
+    }
+    handoffTask(repository, taskId, expectedRevision, actor, targetActor, reason, writerToken = null, grantId = null, expiresAt = null) {
+        const context = this.context(repository);
+        const task = this.store.readTask(context.identity.projectId, taskId);
+        assertExpectedRevision(task, expectedRevision);
+        const normalizedActor = actor.trim();
+        if (!normalizedActor) {
+            throw new WorkflowError('INVALID_ARGUMENT', 'Handoff actor is required.');
+        }
+        if (grantId)
+            this.assertHandoffGrant(context.identity.projectId, task, targetActor, grantId);
+        const milestone = task.milestoneId ? this.readMilestoneCurrent(task.projectId, task.milestoneId) : null;
+        const milestones = milestone ? this.listMilestonesCurrent(task.projectId) : [];
+        const milestoneDisplayNumber = milestone
+            ? milestones.findIndex((candidate) => candidate.id === milestone.id) + 1
+            : null;
+        const taskDisplayNumber = milestone
+            ? milestone.memberships.findIndex((membership) => membership.taskId === task.id) + 1
+            : null;
+        const currentLease = context.locks.inspect(taskId);
+        let lease;
+        let acquiredHere = false;
+        if (currentLease) {
+            if (currentLease.owner !== normalizedActor) {
+                throw new WorkflowError('TRANSITION_BLOCKED', `Task ${taskId} active writer lease belongs to a different actor.`, {
+                    taskId,
+                    leaseOwner: currentLease.owner,
+                    actor: normalizedActor,
+                });
+            }
+            if (writerToken === null) {
+                throw new WorkflowError('TRANSITION_BLOCKED', `Task ${taskId} handoff requires the active writer token while a lease is present.`, {
+                    taskId,
+                    leaseOwner: currentLease.owner,
+                    expiresAt: currentLease.expiresAt,
+                });
+            }
+            lease = context.locks.heartbeat(taskId, writerToken);
+        }
+        else {
+            if (writerToken !== null) {
+                throw new WorkflowError('TRANSITION_BLOCKED', `Task ${taskId} has no active writer lease for the provided writer token.`, {
+                    taskId,
+                });
+            }
+            acquiredHere = true;
+            lease = context.locks.acquire(taskId, normalizedActor);
+        }
+        const releaseLease = () => context.locks.release(taskId, lease.token);
+        try {
+            const prepared = appendTaskHandoff(this.store, task, {
+                actor: normalizedActor,
+                targetActor,
+                reason,
+                writerToken: lease.token,
+                milestoneDisplayNumber,
+                taskDisplayNumber,
+                expectedNext: String(nextForTask(task).action ?? 'task show'),
+                grantId,
+                expiresAt: expiresAt ?? new Date(this.now().getTime() + 24 * 60 * 60 * 1000).toISOString(),
+            }, this.now());
+            releaseLease();
+            return { task, event: prepared.event, bundle: prepared.bundle };
+        }
+        catch (error) {
+            if (acquiredHere)
+                releaseLease();
+            throw error;
+        }
+    }
+    claimTask(repository, taskId, expectedRevision, actor, claimToken, writerToken = null) {
+        const context = this.context(repository);
+        const task = this.store.readTask(context.identity.projectId, taskId);
+        assertExpectedRevision(task, expectedRevision);
+        const normalizedActor = actor.trim();
+        if (!normalizedActor) {
+            throw new WorkflowError('INVALID_ARGUMENT', 'Claim actor is required.');
+        }
+        const pendingHandoff = readTaskC1Posture(this.store, task);
+        if (pendingHandoff.state === 'pending' && pendingHandoff.latestEvent.grantId) {
+            this.assertHandoffGrant(context.identity.projectId, task, normalizedActor, pendingHandoff.latestEvent.grantId);
+        }
+        const existingLease = context.locks.inspect(taskId);
+        let lease;
+        let acquiredHere = false;
+        if (existingLease) {
+            if (existingLease.owner !== normalizedActor) {
+                throw new WorkflowError('TRANSITION_BLOCKED', `Task ${taskId} existing writer lease belongs to a different actor.`, {
+                    taskId,
+                    leaseOwner: existingLease.owner,
+                    actor: normalizedActor,
+                });
+            }
+            if (writerToken === null) {
+                throw new WorkflowError('TRANSITION_BLOCKED', `Task ${taskId} claim requires the existing writer token.`, {
+                    taskId,
+                    leaseOwner: existingLease.owner,
+                });
+            }
+            lease = context.locks.heartbeat(taskId, writerToken);
+        }
+        else {
+            if (writerToken !== null) {
+                throw new WorkflowError('TRANSITION_BLOCKED', `Task ${taskId} has no active writer lease for the provided writer token.`, {
+                    taskId,
+                });
+            }
+            acquiredHere = true;
+            lease = context.locks.acquire(taskId, normalizedActor);
+        }
+        try {
+            const event = appendTaskClaim(this.store, task, actor, claimToken, lease.token, this.now());
+            return { task, event, lease };
+        }
+        catch (error) {
+            if (acquiredHere)
+                context.locks.release(taskId, lease.token);
+            throw error;
+        }
+    }
+    handbackTask(repository, taskId, expectedRevision, actor, reason, writerToken = null, limitations = [], recommendedNext = 'Coordinator reviews the terminal Task result and recorded evidence.') {
+        const context = this.context(repository);
+        const task = this.store.readTask(context.identity.projectId, taskId);
+        assertExpectedRevision(task, expectedRevision);
+        const lease = task.status === 'merged' || task.status === 'cancelled'
+            ? context.locks.inspect(taskId)
+            : this.proveWriterLeaseTokenForHandoff(context, taskId, writerToken);
+        const event = appendTaskHandback(this.store, task, actor, reason, lease?.token ?? writerToken, limitations, recommendedNext, this.now());
+        if (lease)
+            context.locks.release(taskId, lease.token);
+        return { task, event };
+    }
     startTask(repository, taskId, expectedRevision, workspaceOwner) {
         const { identity } = this.context(repository);
         const task = this.store.readTask(identity.projectId, taskId);
         assertExpectedRevision(task, expectedRevision);
+        this.requireExecutionAdoptionPosture(identity, taskId);
         if (task.status !== 'ready')
             throw new WorkflowError('TRANSITION_BLOCKED', `Task ${taskId} is ${task.status}.`);
         this.assertExecutionAuthorizationFresh(task);
         if (task.milestoneId) {
-            const milestone = this.store.readMilestone(identity.projectId, task.milestoneId);
+            const milestone = this.readMilestoneCurrent(identity.projectId, task.milestoneId);
             const membership = milestone.memberships.find((candidate) => candidate.taskId === taskId);
             if (milestone.status !== 'active' || membership?.disposition !== 'required') {
                 throw new WorkflowError('TRANSITION_BLOCKED', 'Milestone-linked Task requires an active, authorized membership.', {
@@ -601,6 +1044,15 @@ export class WorkflowService {
                     disposition: membership?.disposition ?? null,
                 });
             }
+            const handoffPosture = readTaskC1Posture(this.store, task);
+            if (handoffPosture.state !== 'claimed') {
+                throw new WorkflowError('TRANSITION_BLOCKED', 'Milestone-linked Task start requires a prepared and claimed C1 handoff bundle.', {
+                    taskId: task.id,
+                    milestoneId: milestone.id,
+                    c1Posture: handoffPosture.state,
+                    requiredAction: handoffPosture.state === 'pending' ? 'Claim the prepared handoff.' : 'Prepare and claim a C1 handoff.',
+                });
+            }
         }
         if (!isClean(identity.repositoryRoot)) {
             throw new WorkflowError('GIT_PRECONDITION_FAILED', 'Task start requires a clean checkout.', {
@@ -626,20 +1078,48 @@ export class WorkflowService {
         }
         return this.store.writeTask({ ...task, baseCommit, taskBranch, workspaceOwner, blockReason: null }, expectedRevision);
     }
-    runStep(repository, taskId, stepId, expectedRevision, owner, writerToken) {
+    runStep(repository, taskId, stepId, expectedRevision, actor, writerToken) {
         const context = this.context(repository);
         const task = this.store.readTask(context.identity.projectId, taskId);
         assertExpectedRevision(task, expectedRevision);
+        this.requireExecutionAdoptionPosture(context.identity, taskId);
         if (!['ready', 'in_progress', 'needs_fix'].includes(task.status)) {
             throw new WorkflowError('TRANSITION_BLOCKED', `Task ${taskId} cannot run a Step while ${task.status}.`);
         }
         this.assertExecutionAuthorizationFresh(task);
         const knowledgeMap = this.assertTaskKnowledgeBinding(context.identity.repositoryRoot, task);
+        const currentPlanBlockingDecisions = readCorrectiveDecisionEvents(this.store, task)
+            .filter((event) => event.planHash === task.planHash && event.decision !== 'continue-fix');
+        if (currentPlanBlockingDecisions.length > 0) {
+            throw new WorkflowError('TRANSITION_BLOCKED', `Task ${taskId} cannot run any Step while the current Plan has active blocking corrective decisions.`, {
+                taskId,
+                decisions: currentPlanBlockingDecisions.map((event) => ({
+                    eventId: event.eventId,
+                    stepId: event.stepId,
+                    decision: event.decision,
+                    planHash: event.planHash,
+                    triggeringAttemptCount: event.triggeringAttemptCount,
+                })),
+            });
+        }
         assertTaskBranch(context.identity.repositoryRoot, task);
         const step = requireStep(task, stepId);
+        const remediationHistoryForStep = readRemediationEvents(this.store, task).filter((event) => event.stepId === stepId);
         if (!['planned', 'failed'].includes(step.status)) {
             throw new WorkflowError('TRANSITION_BLOCKED', `${stepId} cannot start from ${step.status}.`);
         }
+        const planRiskAudit = readCurrentPlanRiskAudit(this.store, task);
+        if (remediationHistoryForStep.length > 0 && (!planRiskAudit || !isStepReviewRequired(task, stepId, planRiskAudit.reviewRequiredStepIds))) {
+            throw new WorkflowError('TRANSITION_BLOCKED', `Step ${stepId} has remediation history but is no longer marked for guarded review by the current Plan Risk Audit; execution is blocked until the audit and Step posture are reconciled.`, {
+                taskId,
+                stepId,
+                remediationAttemptCount: remediationHistoryForStep.length,
+                currentAuditPresent: Boolean(planRiskAudit),
+            });
+        }
+        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.`, {
@@ -658,18 +1138,41 @@ export class WorkflowService {
                 incompleteDependencies,
             });
         }
+        const handoffPosture = readTaskC1Posture(this.store, task);
+        if (handoffPosture.state === 'pending') {
+            this.assertTaskMutationAllowedByHandoff(task, actor, null);
+        }
         const existing = context.locks.inspect(taskId);
         let acquiredHere = false;
-        const lease = existing
-            ? writerToken
-                ? context.locks.heartbeat(taskId, writerToken)
+        let lease;
+        if (handoffPosture.state === 'claimed') {
+            if (!existing) {
+                throw new WorkflowError('TRANSITION_BLOCKED', `Task ${taskId} claimed C1 posture requires an active writer lease before task run.`, {
+                    taskId,
+                    claimant: handoffPosture.claimant,
+                });
+            }
+            if (!writerToken) {
+                throw new WorkflowError('TRANSITION_BLOCKED', `Task ${taskId} claimed C1 posture requires the bound writer token for task run.`, {
+                    taskId,
+                    claimant: handoffPosture.claimant,
+                });
+            }
+            lease = context.locks.heartbeat(taskId, writerToken);
+            this.assertTaskMutationAllowedByHandoff(task, actor, lease.token);
+        }
+        else {
+            lease = existing
+                ? writerToken
+                    ? context.locks.heartbeat(taskId, writerToken)
+                    : (() => {
+                        throw new WorkflowError('LOCKED', `${taskId} already has a writer.`, { owner: existing.owner });
+                    })()
                 : (() => {
-                    throw new WorkflowError('LOCKED', `${taskId} already has a writer.`, { owner: existing.owner });
-                })()
-            : (() => {
-                acquiredHere = true;
-                return context.locks.acquire(taskId, owner.trim() || 'worker');
-            })();
+                    acquiredHere = true;
+                    return context.locks.acquire(taskId, actor.trim() || 'worker');
+                })();
+        }
         const steps = task.steps.map((candidate) => candidate.id === stepId ? { ...candidate, status: 'in_progress' } : candidate);
         let saved;
         try {
@@ -687,7 +1190,7 @@ export class WorkflowService {
                 protocolVersion: PROTOCOL_VERSION,
                 packageVersion: PACKAGE_VERSION,
                 role: 'worker',
-                objective: step.objective,
+                objective: `${step.objective} Leave all Step changes uncommitted; Workflow core creates the atomic commit through task step-complete.`,
                 inputs: [
                     path.join(this.store.taskRoot(task.projectId, task.id), 'brief.md'),
                     path.join(this.store.taskRoot(task.projectId, task.id), 'plan.md'),
@@ -695,7 +1198,10 @@ export class WorkflowService {
                 allowedReads: [identityRelative(context.identity.repositoryRoot, '.')],
                 allowedWrites: step.allowedWrites,
                 commands: step.checks,
-                forbiddenScope: step.forbiddenScope,
+                forbiddenScope: [
+                    ...step.forbiddenScope,
+                    'Manual Git staging, commits, amendments, resets, rebases, or other history mutations. Workflow core owns the Step commit.',
+                ],
                 resultSchema: {
                     type: 'object',
                     required: ['summary', 'changedFiles', 'checks'],
@@ -709,6 +1215,7 @@ export class WorkflowService {
                     'Required change falls outside allowedWrites.',
                     'Implementation requires changing Brief, Plan, or acceptance.',
                     'A configured check cannot be run or interpreted safely.',
+                    'Do not run git add or git commit. Return uncommitted changes to the coordinator, which must invoke task step-complete.',
                 ],
                 contextBudget: 'medium',
                 taskId,
@@ -727,6 +1234,14 @@ export class WorkflowService {
             ? this.requireActiveKnowledgeMap(identity.repositoryRoot, identity.projectId)
             : this.assertTaskKnowledgeBinding(identity.repositoryRoot, task);
         const root = this.store.taskRoot(task.projectId, task.id);
+        const planRiskAudit = task.planHash && !['planning', 'merged', 'cancelled'].includes(task.status)
+            ? readCurrentPlanRiskAudit(this.store, task)
+            : null;
+        const planRiskReviewScope = planRiskAudit
+            ? planRiskAudit.reviewRequiredStepIds.length > 0
+                ? ` Current Plan Risk Audit marks ${planRiskAudit.reviewRequiredStepIds.join(', ')} for strict review.`
+                : ' Current Plan Risk Audit marks no Steps for strict review.'
+            : '';
         const common = {
             protocolVersion: PROTOCOL_VERSION,
             packageVersion: PACKAGE_VERSION,
@@ -748,17 +1263,25 @@ export class WorkflowService {
         if (role === 'technical-planner') {
             return {
                 ...common,
-                objective: `Produce an execution-ready Plan for ${task.title}.`,
+                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}`,
                 resultSchema: {
                     type: 'object',
                     required: ['objective', 'requirements', 'acceptance', 'risks', 'steps'],
                 },
+                stopConditions: [
+                    ...common.stopConditions,
+                    'A migration is planned without a populated forward-upgrade check.',
+                    '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.',
+                    'The safe risk slice crosses persistence, recovery orchestration, and executable composition and should be split.',
+                ],
             };
         }
         if (role === 'independent-reviewer') {
             return {
                 ...common,
-                objective: `Review ${task.title} against Brief, Plan, diff, checks, and evidence without modifying files.`,
+                objective: `Review ${task.title} against Brief, Plan, diff, checks, and evidence without modifying files.${planRiskReviewScope}`,
                 inputs: [...common.inputs, ...(task.evidenceHash ? [path.join(root, 'evidence.json')] : [])],
                 resultSchema: {
                     type: 'object',
@@ -768,28 +1291,65 @@ export class WorkflowService {
                     ...common.stopConditions,
                     'The checkout is dirty or the evidence does not identify the reviewed commit.',
                     'Read-only reviewer isolation cannot be established; return unverified.',
+                    'High-risk behavior lacks populated-upgrade, race, restart/replay, crash-window, or provider-failure evidence required by the Plan.',
                 ],
             };
         }
         return {
             ...common,
-            objective: `Coordinate the next valid state transition for ${task.title}.`,
+            objective: `Coordinate the next valid state transition for ${task.title}.${planRiskReviewScope}`,
             resultSchema: { type: 'object', required: ['recommendedAction', 'reason'] },
         };
     }
-    completeStep(repository, taskId, stepId, expectedRevision, writerToken, notes) {
+    completeStep(repository, taskId, stepId, expectedRevision, writerToken, notes, actor) {
         const context = this.context(repository);
-        context.locks.heartbeat(taskId, writerToken);
+        const lease = context.locks.heartbeat(taskId, writerToken);
+        this.readCurrentAdoptionPostureStrict(context.identity.projectId);
         const task = this.store.readTask(context.identity.projectId, taskId);
         assertExpectedRevision(task, expectedRevision);
+        this.assertTaskMutationAllowedByHandoff(task, actor ?? null, lease.token);
         assertTaskBranch(context.identity.repositoryRoot, task);
         const step = requireStep(task, stepId);
         if (task.status !== 'in_progress' || step.status !== 'in_progress') {
             throw new WorkflowError('TRANSITION_BLOCKED', `${stepId} is not in progress.`);
         }
+        const planRiskAudit = readCurrentPlanRiskAudit(this.store, task);
+        const reviewRequired = planRiskAudit
+            ? isStepReviewRequired(task, stepId, planRiskAudit.reviewRequiredStepIds)
+            : false;
+        if (reviewRequired && step.evidence) {
+            validateTaskHistory(context.identity.repositoryRoot, task);
+            if (!isClean(context.identity.repositoryRoot)) {
+                throw new WorkflowError('GIT_PRECONDITION_FAILED', 'Strict Step Review recovery requires a clean Task checkout.', {
+                    changedFiles: changedFiles(context.identity.repositoryRoot),
+                });
+            }
+            const currentHead = headCommit(context.identity.repositoryRoot);
+            if (currentHead !== step.evidence.commitSha) {
+                throw new WorkflowError('GIT_PRECONDITION_FAILED', 'Strict Step Review recovery requires HEAD to remain at the recorded completion commit.', {
+                    stepId,
+                    expectedCommit: step.evidence.commitSha,
+                    actualCommit: currentHead,
+                });
+            }
+            const currentCycle = buildCurrentStrictStepReviewCycle(this.store, task, stepId);
+            if (!currentCycle.pendingEvent && !currentCycle.latestMatchingEvent) {
+                ensurePendingStrictStepReview(this.store, task, stepId, this.now());
+            }
+            return task;
+        }
+        validateTaskHistory(context.identity.repositoryRoot, task);
         const checks = runChecks(context.identity.repositoryRoot, step.checks);
         const failed = checks.filter((check) => !check.passed);
         if (failed.length > 0) {
+            if (reviewRequired && planRiskAudit) {
+                appendRemediationEvent(this.store, task, stepId, 'checks-failed', {
+                    completionCommit: headCommit(context.identity.repositoryRoot),
+                    checksHash: sha256Hex(canonicalJsonStringify(checks)),
+                    reviewEventHash: null,
+                    reviewerAttestationHash: null,
+                }, planRiskAudit, this.now());
+            }
             const steps = task.steps.map((candidate) => candidate.id === stepId ? { ...candidate, status: 'failed' } : candidate);
             return this.store.writeTask({ ...task, status: 'needs_fix', steps, blockReason: `${stepId} checks failed.` }, expectedRevision);
         }
@@ -801,6 +1361,18 @@ export class WorkflowService {
             checks,
             notes,
         };
+        if (reviewRequired) {
+            const saved = this.store.writeTask({
+                ...task,
+                status: 'in_progress',
+                steps: task.steps.map((candidate) => candidate.id === stepId
+                    ? { ...candidate, status: 'in_progress', evidence }
+                    : candidate),
+                blockReason: null,
+            }, expectedRevision);
+            ensurePendingStrictStepReview(this.store, saved, stepId, this.now());
+            return saved;
+        }
         const completedIds = new Set([
             ...task.steps.filter((candidate) => candidate.status === 'completed').map((candidate) => candidate.id),
             stepId,
@@ -815,11 +1387,111 @@ export class WorkflowService {
         });
         return this.store.writeTask({ ...task, status: 'in_progress', steps, blockReason: null }, expectedRevision);
     }
-    submitTask(repository, taskId, expectedRevision, writerToken) {
+    reviewStep(repository, taskId, stepId, expectedRevision, runner, actor, writerToken = null) {
         const context = this.context(repository);
-        context.locks.heartbeat(taskId, writerToken);
+        this.readCurrentAdoptionPostureStrict(context.identity.projectId);
         const task = this.store.readTask(context.identity.projectId, taskId);
         assertExpectedRevision(task, expectedRevision);
+        this.proveOptionalWriterLeaseToken(context, taskId, writerToken);
+        this.assertTaskMutationAllowedByHandoff(task, actor ?? null, writerToken);
+        if (task.status !== 'in_progress' && task.status !== 'blocked') {
+            throw new WorkflowError('TRANSITION_BLOCKED', `Strict Step Review cannot run while task ${taskId} is ${task.status}.`);
+        }
+        assertTaskBranch(context.identity.repositoryRoot, task);
+        this.assertTaskKnowledgeBinding(context.identity.repositoryRoot, task);
+        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.`, {
+                taskId: task.id,
+                stepId,
+            });
+        }
+        const step = requireStep(task, stepId);
+        if (step.status !== 'in_progress' || !step.evidence) {
+            throw new WorkflowError('TRANSITION_BLOCKED', `Strict Step Review requires ${stepId} to remain in progress with canonical evidence.`, {
+                taskId: task.id,
+                stepId,
+                stepStatus: step.status,
+            });
+        }
+        validateTaskHistory(context.identity.repositoryRoot, task);
+        if (!isClean(context.identity.repositoryRoot)) {
+            throw new WorkflowError('GIT_PRECONDITION_FAILED', 'Strict Step Review requires a clean Task checkout.', {
+                changedFiles: changedFiles(context.identity.repositoryRoot),
+            });
+        }
+        const currentHead = headCommit(context.identity.repositoryRoot);
+        if (currentHead !== step.evidence.commitSha) {
+            throw new WorkflowError('GIT_PRECONDITION_FAILED', 'Strict Step Review requires HEAD to remain at the recorded completion commit.', {
+                taskId: task.id,
+                stepId,
+                expectedCommit: step.evidence.commitSha,
+                actualCommit: currentHead,
+            });
+        }
+        const currentCycle = buildCurrentStrictStepReviewCycle(this.store, task, stepId);
+        if (task.status === 'blocked') {
+            if (currentCycle.resolution !== 'unverified') {
+                throw new WorkflowError('TRANSITION_BLOCKED', `Strict Step Review retry requires ${stepId} to be blocked by an unverified prior cycle.`, {
+                    taskId: task.id,
+                    stepId,
+                    resolution: currentCycle.resolution,
+                });
+            }
+            assertGuardedRemediationAttemptAllowed(this.store, task, stepId, planRiskAudit);
+        }
+        else if (currentCycle.resolution !== 'pending') {
+            if (currentCycle.resolution === 'failed' || currentCycle.resolution === 'unverified') {
+                if (!currentCycle.reviewRecordedEvent || !currentCycle.reviewerAttestationEvent) {
+                    throw new WorkflowError('STATE_CORRUPT', 'Strict Step Review recovery requires exact review and attestation sidecars.', {
+                        taskId: task.id,
+                        stepId,
+                        resolution: currentCycle.resolution,
+                    });
+                }
+                appendRemediationEvent(this.store, task, stepId, currentCycle.resolution === 'failed' ? 'review-failed' : 'review-unverified', {
+                    completionCommit: currentCycle.reviewRecordedEvent.completionCommit,
+                    checksHash: currentCycle.reviewRecordedEvent.checksHash,
+                    reviewEventHash: currentCycle.reviewRecordedEvent.eventHash,
+                    reviewerAttestationHash: currentCycle.reviewerAttestationEvent.eventHash,
+                }, planRiskAudit, this.now());
+            }
+            return this.store.writeTask(applyStrictStepReviewResolution(task, stepId, currentCycle.resolution), expectedRevision);
+        }
+        ensurePendingStrictStepReview(this.store, task, stepId, this.now());
+        const envelope = this.taskContext(repository, taskId, 'independent-reviewer');
+        const 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,
+            reviewerOutputHash: launch.reviewerOutputHash,
+            reviewedCommit: launch.reviewedCommit,
+            isolationResult: launch.verifiedIsolation ? 'verified' : 'unverified',
+        }, this.now());
+        if (recorded.resolution === 'failed' || recorded.resolution === 'unverified') {
+            const reviewRecordedEvent = recorded.reviewRecordedEvent;
+            const reviewerAttestationEvent = recorded.reviewerAttestationEvent;
+            if (!reviewRecordedEvent || !reviewerAttestationEvent) {
+                throw new WorkflowError('STATE_CORRUPT', 'Strict Step Review remediation recording requires review and attestation sidecars.', {
+                    taskId: task.id,
+                    stepId,
+                    resolution: recorded.resolution,
+                });
+            }
+            appendRemediationEvent(this.store, task, stepId, recorded.resolution === 'failed' ? 'review-failed' : 'review-unverified', {
+                completionCommit: reviewRecordedEvent.completionCommit,
+                checksHash: reviewRecordedEvent.checksHash,
+                reviewEventHash: reviewRecordedEvent.eventHash,
+                reviewerAttestationHash: reviewerAttestationEvent.eventHash,
+            }, planRiskAudit, this.now());
+        }
+        return this.store.writeTask(applyStrictStepReviewResolution(task, stepId, recorded.resolution, launch.review.summary), expectedRevision);
+    }
+    submitTask(repository, taskId, expectedRevision, writerToken, actor) {
+        const context = this.context(repository);
+        const lease = context.locks.heartbeat(taskId, writerToken);
+        const task = this.store.readTask(context.identity.projectId, taskId);
+        assertExpectedRevision(task, expectedRevision);
+        this.assertTaskMutationAllowedByHandoff(task, actor ?? null, lease.token);
         assertTaskBranch(context.identity.repositoryRoot, task);
         if (!['in_progress', 'ready'].includes(task.status)) {
             throw new WorkflowError('TRANSITION_BLOCKED', `Task ${taskId} cannot be submitted while ${task.status}.`);
@@ -846,10 +1518,13 @@ export class WorkflowService {
         this.store.publishArtifact(stagedEvidence);
         return saved;
     }
-    recordReview(repository, taskId, expectedRevision, review) {
+    recordReview(repository, taskId, expectedRevision, review, actor, writerToken = null) {
         const { identity } = this.context(repository);
+        this.readCurrentAdoptionPostureStrict(identity.projectId);
         const task = this.store.readTask(identity.projectId, taskId);
         assertExpectedRevision(task, expectedRevision);
+        this.proveOptionalWriterLeaseToken(this.context(repository), taskId, writerToken);
+        this.assertTaskMutationAllowedByHandoff(task, actor ?? null, writerToken);
         const retryingUnverified = task.status === 'blocked' && task.review.status === 'unverified';
         if (task.status !== 'validating' && !retryingUnverified) {
             throw new WorkflowError('TRANSITION_BLOCKED', `Task ${taskId} is not ready for review.`);
@@ -873,7 +1548,11 @@ export class WorkflowService {
         if (recorded.findings.length > 0) {
             const file = path.join(this.store.taskRoot(task.projectId, task.id), 'findings.jsonl');
             for (const finding of recorded.findings) {
-                appendFileSync(file, `${JSON.stringify({ ...finding, recordedAt: recorded.recordedAt })}\n`, {
+                appendFileSync(file, `${JSON.stringify({
+                    ...finding,
+                    reviewer: recorded.reviewer,
+                    recordedAt: recorded.recordedAt,
+                })}\n`, {
                     encoding: 'utf8',
                     mode: 0o600,
                 });
@@ -881,6 +1560,59 @@ export class WorkflowService {
         }
         return saved;
     }
+    recordStepCorrectiveDecision(repository, taskId, stepId, expectedRevision, correctiveAudit, actor, writerToken = null) {
+        const { identity } = this.context(repository);
+        this.readCurrentAdoptionPostureStrict(identity.projectId);
+        const task = this.store.readTask(identity.projectId, taskId);
+        assertExpectedRevision(task, expectedRevision);
+        this.proveOptionalWriterLeaseToken(this.context(repository), taskId, writerToken);
+        this.assertTaskMutationAllowedByHandoff(task, actor ?? null, writerToken);
+        if (task.status !== 'needs_fix' && task.status !== 'blocked') {
+            throw new WorkflowError('TRANSITION_BLOCKED', `Task ${taskId} cannot record a corrective decision while ${task.status}.`);
+        }
+        const planRiskAudit = readCurrentPlanRiskAudit(this.store, task);
+        if (!planRiskAudit) {
+            throw new WorkflowError('TRANSITION_BLOCKED', `Task ${taskId} has no current Plan Risk Audit for corrective decision recording.`, {
+                taskId,
+                stepId,
+            });
+        }
+        if (!task.planHash) {
+            throw new WorkflowError('STATE_CORRUPT', `Task ${taskId} has no current Plan hash for corrective decision recording.`, {
+                taskId,
+                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 (task.status === 'needs_fix') {
+            if (step.status !== 'failed') {
+                throw new WorkflowError('TRANSITION_BLOCKED', `Corrective decision for ${stepId} requires a currently failed guarded Step while task ${taskId} is needs_fix.`, {
+                    taskId,
+                    stepId,
+                    stepStatus: step.status,
+                });
+            }
+        }
+        else {
+            const currentCycle = buildCurrentStrictStepReviewCycle(this.store, task, stepId);
+            if (step.status !== 'in_progress' || !step.evidence || currentCycle.resolution !== 'unverified') {
+                throw new WorkflowError('TRANSITION_BLOCKED', `Corrective decision for ${stepId} requires a blocked unverified guarded Step with current evidence.`, {
+                    taskId,
+                    stepId,
+                    stepStatus: step.status,
+                    resolution: currentCycle.resolution,
+                });
+            }
+        }
+        assertCorrectiveAuditorIndependence(this.store, task, stepId, correctiveAudit.auditor);
+        return appendCorrectiveDecisionEvent(this.store, task, stepId, correctiveAudit, planRiskAudit, task.planHash, this.now());
+    }
     setTaskResult(repository, taskId, expectedRevision, summary, limitations) {
         const { identity } = this.context(repository);
         const task = this.store.readTask(identity.projectId, taskId);
@@ -895,7 +1627,7 @@ export class WorkflowService {
         this.store.publishArtifact(stagedResult);
         return saved;
     }
-    acceptTask(repository, taskId, expectedRevision, actor) {
+    acceptTask(repository, taskId, expectedRevision, actor, delegationGrantId = null) {
         const { identity } = this.context(repository);
         const task = this.store.readTask(identity.projectId, taskId);
         assertExpectedRevision(task, expectedRevision);
@@ -910,6 +1642,7 @@ export class WorkflowService {
         this.assertReviewFresh(identity.repositoryRoot, task);
         const resultHash = this.store.hashArtifact(root, 'result.md');
         const evidenceHash = this.store.hashArtifact(root, 'evidence.json');
+        const delegation = this.delegatedAuthorization(identity.projectId, delegationGrantId, 'task.final_accept', actor, task);
         const event = {
             kind: 'final_acceptance',
             decision: 'approved',
@@ -921,6 +1654,8 @@ export class WorkflowService {
             evidenceHash,
             headCommit: headCommit(identity.repositoryRoot),
             reason: '',
+            authorizationMode: delegation ? 'delegated' : 'human',
+            ...(delegation ? { delegation } : {}),
         };
         return this.store.writeTask({
             ...task,
@@ -982,10 +1717,12 @@ export class WorkflowService {
         this.store.publishArtifact(stagedEvidence);
         return saved;
     }
-    mergeTask(repository, taskId, expectedRevision, writerToken) {
+    mergeTask(repository, taskId, expectedRevision, writerToken, actor) {
         const context = this.context(repository);
         const task = this.store.readTask(context.identity.projectId, taskId);
         assertExpectedRevision(task, expectedRevision);
+        const lease = context.locks.heartbeat(taskId, writerToken);
+        this.assertTaskMutationAllowedByHandoff(task, actor ?? null, lease.token);
         if (task.status !== 'merging' || task.workspaceOwner !== 'local' || !task.taskBranch || !task.baseCommit) {
             throw new WorkflowError('TRANSITION_BLOCKED', `Task ${taskId} is not ready for a local merge.`);
         }
@@ -1002,10 +1739,12 @@ export class WorkflowService {
         context.locks.release(taskId, writerToken);
         return saved;
     }
-    confirmExternalMerge(repository, taskId, expectedRevision, writerToken) {
+    confirmExternalMerge(repository, taskId, expectedRevision, writerToken, actor) {
         const context = this.context(repository);
         const task = this.store.readTask(context.identity.projectId, taskId);
         assertExpectedRevision(task, expectedRevision);
+        const lease = context.locks.heartbeat(taskId, writerToken);
+        this.assertTaskMutationAllowedByHandoff(task, actor ?? null, lease.token);
         if (task.status !== 'ready_to_merge' || task.workspaceOwner !== 'external') {
             throw new WorkflowError('TRANSITION_BLOCKED', `Task ${taskId} is not awaiting external merge confirmation.`);
         }
@@ -1019,11 +1758,91 @@ export class WorkflowService {
     }
     status(repository) {
         const { identity } = this.context(repository);
+        const tasks = this.store.listTasks(identity.projectId);
+        const rawMilestones = this.store.listMilestones(identity.projectId);
+        const adoption = this.inspectAdoptionPreparation(identity, tasks, rawMilestones);
         return {
             projectId: identity.projectId,
             discoveries: this.store.listDiscoveries(identity.projectId),
-            tasks: this.store.listTasks(identity.projectId),
-            milestones: this.store.listMilestones(identity.projectId),
+            tasks,
+            milestones: this.listMilestonesCurrent(identity.projectId, adoption.currentPosture),
+            delegations: this.store.listDelegations(identity.projectId),
+            adoption,
+        };
+    }
+    recoverMilestoneTransactions(repository) {
+        const { identity } = this.context(repository);
+        const milestones = this.listMilestonesCurrent(identity.projectId, readCurrentAdoptionPosture(this.store, identity.projectId));
+        return {
+            projectId: identity.projectId,
+            recoveredMilestoneIds: milestones.map((milestone) => milestone.id),
+        };
+    }
+    prepareAdoption(repository) {
+        const { identity } = this.context(repository);
+        return this.inspectAdoptionPreparation(identity, this.store.listTasks(identity.projectId), this.store.listMilestones(identity.projectId));
+    }
+    applyAdoption(repository, actor, confirmationCode) {
+        const context = this.context(repository);
+        const tasks = context.store.listTasks(context.identity.projectId);
+        const milestones = context.store.listMilestones(context.identity.projectId);
+        return applyAdoptionPosture(this.store, {
+            projectId: context.identity.projectId,
+            repositoryIdentity: context.identity,
+            packageVersion: PACKAGE_VERSION,
+            protocolVersion: PROTOCOL_VERSION,
+            stateSchemaVersion: STATE_SCHEMA_VERSION,
+            tasks,
+            milestones,
+            sidecarInventory: this.collectAdoptionSidecarInventory(context.identity.projectId, tasks, milestones),
+            blockers: this.computeAdoptionBoundaryBlockers(context.identity, tasks, context.locks.list()),
+            now: this.now(),
+        }, actor, confirmationCode);
+    }
+    updatePreflight(repository) {
+        const context = this.context(repository);
+        const tasks = context.store.listTasks(context.identity.projectId);
+        const milestones = context.store.listMilestones(context.identity.projectId);
+        const dirty = changedFiles(context.identity.repositoryRoot);
+        const runningSteps = tasks.flatMap((task) => task.steps
+            .filter((step) => step.status === 'in_progress')
+            .map((step) => ({ taskId: task.id, stepId: step.id })));
+        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 blockers = [
+            ...(dirty.length > 0 ? ['Repository checkout is not clean.'] : []),
+            ...(runningSteps.length > 0 ? ['At least one Worker Step is in progress.'] : []),
+            ...(activeLeases.length > 0 ? ['At least one writer lease is active.'] : []),
+            ...(staleLeases.length > 0 ? ['At least one stale writer lease requires explicit repair.'] : []),
+        ];
+        const adoption = buildAdoptionPreparation({
+            projectId: context.identity.projectId,
+            repositoryIdentity: context.identity,
+            packageVersion: PACKAGE_VERSION,
+            protocolVersion: PROTOCOL_VERSION,
+            stateSchemaVersion: STATE_SCHEMA_VERSION,
+            tasks,
+            milestones,
+            sidecarInventory: this.collectAdoptionSidecarInventory(context.identity.projectId, tasks, milestones),
+            blockers,
+            now: this.now(),
+        }, readCurrentAdoptionPosture(this.store, context.identity.projectId));
+        return {
+            safe: blockers.length === 0,
+            packageVersion: PACKAGE_VERSION,
+            protocolVersion: PROTOCOL_VERSION,
+            stateSchemaVersion: STATE_SCHEMA_VERSION,
+            projectId: context.identity.projectId,
+            repositoryRoot: context.identity.repositoryRoot,
+            clean: dirty.length === 0,
+            changedFiles: dirty,
+            runningSteps,
+            activeLeases,
+            staleLeases,
+            blockers,
+            adoption,
         };
     }
     scanKnowledgeMap(repository) {
@@ -1049,12 +1868,21 @@ export class WorkflowService {
         const scanned = scanProjectKnowledge(identity.repositoryRoot, identity.projectId, this.now());
         return inspectKnowledgeMap(current, scanned);
     }
-    approveKnowledgeMap(repository, expectedRevision, selections, actor) {
+    approveKnowledgeMap(repository, expectedRevision, selections, actor, delegationGrantId = null) {
         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 approved = applyKnowledgeSelections(inspected, selections, actor, this.now());
+        if (!approved.approval) {
+            throw new WorkflowError('STATE_CORRUPT', 'Knowledge Map approval was not recorded.');
+        }
+        approved.approval = {
+            ...approved.approval,
+            authorizationMode: delegation ? 'delegated' : 'human',
+            ...(delegation ? { delegation } : {}),
+        };
         return this.store.writeKnowledgeMap(approved, expectedRevision);
     }
     reconcileKnowledgeMap(repository, expectedRevision) {
@@ -1090,29 +1918,73 @@ export class WorkflowService {
     }
     next(repository) {
         const status = this.status(repository);
+        const adoptionInfo = {
+            status: status.adoption.status,
+            safe: status.adoption.safe,
+            blockers: status.adoption.blockers,
+            baselineDigestHash: status.adoption.baselineDigestHash,
+            sidecarBaselineHash: status.adoption.sidecarBaselineHash,
+            confirmationCodeBindingHash: status.adoption.confirmationCodeBindingHash,
+            confirmationCode: status.adoption.confirmationCode,
+            currentEventType: status.adoption.currentPosture?.eventType ?? null,
+        };
+        if (status.adoption.status !== 'applied') {
+            return {
+                scope: 'project',
+                projectId: status.projectId,
+                status: status.adoption.status,
+                action: status.adoption.safe ? 'state adoption-apply' : 'restore safe boundary, then state adoption-prepare',
+                adoption: adoptionInfo,
+            };
+        }
+        const withAdoption = (value) => ({ ...value, adoption: adoptionInfo });
         const repositoryRoot = resolveRepositoryIdentity(repository).repositoryRoot;
         const milestonesById = new Map(status.milestones.map((milestone) => [milestone.id, milestone]));
         const activeTask = status.tasks.find((task) => taskIsActionableFromRepositoryNext(task, milestonesById));
         if (activeTask) {
             if (!taskCanRebindKnowledge(activeTask) && activeTask.status !== 'planning') {
-                return nextForTask(activeTask);
+                const planRiskAudit = activeTask.planHash
+                    ? readCurrentPlanRiskAudit(this.store, activeTask)
+                    : null;
+                return withAdoption(this.nextForTaskWithDelegation(status.projectId, activeTask, planRiskAudit));
             }
             const knowledgeMap = this.knowledgeMapStatus(repository);
             if (knowledgeMap.status !== 'active' || !knowledgeMap.approval) {
-                return {
+                const action = knowledgeMap.status === 'stale' ? 'project-memory reconcile' : 'project-memory approve';
+                const delegatedApprovalOptions = action === 'project-memory approve'
+                    ? this.delegatedApprovalOptions(status.projectId, 'project_memory.approve', knowledgeMap)
+                    : [];
+                const storedKnowledgeMap = this.store.readKnowledgeMap(status.projectId);
+                const contextRefreshOptions = action === 'project-memory reconcile'
+                    && storedKnowledgeMap.status === 'active'
+                    && storedKnowledgeMap.approval
+                    && isContentOnlyKnowledgeRefresh(storedKnowledgeMap, knowledgeMap)
+                    ? this.delegatedContextRefreshOptions(status.projectId, activeTask, knowledgeMap)
+                    : [];
+                return withAdoption({
                     scope: 'project-memory',
                     status: knowledgeMap.status,
-                    action: knowledgeMap.status === 'stale' ? 'project-memory reconcile' : 'project-memory approve',
+                    action,
                     revision: knowledgeMap.revision,
                     taskId: activeTask.id,
-                };
+                    ...(delegatedApprovalOptions.length > 0 ? { delegatedApprovalOptions } : {}),
+                    ...(contextRefreshOptions.length > 0
+                        ? {
+                            contextRefresh: {
+                                action: 'task context-refresh',
+                                mode: 'delegated-content-only',
+                                options: contextRefreshOptions,
+                            },
+                        }
+                        : {}),
+                });
             }
             const knowledgeMapHash = hashKnowledgeMap(knowledgeMap);
             if (taskCanRebindKnowledge(activeTask) &&
                 activeTask.planHash &&
                 (activeTask.knowledgeMapRevision !== knowledgeMap.revision ||
                     activeTask.knowledgeMapHash !== knowledgeMapHash)) {
-                return {
+                return withAdoption({
                     scope: 'task',
                     id: activeTask.id,
                     status: activeTask.status,
@@ -1120,9 +1992,12 @@ export class WorkflowService {
                     revision: activeTask.revision,
                     knowledgeMapRevision: knowledgeMap.revision,
                     knowledgeMapHash,
-                };
+                });
             }
-            return nextForTask(activeTask);
+            const planRiskAudit = activeTask.planHash && activeTask.status !== 'planning'
+                ? readCurrentPlanRiskAudit(this.store, activeTask)
+                : null;
+            return withAdoption(this.nextForTaskWithDelegation(status.projectId, activeTask, planRiskAudit));
         }
         const activeMilestone = status.milestones.find((milestone) => !['accepted', 'cancelled'].includes(milestone.status));
         if (activeMilestone) {
@@ -1140,43 +2015,241 @@ export class WorkflowService {
                     evidence.headCommit !== currentHead ||
                     resultHash !== activeMilestone.resultHash ||
                     evidenceHash !== activeMilestone.evidenceHash) {
-                    return {
+                    return withAdoption({
                         scope: 'milestone',
                         id: activeMilestone.id,
                         status: activeMilestone.status,
                         action: 'restore clean base, then milestone validate',
                         revision: activeMilestone.revision,
                         reason: 'final validation evidence is stale',
-                    };
+                    });
                 }
-                return {
+                const delegatedApprovalOptions = this.delegatedApprovalOptions(status.projectId, 'milestone.final_accept', activeMilestone);
+                return withAdoption({
                     scope: 'milestone',
                     id: activeMilestone.id,
                     status: activeMilestone.status,
-                    action: 'await explicit human final acceptance',
+                    action: delegatedApprovalOptions.length > 0
+                        ? 'milestone accept using delegated approval or await explicit human final acceptance'
+                        : 'await explicit human final acceptance',
                     revision: activeMilestone.revision,
                     requiredHumanGate: milestoneFinalAcceptanceGate(activeMilestone, evidence.headCommit),
-                };
+                    completionPolicy: {
+                        resultEvidenceAndHeadMustMatch: true,
+                        finalAcceptanceTransition: 'milestone.final_accept',
+                        delegatedActorMustRemainDelegate: true,
+                    },
+                    ...(delegatedApprovalOptions.length > 0 ? { delegatedApprovalOptions } : {}),
+                });
             }
-            return {
+            const delegatedApprovalOptions = activeMilestone.status === 'awaiting_execution_authorization'
+                ? this.delegatedApprovalOptions(status.projectId, 'milestone.execution_authorize', activeMilestone)
+                : [];
+            return withAdoption({
                 scope: 'milestone',
                 id: activeMilestone.id,
                 status: activeMilestone.status,
                 action: nextForMilestone(activeMilestone),
                 revision: activeMilestone.revision,
-            };
+                ...(activeMilestone.status === 'active'
+                    ? {
+                        completionPolicy: {
+                            requiredTasksMustBeMerged: true,
+                            validationAction: 'milestone validate',
+                            finalAcceptanceTransition: 'milestone.final_accept',
+                            delegatedActorMustRemainDelegate: true,
+                            requiredTasks: activeMilestone.memberships
+                                .filter((membership) => membership.disposition === 'required')
+                                .map((membership) => {
+                                const task = status.tasks.find((candidate) => candidate.id === membership.taskId);
+                                return { taskId: membership.taskId, status: task?.status ?? 'missing' };
+                            }),
+                        },
+                    }
+                    : {}),
+                ...(delegatedApprovalOptions.length > 0 ? { delegatedApprovalOptions } : {}),
+            });
         }
         const activeDiscovery = status.discoveries.find((discovery) => !['materialized', 'abandoned'].includes(discovery.status));
         if (activeDiscovery) {
-            return {
+            return withAdoption({
                 scope: 'discovery',
                 id: activeDiscovery.id,
                 status: activeDiscovery.status,
                 action: activeDiscovery.status === 'ready_to_materialize' ? 'discovery materialize' : 'discovery update',
                 readiness: assessDiscovery(activeDiscovery),
+            });
+        }
+        return withAdoption({ scope: 'repository', status: 'idle', action: 'discovery start' });
+    }
+    delegatedAuthorization(projectId, grantId, transition, actor, target) {
+        if (!grantId) {
+            if (actor.trim().startsWith('agent:')) {
+                throw new WorkflowError('TRANSITION_BLOCKED', 'An agent actor requires an explicit delegated approval grant.');
+            }
+            return null;
+        }
+        const grant = this.store.readDelegation(projectId, grantId);
+        return assertDelegationCanAuthorize(grant, transition, actor, target, this.now());
+    }
+    assertHandoffGrant(projectId, task, targetActor, grantId) {
+        const grant = this.store.readDelegation(projectId, grantId);
+        const policyHash = hashDelegationPolicy(projectId, {
+            principal: grant.principal,
+            delegate: grant.delegate,
+            scope: grant.scope,
+            transitions: grant.transitions,
+            expiresAt: grant.expiresAt,
+        });
+        const scopeMatches = grant.scope.kind === 'project'
+            || (grant.scope.kind === 'task' && grant.scope.id === task.id)
+            || (grant.scope.kind === 'milestone' && grant.scope.id === task.milestoneId);
+        if (grant.status !== 'active'
+            || grant.policyHash !== policyHash
+            || Date.parse(grant.expiresAt) <= this.now().getTime()
+            || grant.delegate !== targetActor.trim()
+            || !scopeMatches) {
+            throw new WorkflowError('TRANSITION_BLOCKED', `Delegation ${grantId} cannot be bound to this C1 handoff.`, {
+                grantId,
+                taskId: task.id,
+                targetActor: targetActor.trim(),
+                grantStatus: grant.status,
+                expectedPolicyHash: policyHash,
+                actualPolicyHash: grant.policyHash,
+                grantDelegate: grant.delegate,
+                grantScope: grant.scope,
+                grantExpiresAt: grant.expiresAt,
+            });
+        }
+    }
+    nextForTaskWithDelegation(projectId, task, planRiskAudit = null) {
+        const transition = task.status === 'awaiting_execution_authorization'
+            ? 'task.execution_authorize'
+            : task.status === 'awaiting_final_acceptance'
+                ? 'task.final_accept'
+                : null;
+        const delegatedApprovalOptions = transition
+            ? this.delegatedApprovalOptions(projectId, transition, task)
+            : [];
+        const failedReviewAttempts = countFailedReviewAttempts(this.store.taskRoot(projectId, task.id));
+        const next = nextForTask(task);
+        const handoffPosture = readTaskC1Posture(this.store, task);
+        const strictStepReviewStep = planRiskAudit
+            ? task.steps.find((step) => {
+                if (step.status !== 'in_progress' || !step.evidence || !planRiskAudit.reviewRequiredStepIds.includes(step.id)) {
+                    return false;
+                }
+                if (task.status !== 'blocked')
+                    return true;
+                return buildCurrentStrictStepReviewCycle(this.store, task, step.id).resolution === 'unverified';
+            }) ?? null
+            : null;
+        const handoffOverlay = handoffPosture.state === 'pending'
+            ? {
+                action: 'task claim',
+                blockedAction: next.action,
+                c1Handoff: {
+                    state: 'pending',
+                    targetActor: handoffPosture.targetActor,
+                    eventId: handoffPosture.latestEvent.eventId,
+                },
+            }
+            : handoffPosture.state === 'claimed'
+                ? {
+                    c1Handoff: {
+                        state: 'claimed',
+                        claimant: handoffPosture.claimant,
+                        writerLeaseTokenBound: handoffPosture.writerLeaseTokenHash !== null,
+                        requiredActor: handoffPosture.claimant,
+                    },
+                }
+                : {};
+        const result = {
+            ...next,
+            ...handoffOverlay,
+            ...(strictStepReviewStep
+                ? {
+                    action: 'task step-review',
+                    stepId: strictStepReviewStep.id,
+                    commitPolicy: {
+                        owner: 'workflow-core',
+                        manualCommitAllowed: false,
+                        completionAction: 'task step-review',
+                    },
+                    strictStepReview: {
+                        reviewRequired: true,
+                        completionCommit: strictStepReviewStep.evidence.commitSha,
+                    },
+                }
+                : {}),
+            ...(planRiskAudit
+                ? {
+                    planRiskAudit: {
+                        decision: planRiskAudit.audit.decision,
+                        scope: planRiskAudit.scope,
+                        postureEventType: planRiskAudit.postureEventType,
+                        reviewRequiredStepIds: planRiskAudit.reviewRequiredStepIds,
+                    },
+                }
+                : {}),
+            ...(task.status === 'needs_fix' && task.review.status === 'failed' && failedReviewAttempts >= 2
+                ? {
+                    action: 'task plan-set with independent corrective audit',
+                    correctivePlanGate: {
+                        failedReviewAttempts,
+                        auditFileRequired: true,
+                        auditorMustDifferFromFailedReviewer: true,
+                        allowedDecision: 'continue-fix',
+                        escalationDecisions: ['replan-required', 'split-required', 'stop-escalate'],
+                    },
+                }
+                : {}),
+            ...(delegatedApprovalOptions.length > 0 ? { delegatedApprovalOptions } : {}),
+        };
+        if (handoffPosture.state === 'pending') {
+            return {
+                ...result,
+                action: 'task claim',
+                blockedAction: next.action,
             };
         }
-        return { scope: 'repository', status: 'idle', action: 'discovery start' };
+        return result;
+    }
+    delegatedApprovalOptions(projectId, transition, target) {
+        return this.store.listDelegations(projectId)
+            .filter((grant) => delegationCanAuthorize(grant, transition, target, this.now()))
+            .map((grant) => ({
+            grantId: grant.id,
+            principal: grant.principal,
+            delegate: grant.delegate,
+            transition,
+            scope: grant.scope,
+            expiresAt: grant.expiresAt,
+            policyHash: grant.policyHash,
+        }));
+    }
+    delegatedContextRefreshOptions(projectId, task, knowledgeMap) {
+        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()))
+            .map((grant) => ({
+            grantId: grant.id,
+            principal: grant.principal,
+            delegate: grant.delegate,
+            transition: 'task.execution_authorize',
+            transitions: ['project_memory.approve', 'task.execution_authorize'],
+            scope: grant.scope,
+            expiresAt: grant.expiresAt,
+            policyHash: grant.policyHash,
+        }));
+    }
+    assertDelegationScopeExists(projectId, policy) {
+        if (policy.scope.kind === 'task') {
+            this.store.readTask(projectId, policy.scope.id);
+            return;
+        }
+        if (policy.scope.kind === 'milestone')
+            this.store.readMilestone(projectId, policy.scope.id);
     }
     assertExecutionAuthorizationFresh(task) {
         const root = this.store.taskRoot(task.projectId, task.id);
@@ -1207,6 +2280,75 @@ export class WorkflowService {
             throw new WorkflowError('TRANSITION_BLOCKED', 'Milestone authorization is stale.');
         }
     }
+    readMilestoneCurrent(projectId, milestoneId) {
+        return readMilestoneWithIntegrity(this.store, projectId, milestoneId, (taskId) => this.store.readTask(projectId, taskId), () => this.store.listTasks(projectId));
+    }
+    readMilestoneScopeChangeCurrent(projectId, milestoneId) {
+        return readMilestoneForScopeChange(this.store, projectId, milestoneId, (taskId) => this.store.readTask(projectId, taskId), () => this.store.listTasks(projectId));
+    }
+    listMilestonesCurrent(projectId, posture = this.readCurrentAdoptionPostureStrict(projectId)) {
+        const milestones = this.store.listMilestones(projectId);
+        if (!posture)
+            return milestones;
+        const grandfatheredMilestones = new Set(posture.terminalMilestones.map((milestone) => `${milestone.milestoneId}:${milestone.revision}:${milestone.status}`));
+        return milestones.map((milestone) => (grandfatheredMilestones.has(`${milestone.id}:${milestone.revision}:${milestone.status}`)
+            ? milestone
+            : readMilestoneWithIntegrity(this.store, projectId, milestone.id, (taskId) => this.store.readTask(projectId, taskId), () => this.store.listTasks(projectId))));
+    }
+    prepareMilestoneScopeChangeCandidate(projectId, milestone, plan, actor) {
+        validateMilestonePlan(plan);
+        return prepareMilestoneScopeChangeCandidate({
+            milestone,
+            plan,
+            readTask: (taskId) => this.store.readTask(projectId, taskId),
+            actor,
+        });
+    }
+    proveWriterLeaseTokenForHandoff(context, taskId, writerToken) {
+        const currentLease = context.locks.inspect(taskId);
+        if (!currentLease) {
+            if (writerToken !== null) {
+                throw new WorkflowError('TRANSITION_BLOCKED', `Task ${taskId} has no active writer lease for the provided writer token.`, {
+                    taskId,
+                });
+            }
+            return null;
+        }
+        if (writerToken === null) {
+            throw new WorkflowError('TRANSITION_BLOCKED', `Task ${taskId} requires the active writer token while a lease is present.`, {
+                taskId,
+                leaseOwner: currentLease.owner,
+                expiresAt: currentLease.expiresAt,
+            });
+        }
+        return context.locks.heartbeat(taskId, writerToken);
+    }
+    proveOptionalWriterLeaseToken(context, taskId, writerToken) {
+        const currentLease = context.locks.inspect(taskId);
+        if (!currentLease) {
+            if (writerToken !== null) {
+                throw new WorkflowError('TRANSITION_BLOCKED', `Task ${taskId} has no active writer lease for the provided writer token.`, {
+                    taskId,
+                });
+            }
+            return null;
+        }
+        if (writerToken === null)
+            return null;
+        return context.locks.heartbeat(taskId, writerToken);
+    }
+    assertTaskMutationAllowedByHandoff(task, actor, writerToken) {
+        const posture = readTaskC1Posture(this.store, task);
+        if (posture.state === 'none')
+            return;
+        if (!actor || !actor.trim()) {
+            throw new WorkflowError('TRANSITION_BLOCKED', `Task ${task.id} has active C1 coordination and requires an explicit actor for mutation.`, {
+                taskId: task.id,
+                posture: posture.state,
+            });
+        }
+        assertTaskMutationAllowedByC1(this.store, task, { actor: actor.trim(), writerToken });
+    }
     readGraphBindingOrNull(projectId, graphKind) {
         try {
             return this.store.readGraphBinding(projectId, graphKind);
@@ -1229,6 +2371,71 @@ export class WorkflowService {
         }
         return inspected;
     }
+    inspectAdoptionPreparation(identity, tasks, milestones) {
+        const locks = new WriterLockManager(this.store.lockRoot(identity.projectId), this.now);
+        const currentPosture = readCurrentAdoptionPosture(this.store, identity.projectId);
+        if (currentPosture) {
+            assertAdoptionBaselinePreserved(currentPosture, tasks, milestones);
+        }
+        return buildAdoptionPreparation({
+            projectId: identity.projectId,
+            repositoryIdentity: identity,
+            packageVersion: PACKAGE_VERSION,
+            protocolVersion: PROTOCOL_VERSION,
+            stateSchemaVersion: STATE_SCHEMA_VERSION,
+            tasks,
+            milestones,
+            sidecarInventory: this.collectAdoptionSidecarInventory(identity.projectId, tasks, milestones),
+            blockers: this.computeAdoptionBoundaryBlockers(identity, tasks, locks.list()),
+            now: this.now(),
+        }, currentPosture);
+    }
+    computeAdoptionBoundaryBlockers(identity, tasks, leases) {
+        const dirty = changedFiles(identity.repositoryRoot);
+        const runningSteps = tasks.flatMap((task) => task.steps
+            .filter((step) => step.status === 'in_progress')
+            .map((step) => ({ taskId: task.id, stepId: step.id })));
+        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);
+        return [
+            ...(dirty.length > 0 ? ['Repository checkout is not clean.'] : []),
+            ...(runningSteps.length > 0 ? ['At least one Worker Step is in progress.'] : []),
+            ...(activeLeases.length > 0 ? ['At least one writer lease is active.'] : []),
+            ...(staleLeases.length > 0 ? ['At least one stale writer lease requires explicit repair.'] : []),
+        ];
+    }
+    collectAdoptionSidecarInventory(projectId, tasks, milestones) {
+        const inventory = [];
+        const collect = (scope, ownerId, root) => {
+            if (!existsSync(root))
+                return;
+            for (const entry of readdirSync(root, { withFileTypes: true })) {
+                if (entry.isSymbolicLink()) {
+                    throw new WorkflowError('STATE_CORRUPT', `Adoption sidecar inventory rejects symlink entries: ${path.join(root, entry.name)}`);
+                }
+                if (!entry.isFile() || !entry.name.endsWith('.jsonl'))
+                    continue;
+                const filePath = path.join(root, entry.name);
+                const stat = lstatSync(filePath);
+                if (!stat.isFile()) {
+                    throw new WorkflowError('STATE_CORRUPT', `Adoption sidecar inventory requires regular files only: ${filePath}`);
+                }
+                inventory.push({
+                    scope,
+                    ownerId,
+                    sidecarName: entry.name,
+                    contentHash: createHash('sha256').update(readFileSync(filePath)).digest('hex'),
+                });
+            }
+        };
+        collect('project', projectId, this.store.projectRoot(projectId));
+        for (const task of tasks)
+            collect('task', task.id, this.store.taskRoot(projectId, task.id));
+        for (const milestone of milestones)
+            collect('milestone', milestone.id, this.store.milestoneRoot(projectId, milestone.id));
+        return inventory;
+    }
     assertKnowledgeMapBinding(repositoryRoot, projectId, revision, mapHash) {
         const map = this.requireActiveKnowledgeMap(repositoryRoot, projectId);
         const currentHash = hashKnowledgeMap(map);
@@ -1242,6 +2449,29 @@ export class WorkflowService {
         }
         return map;
     }
+    readCurrentAdoptionPostureStrict(projectId) {
+        const posture = readCurrentAdoptionPosture(this.store, projectId);
+        if (!posture)
+            return null;
+        assertAdoptionBaselinePreserved(posture, this.store.listTasks(projectId), this.store.listMilestones(projectId));
+        return posture;
+    }
+    requireExecutionAdoptionPosture(identity, taskId) {
+        const tasks = this.store.listTasks(identity.projectId);
+        const milestones = this.store.listMilestones(identity.projectId);
+        const posture = this.readCurrentAdoptionPostureStrict(identity.projectId);
+        if (posture)
+            return posture;
+        const adoption = this.inspectAdoptionPreparation(identity, tasks, milestones);
+        throw new WorkflowError('TRANSITION_BLOCKED', 'Alpha.6 adoption posture is required before execution can proceed.', {
+            taskId,
+            adoptionStatus: adoption.status,
+            requiredAction: adoption.safe ? 'state adoption-apply' : 'restore safe boundary, then state adoption-prepare',
+            blockers: adoption.blockers,
+            confirmationCode: adoption.confirmationCode,
+            confirmationCodeBindingHash: adoption.confirmationCodeBindingHash,
+        });
+    }
     assertTaskKnowledgeBinding(repositoryRoot, task) {
         if (task.knowledgeMapRevision === null || !task.knowledgeMapHash) {
             throw new WorkflowError('TRANSITION_BLOCKED', `Task ${task.id} has no Project Knowledge Map binding.`);
@@ -1313,6 +2543,62 @@ function dependenciesComplete(step, completed) {
     const completedIds = new Set(completed);
     return step.dependencies.every((dependency) => completedIds.has(dependency));
 }
+function applyStrictStepReviewResolution(task, stepId, resolution, summary) {
+    if (resolution === 'pending') {
+        throw new WorkflowError('STATE_CORRUPT', `Strict Step Review resolution is still pending for ${stepId}.`, {
+            taskId: task.id,
+            stepId,
+        });
+    }
+    const step = requireStep(task, stepId);
+    if (!step.evidence) {
+        throw new WorkflowError('STATE_CORRUPT', `Strict Step Review resolution requires canonical evidence for ${stepId}.`, {
+            taskId: task.id,
+            stepId,
+            resolution,
+        });
+    }
+    if (resolution === 'passed_verified') {
+        const completedIds = new Set([
+            ...task.steps.filter((candidate) => candidate.status === 'completed').map((candidate) => candidate.id),
+            stepId,
+        ]);
+        return {
+            ...task,
+            status: 'in_progress',
+            steps: task.steps.map((candidate) => {
+                if (candidate.id === stepId)
+                    return { ...candidate, status: 'completed', evidence: step.evidence };
+                if (candidate.status === 'blocked' && dependenciesComplete(candidate, completedIds)) {
+                    return { ...candidate, status: 'planned' };
+                }
+                return candidate;
+            }),
+            blockReason: null,
+        };
+    }
+    if (resolution === 'failed') {
+        return {
+            ...task,
+            status: 'needs_fix',
+            steps: task.steps.map((candidate) => candidate.id === stepId
+                ? { ...candidate, status: 'failed', evidence: null }
+                : candidate),
+            blockReason: summary?.trim() || `Strict Step Review failed for ${stepId}.`,
+            systemCommits: task.systemCommits.includes(step.evidence.commitSha)
+                ? task.systemCommits
+                : [...task.systemCommits, step.evidence.commitSha],
+        };
+    }
+    return {
+        ...task,
+        status: 'blocked',
+        steps: task.steps.map((candidate) => candidate.id === stepId
+            ? { ...candidate, status: 'in_progress', evidence: step.evidence }
+            : candidate),
+        blockReason: summary?.trim() || `Strict Step Review isolation could not be verified for ${stepId}.`,
+    };
+}
 function identityRelative(repositoryRoot, value) {
     return path.resolve(repositoryRoot, value);
 }
@@ -1366,6 +2652,83 @@ function validateReviewInput(review) {
         throw new WorkflowError('INVALID_ARGUMENT', 'A failed review requires at least one finding.');
     }
 }
+function countFailedReviewAttempts(taskRoot) {
+    const file = path.join(taskRoot, 'findings.jsonl');
+    if (!existsSync(file))
+        return 0;
+    const attempts = new Set();
+    for (const line of readFileSync(file, 'utf8').split('\n').filter(Boolean)) {
+        try {
+            const finding = JSON.parse(line);
+            if (typeof finding.recordedAt === 'string' && finding.recordedAt) {
+                attempts.add(`${finding.recordedAt}\0${typeof finding.reviewer === 'string' ? finding.reviewer : ''}`);
+            }
+        }
+        catch {
+            throw new WorkflowError('STATE_CORRUPT', `Invalid review finding log: ${file}`);
+        }
+    }
+    return attempts.size;
+}
+function validateCorrectivePlanAudit(task, audit, failedReviewAttempts) {
+    if (!audit) {
+        throw new WorkflowError('TRANSITION_BLOCKED', `Task ${task.id} has ${failedReviewAttempts} failed independent reviews. A separate corrective Plan audit is required before another plan-set.`, {
+            failedReviewAttempts,
+            requiredAction: 'Run a separate read-only Auditor and pass its evidence through --corrective-audit-file.',
+        });
+    }
+    if (!audit.auditor.trim() || !audit.summary.trim()) {
+        throw new WorkflowError('INVALID_ARGUMENT', 'Corrective Plan audit requires auditor and summary.');
+    }
+    if (audit.auditor.trim() === task.review.reviewer.trim()) {
+        throw new WorkflowError('TRANSITION_BLOCKED', 'Corrective Plan audit must be performed by an Auditor distinct from the failed-review author.');
+    }
+    const latestFindingIds = new Set(task.review.findings.map((finding) => finding.id));
+    const reviewedFindingIds = new Set(audit.reviewedFindingIds);
+    if (reviewedFindingIds.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 = [...latestFindingIds].filter((findingId) => !reviewedFindingIds.has(findingId));
+    if (missing.length > 0) {
+        throw new WorkflowError('TRANSITION_BLOCKED', 'Corrective Plan audit does not cover every latest finding.', {
+            missingFindingIds: missing,
+        });
+    }
+    if (audit.decision !== 'continue-fix') {
+        throw new WorkflowError('TRANSITION_BLOCKED', `Corrective Auditor decision ${audit.decision} requires coordinator/user redirection before implementation continues.`, { decision: audit.decision, summary: audit.summary });
+    }
+}
+function appendCorrectivePlanAudit(taskRoot, previous, saved, failedReviewAttempts, audit, now) {
+    appendFileSync(path.join(taskRoot, 'corrective-plan-audits.jsonl'), `${JSON.stringify({
+        recordedAt: now.toISOString(),
+        taskId: previous.id,
+        taskRevision: previous.revision,
+        failedReviewAttempts,
+        previousPlanHash: previous.planHash,
+        correctivePlanHash: saved.planHash,
+        ...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) => ({
+            id: entry.id,
+            category: entry.category,
+            path: entry.path,
+            scope: entry.scope,
+            authority: entry.authority,
+            discoveredBy: entry.discoveredBy,
+        })),
+        gaps: map.gaps,
+        conflicts: map.conflicts,
+    });
+    return classification(approved) === classification(inspected);
+}
 function validateMilestonePlan(plan) {
     if (!plan.outcome.trim())
         throw new WorkflowError('INVALID_ARGUMENT', 'Milestone outcome is required.');
@@ -1461,11 +2824,14 @@ function nextForMilestone(milestone) {
 }
 function nextForTask(task) {
     const stepsComplete = task.steps.every((step) => step.status === 'completed' || step.status === 'skipped');
+    const activeStep = task.steps.find((step) => step.status === 'in_progress');
+    const failedStep = task.steps.find((step) => step.status === 'failed');
+    const runnableStep = task.steps.find((step) => step.status === 'planned' && step.dependencies.every((dependency) => ['completed', 'skipped'].includes(requireStep(task, dependency).status)));
     const actionByStatus = {
         planning: 'task plan-set',
         awaiting_execution_authorization: 'task authorize',
         ready: task.workspaceOwner ? (stepsComplete ? 'task submit' : 'task run') : 'task start',
-        in_progress: stepsComplete ? 'task submit' : 'task run or task submit',
+        in_progress: activeStep ? 'task step-complete' : stepsComplete ? 'task submit' : 'task run',
         validating: task.review.status === 'passed' ? 'task result-set' : 'task review-record',
         needs_fix: task.steps.some((step) => step.status === 'failed') ? 'task run' : 'task plan-set',
         awaiting_final_acceptance: 'task accept',
@@ -1475,7 +2841,24 @@ function nextForTask(task) {
         blocked: task.review.status === 'unverified' ? 'task review-record' : 'doctor',
         cancelled: 'none',
     };
-    return { scope: 'task', id: task.id, status: task.status, action: actionByStatus[task.status], revision: task.revision };
+    const selectedStep = activeStep ?? failedStep ?? runnableStep;
+    return {
+        scope: 'task',
+        id: task.id,
+        status: task.status,
+        action: actionByStatus[task.status],
+        revision: task.revision,
+        ...(selectedStep ? { stepId: selectedStep.id } : {}),
+        ...(activeStep
+            ? {
+                commitPolicy: {
+                    owner: 'workflow-core',
+                    manualCommitAllowed: false,
+                    completionAction: 'task step-complete',
+                },
+            }
+            : {}),
+    };
 }
 function knowledgeSummary(map) {
     return {