codex-workflow-v2 2.0.0-beta.14 → 2.0.0-beta.14.1

package/dist/src/version.js

@@ -1,3 +1,3 @@
 export const PACKAGE_NAME = 'codex-workflow-v2';
-export const PACKAGE_VERSION = '2.0.0-beta.14';
+export const PACKAGE_VERSION = '2.0.0-beta.14.1';
 //# sourceMappingURL=version.js.map

package/dist/src/version.js.map

@@ -1 +1 @@
-{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,YAAY,GAAG,mBAAmB,CAAC;AAChD,MAAM,CAAC,MAAM,eAAe,GAAG,eAAe,CAAC"}
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,YAAY,GAAG,mBAAmB,CAAC;AAChD,MAAM,CAAC,MAAM,eAAe,GAAG,iBAAiB,CAAC"}

package/dist/src/workflow-blocker-route.js

@@ -75,7 +75,7 @@ export function withWorkflowBlockerRoute(next, packageVersion) {
                 projectName: 'codex-workflow-v2',
                 chatType: 'workflow-blocker',
                 title: patchVersion,
-                modelRequest: { phase: 'implementation', complexity: 'complex', highRisk: false },
+                modelSelection: 'destination-default',
                 requiredPacketFields: [
                     'blockerId', 'packageVersion', 'sourceProject', 'sourceThreadId', 'source',
                     'freshStatusHash', 'freshNextHash', 'repositoryState', 'expectedContinuation',

package/dist/src/workflow-blocker-route.js.map

@@ -1 +1 @@
-{"version":3,"file":"workflow-blocker-route.js","sourceRoot":"","sources":["../../src/workflow-blocker-route.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"workflow-blocker-route.js","sourceRoot":"","sources":["../../src/workflow-blocker-route.ts"],"names":[],"mappings":"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"}

package/dist/src/workflow.d.ts

@@ -1,4 +1,5 @@
 import { type NavigationUpdateReceipt } from './navigation-update.js';
+import { type FailedCheckpointUpdateReceipt } from './failed-checkpoint-update.js';
 import type { CheckExecutionOptions } from './checks/runner.js';
 import { type ChangeExplanationInput } from './change-explanation.js';
 import { type AdoptionPostureEvent, type AuditedRemediationEvidence, type ContextEnvelope, type CorrectivePlanAuditInput, type DependencyProvenanceRecoveryPreflight, type DelegationGrant, type DelegationGrantGate, type DelegationPolicyInput, type DiscoveryState, type MilestonePlanInput, type MilestoneProgressProjection, type MilestoneState, type KnowledgeSelection, type GraphBinding, type GraphKind, type GraphMode, type GraphRefreshEvidence, type GraphRefreshRequest, type HistoricalStepProvenanceRecoveryPreflight, type PlanRiskAuditEvent, type PublicWriterLease, type PublicWriterLeaseDiagnostic, type PublicWriterLeaseRepairResult, type ProjectKnowledgeMap, type ReviewInput, type TaskPlanInput, type TaskContextRefreshResult, type TaskState, type UpdatePreflightResult, type WriterCredentialResult, type WriterCredentialStatus, type WorkflowObservation, type WorkflowRole, type WorkspaceOwner } from './contracts.js';
@@ -125,6 +126,7 @@ export declare class WorkflowService {
     constructor(store?: FileStateStore, now?: () => Date, transactionHooks?: WorkflowTransactionHooks, checkOptions?: CheckExecutionOptions);
     inspectWriterLease(repository: string, entityId: string): PublicWriterLeaseDiagnostic | null;
     repairStaleWriterLease(repository: string, entityId: string): PublicWriterLeaseRepairResult | ReturnType<CoreTaskOperationLockManager['repairExpiredOrphan']>;
+    authorizeDelegatedCorrectiveReplan(repository: string, taskId: string, candidate: CorrectiveReplanPublicCandidate): CorrectiveReplanPublicCredential;
     prepareCorrectiveReplan(repository: string, taskId: string, candidate: CorrectiveReplanPublicCandidate): CorrectiveReplanHumanGateResult;
     confirmCorrectiveReplan(repository: string, taskId: string, candidate: CorrectiveReplanPublicCandidate, gate: CorrectiveReplanHumanGate, confirmationCode: string): CorrectiveReplanPublicCredential;
     executeCorrectiveReplan(repository: string, taskId: string, candidate: CorrectiveReplanPublicCandidate, credential: CorrectiveReplanPublicCredential): CorrectiveReplanExecutionResult;
@@ -171,6 +173,7 @@ export declare class WorkflowService {
     listDelegations(projectId: string): DelegationGrant[];
     prepareMilestoneAutonomy(repository: string, milestoneId: string, expectedRevision: number, principal: string, delegate: string, expiresAt: string): MilestoneAutonomyPreparation;
     grantMilestoneAutonomy(repository: string, milestoneId: string, expectedRevision: number, principal: string, delegate: string, expiresAt: string, confirmationCode: string): ActiveMilestoneAutonomy;
+    bindMilestoneAutonomy(repository: string, milestoneId: string, expectedRevision: number, actor: string, grantId: string): ActiveMilestoneAutonomy;
     evolveMilestonePlanAutonomously(repository: string, milestoneId: string, expectedRevision: number, plan: MilestonePlanInput, actor: string): MilestoneState;
     authorizeMilestone(repository: string, milestoneId: string, expectedRevision: number, actor: string, reason?: string, delegationGrantId?: string | null): MilestoneState;
     private assertMilestoneValidationReady;
@@ -272,11 +275,46 @@ export declare class WorkflowService {
         recoveredMilestoneIds: string[];
     };
     prepareAdoption(repository: string): AdoptionPreparation;
-    applyAdoption(repository: string, actor: string, confirmationCode: string): AdoptionPostureEvent;
+    applyAdoption(repository: string, actor: string, confirmationCode: string, delegationGrantId?: string | null): AdoptionPostureEvent;
     updatePreflight(repository: string): UpdatePreflightResult & {
         adoption: AdoptionPreparation | null;
     };
     private navigationUpdateBoundary;
+    failedCheckpointUpdateSourcePreflight(repository: string, taskId: string, tarball: string): {
+        eligible: boolean;
+        blockers: string[];
+        receipt: FailedCheckpointUpdateReceipt;
+    } | {
+        eligible: boolean;
+        blockers: string[];
+        receipt: null;
+    };
+    failedCheckpointUpdateTransportPreflight(repository: string, taskId: string, tarball: string, receipt: FailedCheckpointUpdateReceipt): {
+        eligible: boolean;
+        blockers: string[];
+        proof: {
+            receipt: FailedCheckpointUpdateReceipt;
+            target: {
+                commitSha: string;
+                parentCommitSha: string;
+                packageVersion: string;
+            };
+            baseTransport: string;
+            targetHead: string;
+            binding: import("./failed-checkpoint-update.js").FailedCheckpointUpdateBinding;
+        };
+        action: string;
+        expectedRevision: number;
+        actor: string;
+    } | {
+        eligible: boolean;
+        blockers: string[];
+        proof: null;
+        action?: never;
+        expectedRevision?: never;
+        actor?: never;
+    };
+    recoverFailedCheckpointUpdate(repository: string, taskId: string, expectedRevision: number, tarball: string, receipt: FailedCheckpointUpdateReceipt, actor: string, reason: string): TaskState;
     navigationUpdateSourcePreflight(repository: string, taskId: string, tarball: string): {
         eligible: boolean;
         blockers: string[];
@@ -390,6 +428,7 @@ export declare class WorkflowService {
     private currentCorrectiveDerivedTaskAuthority;
     private nextForTaskWithDelegation;
     private taskPlanContract;
+    private registeredPlanningContextTransport;
     private taskContextChangeBlocker;
     private stopOverrideContextRebindDecisionId;
     private taskHasTerminalCorrectiveDecision;

package/dist/src/workflow.js

@@ -1,5 +1,6 @@
 import { assessNavigationDirtyCarryover } from './alpha6/navigation-dirty-carryover.js';
 import { navigationUpdateSource, assertNavigationSourceInstalled, inspectNavigationTransport } from './navigation-update.js';
+import { failedCheckpointUpdateSource, assertFailedCheckpointInstalled, inspectFailedCheckpointTransport, readFailedCheckpointDirtyTransport, FAILED_CHECKPOINT_SOURCE, FAILED_CHECKPOINT_TARGET } from './failed-checkpoint-update.js';
 import { verifyNavigationUpdateArtifact } from './navigation-update-artifact.js';
 import { taskSyncChecks, taskSyncChecksHash, assertNoPendingBaseSyncValidation, assessPendingBaseSyncValidation, assertPendingBaseSyncValidationReady } from './checks/task-sync.js';
 import { isVirginRegistrationRoot } from './domain/virgin-registration.js';
@@ -33,14 +34,14 @@ import { applyAdoptionPosture, assertAdoptionBaselinePreserved, buildAdoptionPre
 import { appendCurrentPlanRiskAudit, appendReboundPlanRiskAudit, buildCandidatePlanRiskAuditEvent, buildPlanRiskAuditEvent, readCurrentPlanRiskAudit, readCurrentPlanningObstructionAudit, readPlanRiskAuditEvents, validatePlanRiskAuditCandidate, } from './alpha6/plan-risk.js';
 import { hashCompletedSteps, hashExecutionAuthorization, preparePreExecutionReplanEvent, preExecutionReplanSidecar, readCurrentPreExecutionReplan, } from './alpha6/preexecution-replan.js';
 import { assessRootCauseReplanDirtyCarryover, matchesTerminalCorrectiveYield, } from './alpha6/root-cause-replan-carryover.js';
-import { appendCorrectiveDecisionEvent, appendPlanIntegrityRecoveryDecision, assertCorrectiveAuditorIndependence, assertGuardedRemediationAttemptAllowed, defaultCorrectiveAuditorActor, effectiveStepAllowedWrites, isKnowledgeReboundSupportDecision, findCurrentGuardedRemediationPosture, findFailedGuardedStepRequiringCorrectiveDecision, readGuardedRemediationPostureForStep, readCorrectiveDecisionEvents, readRemediationEvents, deriveRollingCauseDecision, deriveCurrentCauseDecisionForTask, prepareRemediationEvent, stopEscalateOverrideDecisionEventIds, } from './alpha6/remediation.js';
+import { appendCorrectiveDecisionEvent, firstFailurePlanningObstructionEvidence, appendPlanIntegrityRecoveryDecision, assertCorrectiveAuditorIndependence, assertGuardedRemediationAttemptAllowed, defaultCorrectiveAuditorActor, effectiveStepAllowedWrites, isKnowledgeReboundSupportDecision, findCurrentGuardedRemediationPosture, findFailedGuardedStepRequiringCorrectiveDecision, readGuardedRemediationPostureForStep, readCorrectiveDecisionEvents, readRemediationEvents, deriveRollingCauseDecision, deriveCurrentCauseDecisionForTask, prepareRemediationEvent, stopEscalateOverrideDecisionEventIds, } from './alpha6/remediation.js';
 import { assessPlanIntegrityRecovery, defaultPlanIntegrityRecoveryActor, } from './alpha6/plan-integrity.js';
 import { mechanicalCauseBindings, normalizeMechanicalFailures, } from './alpha6/remediation-cause.js';
 import { assertMechanicalFeasibilityFresh, evaluateMechanicalFeasibility, hashMechanicalFeasibilityEvidence, } from './alpha6/mechanical-feasibility.js';
 import { assessMilestoneInitialAssembly, applyInitialMilestonePlanTransaction, applyMilestoneScopeChangeTransaction, assertMilestoneDependenciesDeclared, assertMilestoneTaskRunnable, assessMilestoneTaskDependencies, assertMilestoneMembershipIntegrity, assertMilestoneScopeChangeStatusAllowed, inspectMilestoneWithIntegrity, normalizeMilestonePlan, prepareMilestoneScopeChangeCandidate, prepareMilestoneScopeChangeBundle, readMilestoneScopeChangeEvents, readMilestoneForScopeChange, assessMilestoneScopeCompletion, readMilestoneWithIntegrity, } from './alpha6/milestone.js';
 import { applyProjectTransaction, recoverProjectTransactions, runRollbackProjectTransaction, } from './beta1/project-transaction.js';
 import { buildCurrentStrictStepReviewCycle, countUnverifiedStrictStepReviews, ensurePendingStrictStepReview, isStepReviewRequired, latestFailedStepReviewRouting, latestPassedVerifiedStepReviewEvent, recordStrictStepReview, verifiedHistoricalStepReviewCommits, verifiedHistoricalStepReviewBindings, } from './alpha6/review.js';
-import { applyMilestoneAutonomyContract, assertAutonomousPlanEvolution, prepareMilestoneAutonomyContract, readMilestoneAutonomyEvents, requireActiveMilestoneAutonomy, } from './alpha7/autonomy.js';
+import { applyMilestoneAutonomyContract, bindMilestoneAutonomyToGrant, milestoneSemanticScopeHash, assertAutonomousPlanEvolution, prepareMilestoneAutonomyContract, readMilestoneAutonomyEvents, requireActiveMilestoneAutonomy, } from './alpha7/autonomy.js';
 import { appendCorrectiveDecisionRecovery, readValidatedCorrectiveDecisionRecoveryForNavigation, readValidatedStopOverrideContextRebindIfApplicable, requireCorrectiveDecisionRecoveryForRun, } from './alpha7/corrective-recovery.js';
 import { applyKnowledgeSelections, hashKnowledgeMap, inspectKnowledgeMap, normalizeRelativePath, reconcileKnowledgeMap, scanProjectKnowledge, selectKnowledgeSources, } from './memory.js';
 import { canonicalJsonStringify, prepareSidecarAppend, sha256Hex } from './alpha6/store-sidecars.js';
@@ -168,6 +169,9 @@ export class WorkflowService {
             repaired: true,
         };
     }
+    authorizeDelegatedCorrectiveReplan(repository, taskId, candidate) {
+        return this.correctiveReplanController(repository).authorizeDelegated({ taskId, candidate });
+    }
     prepareCorrectiveReplan(repository, taskId, candidate) {
         return this.correctiveReplanController(repository).prepare({ taskId, candidate });
     }
@@ -1382,6 +1386,20 @@ export class WorkflowService {
             locks.release(milestoneId, lease.token);
         }
     }
+    bindMilestoneAutonomy(repository, milestoneId, expectedRevision, actor, grantId) {
+        const { identity, locks } = this.#mutationContext(repository);
+        const lease = locks.acquire(milestoneId, 'workflow-core:autonomy-binding');
+        try {
+            const milestone = this.readMilestoneCurrent(identity.projectId, milestoneId);
+            assertExpectedRevision(milestone, expectedRevision);
+            this.requireActiveKnowledgeMap(identity.repositoryRoot, identity.projectId);
+            return bindMilestoneAutonomyToGrant({ store: this.store, projectId: identity.projectId,
+                milestone, actor, grantId, now: this.now() });
+        }
+        finally {
+            locks.release(milestoneId, lease.token);
+        }
+    }
     evolveMilestonePlanAutonomously(repository, milestoneId, expectedRevision, plan, actor) {
         const { identity, locks } = this.#mutationContext(repository);
         const authorityLease = locks.acquire(milestoneId, 'workflow-core:milestone-authority');
@@ -2033,7 +2051,7 @@ export class WorkflowService {
         const { identity } = this.#mutationContext(repository);
         const task = this.store.readTask(identity.projectId, taskId);
         assertExpectedRevision(task, expectedRevision);
-        const contextBlocker = this.taskContextChangeBlocker(task, 'rebind');
+        const contextBlocker = this.taskContextChangeBlocker(task, 'rebind', identity.repositoryRoot);
         // Preserve Plan-corruption precedence over the active-Step rejection.
         if (contextBlocker && !contextBlocker.activeStep)
             throw contextBlocker.error;
@@ -2124,18 +2142,22 @@ export class WorkflowService {
         const currentMap = this.store.readKnowledgeMap(identity.projectId);
         assertExpectedRevision(task, expectedTaskRevision);
         assertExpectedRevision(currentMap, expectedKnowledgeMapRevision);
-        const contextBlocker = this.taskContextChangeBlocker(task, 'refresh');
+        const contextBlocker = this.taskContextChangeBlocker(task, 'refresh', identity.repositoryRoot);
         if (contextBlocker)
             throw contextBlocker.error;
         const inspectedMap = inspectKnowledgeMap(currentMap, scanProjectKnowledge(identity.repositoryRoot, identity.projectId, this.now()));
         const transitions = [];
-        const planningRecovery = readFailedStepPlanningRecovery(this.store, task);
-        const currentPlanRiskAudit = planningRecovery?.current ?? readCurrentPlanRiskAudit(this.store, task);
+        const retainedAudits = JSON.stringify(readPlanRiskAuditEvents(this.store, task));
+        const retainedRemediation = JSON.stringify(readRemediationEvents(this.store, task));
+        const transport = this.registeredPlanningContextTransport(task, identity.repositoryRoot);
+        const planningRecovery = transport ? null : readFailedStepPlanningRecovery(this.store, task);
+        const planningOnly = Boolean(planningRecovery || transport);
+        const currentPlanRiskAudit = transport ? null : planningRecovery?.current ?? readCurrentPlanRiskAudit(this.store, task);
         const currentPlanArtifactHash = task.planHash
             ? this.store.hashArtifact(this.store.taskRoot(identity.projectId, task.id), 'plan.md')
             : null;
         const refreshAssessment = assessDelegatedKnowledgeRefresh(currentMap, inspectedMap, task, currentPlanArtifactHash);
-        if (planningRecovery && refreshAssessment.mode !== 'delegated-content-only') {
+        if (planningOnly && refreshAssessment.mode !== 'delegated-content-only') {
             throw new WorkflowError('TRANSITION_BLOCKED', 'Stopped planning context refresh permits content-only Knowledge drift.');
         }
         // Validate every delegated transition before the first write so a narrow grant cannot
@@ -2185,14 +2207,14 @@ export class WorkflowService {
                 }
                 transitions.push('task knowledge-rebind');
                 // A stopped Plan may regain its Knowledge binding, never execution authority.
-                if (!planningRecovery)
+                if (!planningOnly)
                     refreshedTask = this.authorizeTask(repository, taskId, refreshedTask.revision, actor, refreshAssessment.mode === 'delegated-plan-bounded-supporting-source'
                         ? 'Delegated Plan-bounded supporting-source context refresh.'
                         : 'Delegated content-only context refresh.', delegationGrantId);
-                if (!planningRecovery)
+                if (!planningOnly)
                     transitions.push('task execution authorize');
                 return {
-                    authority: planningRecovery ? 'planning-only' : 'execution',
+                    authority: planningOnly ? 'planning-only' : 'execution',
                     mode: refreshAssessment.mode,
                     transitions,
                     addedSources: refreshAssessment.addedSources,
@@ -2202,10 +2224,21 @@ export class WorkflowService {
             },
             validate: (result) => {
                 const currentTask = this.store.readTask(identity.projectId, task.id);
-                if (currentTask.revision !== result.task.revision || currentTask.status !== (planningRecovery ? 'awaiting_execution_authorization' : 'ready')) {
+                if (currentTask.revision !== result.task.revision || currentTask.status !== (planningOnly ? 'awaiting_execution_authorization' : 'ready')) {
                     throw new WorkflowError('STATE_CORRUPT', 'Context refresh transaction did not commit the expected Task posture.');
                 }
-                if (planningRecovery) {
+                if (transport) {
+                    if (!readFailedCheckpointDirtyTransport(this.store, identity.repositoryRoot, currentTask, transport.stepId, transport.sourceHead, transport.sourceDirtyHash)) {
+                        throw new WorkflowError('STATE_CORRUPT', 'Transport context proof disappeared.');
+                    }
+                    if (JSON.stringify(currentTask.steps) !== JSON.stringify(task.steps)
+                        || JSON.stringify(currentTask.authorizations) !== JSON.stringify(task.authorizations)
+                        || JSON.stringify(readPlanRiskAuditEvents(this.store, currentTask)) !== retainedAudits
+                        || JSON.stringify(readRemediationEvents(this.store, currentTask)) !== retainedRemediation) {
+                        throw new WorkflowError('STATE_CORRUPT', 'Transport context refresh changed retained evidence.');
+                    }
+                }
+                if (planningRecovery && !transport) {
                     const rebound = readFailedStepPlanningRecovery(this.store, currentTask);
                     if (!rebound || rebound.baseline.eventHash !== planningRecovery.baseline.eventHash
                         || JSON.stringify(currentTask.steps) !== JSON.stringify(task.steps)
@@ -4031,7 +4064,7 @@ export class WorkflowService {
         const { identity } = this.#mutationContext(repository);
         return this.inspectAdoptionPreparation(identity, this.store.listTasks(identity.projectId), this.store.listMilestones(identity.projectId));
     }
-    applyAdoption(repository, actor, confirmationCode) {
+    applyAdoption(repository, actor, confirmationCode, delegationGrantId = null) {
         const context = this.#mutationContext(repository);
         const tasks = context.store.listTasks(context.identity.projectId);
         const milestones = context.store.listMilestones(context.identity.projectId);
@@ -4046,7 +4079,7 @@ export class WorkflowService {
             sidecarInventory: this.collectAdoptionSidecarInventory(context.identity.projectId, tasks, milestones),
             blockers: this.computeAdoptionBoundaryBlockers(context.identity, tasks, context.locks.list()),
             now: this.now(),
-        }, actor, confirmationCode);
+        }, actor, confirmationCode, delegationGrantId);
     }
     updatePreflight(repository) {
         const snapshot = this.observationSnapshot(repository);
@@ -4146,6 +4179,47 @@ export class WorkflowService {
             throw new WorkflowError('TRANSITION_BLOCKED', 'Navigation update supports one active base branch.');
         return { snapshot, task, root: snapshot.identity.repositoryRoot };
     }
+    failedCheckpointUpdateSourcePreflight(repository, taskId, tarball) {
+        try {
+            const { task, root } = this.navigationUpdateBoundary(repository, taskId);
+            assertFailedCheckpointInstalled(root, task, FAILED_CHECKPOINT_SOURCE);
+            const receipt = failedCheckpointUpdateSource(root, this.store, task, verifyNavigationUpdateArtifact(tarball));
+            return { eligible: true, blockers: [], receipt };
+        }
+        catch (error) {
+            return { eligible: false, blockers: [error instanceof Error ? error.message : String(error)], receipt: null };
+        }
+    }
+    failedCheckpointUpdateTransportPreflight(repository, taskId, tarball, receipt) {
+        try {
+            const { task, root } = this.navigationUpdateBoundary(repository, taskId);
+            const proof = inspectFailedCheckpointTransport(root, this.store, task, receipt, verifyNavigationUpdateArtifact(tarball, path.join(root, 'node_modules/codex-workflow-v2')));
+            return { eligible: true, blockers: [], proof,
+                action: 'update failed-checkpoint-recover', expectedRevision: task.revision, actor: receipt.actor };
+        }
+        catch (error) {
+            return { eligible: false, blockers: [error instanceof Error ? error.message : String(error)], proof: null };
+        }
+    }
+    recoverFailedCheckpointUpdate(repository, taskId, expectedRevision, tarball, receipt, actor, reason) {
+        this.#mutationContext(repository);
+        const { task, root } = this.navigationUpdateBoundary(repository, taskId);
+        assertExpectedRevision(task, expectedRevision);
+        if (!actor.trim() || actor !== receipt?.actor || !reason.trim()) {
+            throw new WorkflowError('INVALID_ARGUMENT', 'Failed-checkpoint update requires the original claimant and an explicit reason.');
+        }
+        const proof = inspectFailedCheckpointTransport(root, this.store, task, receipt, verifyNavigationUpdateArtifact(tarball, path.join(root, 'node_modules/codex-workflow-v2')));
+        const updated = { ...task, status: 'awaiting_execution_authorization',
+            systemCommits: [...task.systemCommits, proof.target.commitSha],
+            dependencyProvenanceRecoveries: [...(task.dependencyProvenanceRecoveries ?? []), {
+                    ...proof.target, packageName: PACKAGE_NAME, files: ['package-lock.json', 'package.json'], actor,
+                    reason: `${reason.trim()} [failed-checkpoint-update ${receipt.artifact.sha256}]`,
+                    recordedAt: this.now().toISOString(), failedCheckpoint: proof.binding,
+                }],
+        };
+        validateTaskHistory(root, updated);
+        return this.store.writeTask(updated, expectedRevision);
+    }
     navigationUpdateSourcePreflight(repository, taskId, tarball) {
         try {
             const { task, root } = this.navigationUpdateBoundary(repository, taskId);
@@ -4567,7 +4641,7 @@ export class WorkflowService {
         if (!allowAtomicTaskRefresh && current.status === 'active' && current.approval) {
             const milestonesById = new Map(this.listMilestonesCurrent(identity.projectId).map((milestone) => [milestone.id, milestone]));
             const inspected = inspectKnowledgeMap(current, scanned);
-            const refreshOwner = this.findDelegatedContextRefreshOwner(identity.projectId, this.store.listTasks(identity.projectId), milestonesById, current, inspected);
+            const refreshOwner = this.findDelegatedContextRefreshOwner(identity.projectId, this.store.listTasks(identity.projectId), milestonesById, current, inspected, identity.repositoryRoot);
             if (refreshOwner) {
                 throw new WorkflowError('TRANSITION_BLOCKED', 'Standalone Project Knowledge reconcile would strand an authorized Task context refresh.', {
                     taskId: refreshOwner.task.id,
@@ -4720,7 +4794,18 @@ export class WorkflowService {
             currentEventType: status.adoption.currentPosture?.eventType ?? null,
         };
         if (status.adoption.status !== 'applied') {
+            const adoptionApprovals = this.listDelegations(status.projectId).flatMap(grant => {
+                try {
+                    return [assertDelegationCanAuthorize(grant, 'project.adopt', grant.delegate, { kind: 'project', id: status.projectId }, this.now())];
+                }
+                catch (error) {
+                    if (error instanceof WorkflowError && error.code === 'TRANSITION_BLOCKED')
+                        return [];
+                    throw error;
+                }
+            });
             return {
+                ...(adoptionApprovals.length ? { delegatedApprovalOptions: adoptionApprovals } : {}),
                 scope: 'project',
                 projectId: status.projectId,
                 status: status.adoption.status,
@@ -4729,7 +4814,7 @@ export class WorkflowService {
                 observation: status.observation,
                 navigation: status.adoption.safe
                     ? {
-                        kind: 'human-gate',
+                        kind: adoptionApprovals.length ? 'delegated' : 'human-gate',
                         transitionId: null,
                         cataloged: false,
                         command: 'state adoption-apply',
@@ -4751,6 +4836,49 @@ export class WorkflowService {
         }
         const withAdoption = (value) => ({
             ...value,
+            delegatedMilestoneAutonomyOptions: status.milestones.flatMap(milestone => {
+                if (!['active', 'awaiting_execution_authorization'].includes(milestone.status) || !milestone.planHash)
+                    return [];
+                const previousContract = readMilestoneAutonomyEvents(this.store, status.projectId, milestone.id).at(-1);
+                if (previousContract) {
+                    if (previousContract.semanticScopeHash !== milestoneSemanticScopeHash(milestone))
+                        return [];
+                    try {
+                        const previousGrant = this.store.readDelegation(status.projectId, previousContract.delegationGrantId);
+                        if (previousGrant.status === 'active' && Date.parse(previousGrant.expiresAt) > this.now().getTime())
+                            return [];
+                    }
+                    catch (error) {
+                        if (!(error instanceof WorkflowError) || error.code !== 'NOT_FOUND')
+                            throw error;
+                    }
+                }
+                try {
+                    this.requireActiveKnowledgeMap(repository, status.projectId);
+                }
+                catch (error) {
+                    if (error instanceof WorkflowError)
+                        return [];
+                    throw error;
+                }
+                return this.listDelegations(status.projectId).flatMap(grant => {
+                    if (grant.scope.kind !== 'milestone' || grant.scope.id !== milestone.id
+                        || !['task.execution_authorize', 'task.final_accept', 'milestone.execution_authorize', 'milestone.final_accept']
+                            .every(transition => grant.transitions.some(value => value === transition)))
+                        return [];
+                    try {
+                        assertDelegationCanAuthorize(grant, 'milestone.execution_authorize', grant.delegate, milestone, this.now());
+                        return [{ action: 'milestone autonomy-bind', milestoneId: milestone.id,
+                                expectedRevision: milestone.revision, actor: grant.delegate, delegationGrantId: grant.id,
+                                issuesGrant: false, requiresExactHumanConfirmation: false }];
+                    }
+                    catch (error) {
+                        if (error instanceof WorkflowError && error.code === 'TRANSITION_BLOCKED')
+                            return [];
+                        throw error;
+                    }
+                });
+            }),
             ...(status.milestones.some((milestone) => milestone.status === 'active' && milestone.planHash)
                 ? { activeMilestoneAutonomyOptions: status.milestones
                         .filter((milestone) => milestone.status === 'active' && milestone.planHash)
@@ -4883,7 +5011,7 @@ export class WorkflowService {
             if (approved?.status === 'active' && approved.approval) {
                 const inspected = inspectCurrentKnowledgeMap();
                 if (inspected.status === 'stale')
-                    prioritizedRefreshTask = this.findDelegatedContextRefreshOwner(status.projectId, status.tasks, milestonesById, approved, inspected)?.task ?? null;
+                    prioritizedRefreshTask = this.findDelegatedContextRefreshOwner(status.projectId, status.tasks, milestonesById, approved, inspected, repositoryRoot)?.task ?? null;
             }
         }
         const activeTask = requestedTask
@@ -4929,6 +5057,17 @@ export class WorkflowService {
                     dependencyProvenanceRecovery: dependencyRecovery,
                 });
             }
+            if (PACKAGE_VERSION === FAILED_CHECKPOINT_TARGET && activeTask.status === 'awaiting_execution_authorization'
+                && activeTask.workspaceOwner === 'external' && activeTask.steps.some(step => step.status === 'failed')) {
+                const transport = inspectBoundedWorkflowDependencyCommit(repositoryRoot, headCommit(repositoryRoot));
+                if (transport?.packageVersion === FAILED_CHECKPOINT_TARGET && !activeTask.systemCommits.includes(transport.commitSha)) {
+                    return withAdoption({ scope: 'task', id: activeTask.id, revision: activeTask.revision,
+                        action: 'update failed-checkpoint-transport-preflight',
+                        requiredInputs: ['--tarball <exact target artifact>', '--file <source receipt>'],
+                        reason: 'Verify the original failed-checkpoint receipt, native failure and retained product bytes before registering the dependency transport.',
+                    });
+                }
+            }
             const navigationSourceHead = activeTask.authorizations.filter(item => item.kind === 'execution' && item.decision === 'approved').at(-1)?.headCommit;
             if (activeTask.status === 'ready' && navigationSourceHead
                 && activeTask.dependencyProvenanceRecoveries?.some(item => item.planIntegrity?.mode === 'navigation-fix-dirty-carryover')) {
@@ -5242,10 +5381,10 @@ export class WorkflowService {
                 const contextRefreshOptions = action === 'project-memory reconcile'
                     && (taskNext?.action !== 'task plan-set' || rollingRootCausePlanSet)
                     && refreshAssessment?.eligible
-                    ? this.delegatedContextRefreshOptions(status.projectId, activeTask, knowledgeMap, refreshAssessment.mode)
+                    ? this.delegatedContextRefreshOptions(status.projectId, activeTask, knowledgeMap, refreshAssessment.mode, repositoryRoot)
                     : [];
                 if (requestedTask && action === 'project-memory reconcile' && contextRefreshOptions.length === 0) {
-                    const refreshOwner = this.findDelegatedContextRefreshOwner(status.projectId, status.tasks, milestonesById, storedKnowledgeMap, knowledgeMap);
+                    const refreshOwner = this.findDelegatedContextRefreshOwner(status.projectId, status.tasks, milestonesById, storedKnowledgeMap, knowledgeMap, repositoryRoot);
                     if (refreshOwner && refreshOwner.task.id !== requestedTask.id) {
                         throw new WorkflowError('TRANSITION_BLOCKED', `Task ${requestedTask.id} cannot be selected while Task ${refreshOwner.task.id} requires an atomic context refresh.`, {
                             taskId: requestedTask.id,
@@ -5272,7 +5411,7 @@ export class WorkflowService {
                             contextRefresh: {
                                 action: 'task context-refresh',
                                 mode: refreshAssessment.mode,
-                                authority: readFailedStepPlanningRecovery(this.store, activeTask) ? 'planning-only' : 'execution',
+                                authority: (this.registeredPlanningContextTransport(activeTask, repositoryRoot) || readFailedStepPlanningRecovery(this.store, activeTask)) ? 'planning-only' : 'execution',
                                 addedSources: refreshAssessment.addedSources,
                                 options: contextRefreshOptions,
                             },
@@ -5878,12 +6017,13 @@ export class WorkflowService {
                     : {};
         const correctiveReplanOverlay = (posture) => {
             const evaluation = evaluateTaskCorrectiveReplanAvailability(task, posture);
+            const replanDelegations = this.delegatedApprovalOptions(task.projectId, 'task.execution_authorize', task);
             const writerLease = inspectRawWriterLease(this.store.lockRoot(task.projectId), task.id, this.store.root);
             const command = handoffPosture.state === 'claimed'
                 ? 'task corrective-yield'
                 : writerLease
                     ? 'doctor'
-                    : 'task corrective-replan-prepare';
+                    : replanDelegations.length ? 'task corrective-replan-authorize' : 'task corrective-replan-prepare';
             if (evaluation.allowed && handoffPosture.state === 'none' && writerLease) {
                 const navigation = correctiveReplanNavigation(evaluation);
                 return {
@@ -5914,16 +6054,19 @@ export class WorkflowService {
             return evaluation.allowed
                 ? {
                     action: command,
+                    ...(replanDelegations.length ? { delegatedApprovalOptions: replanDelegations, correctiveReplanAuthority: { mode: 'delegated', candidateField: 'delegation', actorHash: 'sha256-utf8-grant-delegate', principalHash: 'sha256-utf8-grant-principal', grantTransition: 'task.execution_authorize' } } : {}),
                     blockedAction: 'task plan-set',
                     stepId: posture.stepId,
-                    navigation: { ...correctiveReplanNavigation(evaluation), command },
+                    navigation: { ...correctiveReplanNavigation(evaluation), kind: replanDelegations.length ? 'executable' : 'human-gate', command },
                     correctiveDecisionGate: {
                         attemptCount: posture.attemptCount,
                         decision: posture.correctiveDecision?.decision ?? null,
                         decisionEventId: posture.correctiveDecision?.eventId ?? null,
                         requiredAction: handoffPosture.state === 'claimed'
                             ? 'Yield the exact C1 claim and writer lease before preparing replacement authority.'
-                            : 'Prepare a state-bound candidate, confirm the Human gate, then execute its exact receipt.',
+                            : replanDelegations.length
+                                ? 'Prepare an independently validated same-scope candidate with the eligible grant and actor; authorize it without Human confirmation, then execute its exact delegated receipt.'
+                                : 'No eligible execution grant: request issuance/expansion of grant for delegate mode; the explicit Human preparation route remains available outside delegate mode.',
                     },
                 }
                 : {
@@ -6461,12 +6604,14 @@ export class WorkflowService {
         // fix review. Advertise the existing append-only decision route without turning
         // every ordinary repair into a mandatory replan or rewriting that review.
         const correctiveDecisionOrdinal = failedStepRemediations.length + 1;
+        const firstFailurePlanningObstruction = planningRecovery && failedStep
+            ? firstFailurePlanningObstructionEvidence(this.store, task, failedStep.id) : null;
         const optionalCorrectiveDecision = (result.action === 'task run' || planningRecovery !== null)
             && (['needs_fix', 'ready'].includes(task.status) || planningRecovery !== null)
             && failedStep && task.planHash && planRiskAudit
             && planRiskAudit.reviewRequiredStepIds.includes(failedStep.id)
             && !task.steps.some(step => step.status === 'in_progress')
-            && failedStepRemediations.length >= 2
+            && (failedStepRemediations.length >= 2 || firstFailurePlanningObstruction !== null)
             && handoffPosture.state !== 'pending'
             && !readCorrectiveDecisionEvents(this.store, task).some(event => event.stepId === failedStep.id && event.triggeringAttemptCount === correctiveDecisionOrdinal)
             && correctiveDecisionCheckoutEligible(this.store, repositoryRoot, task, failedStep.id)
@@ -6485,12 +6630,13 @@ export class WorkflowService {
                 recommendedAuditor: defaultCorrectiveAuditorActor(task.id),
                 auditorMustDifferFromLatestStrictReviewer: true,
                 requiredActor: handoffPosture.state === 'claimed' ? handoffPosture.claimant : null,
-                decisions: planningRecovery ? ['replan-required', 'split-required', 'stop-escalate']
-                    : ['continue-fix', 'replan-required', 'split-required', 'stop-escalate'],
+                decisions: firstFailurePlanningObstruction ? ['replan-required']
+                    : planningRecovery ? ['replan-required', 'split-required', 'stop-escalate']
+                        : ['continue-fix', 'replan-required', 'split-required', 'stop-escalate'],
                 authority: 'none',
                 preservesOriginalReview: true,
                 humanApprovalRequiredForDecision: false,
-                replanRequiresExistingHumanGate: true,
+                replanRequiresBoundAuthorization: true,
                 requiredAction: 'Only for newly assessed evidence: obtain an independent corrective audit, refresh next and existing writer authority, then record the decision. This option does not authorize Plan replacement or extra writes.',
             }
             : null;
@@ -6538,7 +6684,28 @@ export class WorkflowService {
             },
         };
     }
-    taskContextChangeBlocker(task, operation) {
+    registeredPlanningContextTransport(task, repositoryRoot) {
+        const failedTransport = repositoryRoot
+            && task.status === 'awaiting_execution_authorization'
+            && !task.steps.some(step => step.status === 'in_progress')
+            && !readPlanRiskAuditEvents(this.store, task).some(event => event.planHash === task.planHash && event.decision !== 'stop-escalate')
+            && readCorrectiveDecisionEvents(this.store, task).length === 0
+            ? task.dependencyProvenanceRecoveries?.find(record => record.failedCheckpoint
+                && task.steps.some(step => step.id === record.failedCheckpoint.stepId && step.status === 'failed'))
+            : null;
+        if (failedTransport?.failedCheckpoint && repositoryRoot) {
+            const binding = failedTransport.failedCheckpoint;
+            // Historical transports remain readable after later legitimate progress. Validate
+            // their artifact first, but require current dirty bytes only for this exact checkpoint.
+            readVerifiedPlanArtifact(this.store.taskRoot(task.projectId, task.id), binding.sourcePlanHash, task.planHash);
+            if (binding.sourcePlanHash !== task.planHash)
+                return null;
+            if (readFailedCheckpointDirtyTransport(this.store, repositoryRoot, task, binding.stepId, binding.sourceHead, binding.sourceDirtyHash))
+                return binding;
+        }
+        return null;
+    }
+    taskContextChangeBlocker(task, operation, repositoryRoot) {
         const blocked = (error) => ({ error, activeStep: false });
         if (readCurrentPreExecutionReplan(this.store, task)) {
             return blocked(new WorkflowError('TRANSITION_BLOCKED', `Task ${task.id} has a pending pre-execution replan; replace the implementation Plan before changing context.`, { taskId: task.id, requiredAction: 'task plan-set' }));
@@ -6549,6 +6716,8 @@ export class WorkflowService {
                 requiredAction: 'Run task plan-set with the full unfinished remainder before requesting authorization.',
             }));
         }
+        if (repositoryRoot && this.registeredPlanningContextTransport(task, repositoryRoot))
+            return null;
         const posture = this.taskTerminalCorrectivePosture(task);
         if (posture) {
             return blocked(new WorkflowError('TRANSITION_BLOCKED', `Task ${task.id} has terminal corrective decision ${posture.posture}; Project Knowledge cannot rebind or refresh this Task.`, {
@@ -6636,10 +6805,11 @@ export class WorkflowService {
             policyHash: grant.policyHash,
         }));
     }
-    delegatedContextRefreshOptions(projectId, task, knowledgeMap, mode) {
+    delegatedContextRefreshOptions(projectId, task, knowledgeMap, mode, repositoryRoot) {
         let planningRecovery;
         try {
-            planningRecovery = readFailedStepPlanningRecovery(this.store, task);
+            planningRecovery = this.registeredPlanningContextTransport(task, repositoryRoot)
+                ?? readFailedStepPlanningRecovery(this.store, task);
             if (!planningRecovery)
                 readCurrentPlanRiskAudit(this.store, task);
         }
@@ -6676,7 +6846,7 @@ export class WorkflowService {
             policyHash: grant.policyHash,
         }));
     }
-    findDelegatedContextRefreshOwner(projectId, tasks, milestonesById, approved, inspected) {
+    findDelegatedContextRefreshOwner(projectId, tasks, milestonesById, approved, inspected, repositoryRoot) {
         const tasksById = new Map(tasks.map((task) => [task.id, task]));
         for (const task of tasks) {
             if (!taskIsActionableFromRepositoryNext(task, milestonesById, tasksById)
@@ -6685,8 +6855,8 @@ export class WorkflowService {
             const assessment = assessDelegatedKnowledgeRefresh(approved, inspected, task, this.store.hashArtifact(this.store.taskRoot(projectId, task.id), 'plan.md'));
             if (!assessment.eligible)
                 continue;
-            const options = this.delegatedContextRefreshOptions(projectId, task, inspected, assessment.mode);
-            if (options.length > 0 && this.taskContextChangeBlocker(task, 'refresh') === null)
+            const options = this.delegatedContextRefreshOptions(projectId, task, inspected, assessment.mode, repositoryRoot);
+            if (options.length > 0 && this.taskContextChangeBlocker(task, 'refresh', repositoryRoot) === null)
                 return { task, assessment, options };
         }
         return null;