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

package/src/state/corrective-replan-public.ts

@@ -13,9 +13,11 @@ import {
 } from '../alpha6/remediation.js';
 import { pathAllowed, validatePlan } from '../domain/validation.js';
 import { WorkflowError } from '../errors.js';
+import { assertDelegationCanAuthorize } from '../delegation.js';
 import { hashKnowledgeMap } from '../memory.js';
 import { changedFiles, headCommit } from '../repository.js';
 import { hashDirtyWorktree } from '../alpha6/downstream-proof.js';
+import { readFailedCheckpointDirtyTransport } from '../failed-checkpoint-update.js';
 import { PACKAGE_VERSION } from '../version.js';
 import { GuardedTransitionCatalog } from '../lifecycle/catalog.js';
 import { correctiveReplanBindingManifest } from '../lifecycle/corrective-replan-binding-manifest.js';
@@ -92,6 +94,7 @@ export interface CorrectiveReplanValidationEvidence {
 }
 
 export interface CorrectiveReplanPublicCandidate {
+  readonly delegation?: { readonly grantId: string; readonly actor: string };
   readonly plan: TaskPlanInput;
   readonly validation: CorrectiveReplanValidationEvidence;
   readonly riskAudit: CorrectiveReplanRiskAuditInput;
@@ -99,7 +102,7 @@ export interface CorrectiveReplanPublicCandidate {
 }
 
 export interface CorrectiveReplanHumanGate {
-  readonly kind: 'corrective-replan-human-gate';
+  readonly kind: 'corrective-replan-human-gate' | 'corrective-replan-delegated-binding';
   readonly version: 1;
   readonly taskId: string;
   readonly preparedAtMs: number;
@@ -136,6 +139,7 @@ export interface CorrectiveReplanPublicCredential {
 }
 
 export interface CorrectiveReplanPublicController {
+  authorizeDelegated(input: { taskId: string; candidate: CorrectiveReplanPublicCandidate }): CorrectiveReplanPublicCredential;
   prepare(input: { taskId: string; candidate: CorrectiveReplanPublicCandidate }): CorrectiveReplanHumanGateResult;
   confirm(input: {
     taskId: string;
@@ -192,6 +196,7 @@ export function createCorrectiveReplanPublicController(options: ControllerOption
   const prepare = (input: { taskId: string; candidate: CorrectiveReplanPublicCandidate }): CorrectiveReplanHumanGateResult => {
     const owned = ownRequest(input);
     assertPublicCandidate(owned.candidate);
+    if (owned.candidate.delegation) throw new WorkflowError('INVALID_ARGUMENT', 'Use corrective-replan-authorize for delegated candidates.');
     const preparedAtMs = now().getTime();
     const chain = buildChain(options, owned.taskId, owned.candidate, preparedAtMs);
     return assertCorrectiveReplanPublicOutput('humanGateResult', deepFreeze({
@@ -209,6 +214,7 @@ export function createCorrectiveReplanPublicController(options: ControllerOption
   }): CorrectiveReplanPublicCredential => {
     const owned = ownRequest(input);
     assertPublicCandidate(owned.candidate);
+    if (owned.candidate.delegation) throw new WorkflowError('INVALID_ARGUMENT', 'Delegated candidates cannot use Human confirmation.');
     assertGateTime(owned.gate, now().getTime());
     const chain = buildChain(options, owned.taskId, owned.candidate, owned.gate.preparedAtMs);
     if (!same(chain.gate, owned.gate)) throw new WorkflowError('STATE_CONFLICT', 'Corrective-replan Human gate is stale or malformed.');
@@ -237,6 +243,17 @@ export function createCorrectiveReplanPublicController(options: ControllerOption
     }));
   };
 
+  const authorizeDelegated = (input: { taskId: string; candidate: CorrectiveReplanPublicCandidate }): CorrectiveReplanPublicCredential => {
+    const owned = ownRequest(input); assertPublicCandidate(owned.candidate);
+    if (!owned.candidate.delegation) throw new WorkflowError('INVALID_ARGUMENT', 'Delegated corrective replan requires an explicit grant and actor.');
+    const chain = buildChain(options, owned.taskId, owned.candidate, now().getTime());
+    const confirmation = accepted(chain.kernel.confirmDelegated({ challenge: chain.challenge }), 'Delegated authorization was rejected.');
+    const receipt = accepted(chain.kernel.issueReceipt({ planValidation: chain.planValidation, confirmation: confirmation.handle }), 'Delegated receipt issuance was rejected.');
+    const event = accepted(chain.kernel.materializeStoredEvent({ receipt: receipt.handle }), 'Plan Validation event materialization was rejected.');
+    return assertCorrectiveReplanPublicOutput('credential', deepFreeze({ kind: 'corrective-replan-public-credential', version: 1,
+      gate: chain.gate, receipt: receipt.receipt as JsonRecord, planValidationEvent: event.event as JsonRecord }));
+  };
+
   const execute = (input: {
     taskId: string;
     candidate: CorrectiveReplanPublicCandidate;
@@ -292,7 +309,7 @@ export function createCorrectiveReplanPublicController(options: ControllerOption
     return assertCorrectiveReplanPublicOutput('executionResult', executor(owned.taskId, inertKernel()).recover({ taskId: owned.taskId, transactionId: owned.transactionId }));
   };
 
-  return deepFreeze({ prepare, confirm, execute, recover });
+  return deepFreeze({ prepare, confirm, authorizeDelegated, execute, recover });
 }
 
 function assertCanonicalAdmission(
@@ -397,13 +414,15 @@ function buildChain(
     } },
   });
   const validation = accepted(kernel.issuePlanValidation({ taskId, draft: validationDraft(initialSnapshot, candidate.validation) }), 'Plan Validation issuance was rejected.');
-  const challenge = accepted(kernel.issueHumanChallenge({ planValidation: validation.handle }), 'Human challenge issuance was rejected.');
+  const challenge = accepted(candidate.delegation
+    ? kernel.issueDelegatedChallenge({ planValidation: validation.handle })
+    : kernel.issueHumanChallenge({ planValidation: validation.handle }), 'Authorization binding issuance was rejected.');
   const delivery = record(challenge.delivery);
   const binding = record(validation.binding);
   const attestation = record(validation.attestation);
   const values = record(binding.values);
   const gateBase = {
-    kind: 'corrective-replan-human-gate' as const,
+    kind: candidate.delegation ? 'corrective-replan-delegated-binding' as const : 'corrective-replan-human-gate' as const,
     version: 1 as const,
     taskId,
     preparedAtMs,
@@ -439,11 +458,11 @@ function confirmChain(
   const chain = buildChain(options, taskId, candidate, credential.gate.preparedAtMs, previousEventHash);
   if (!same(chain.gate, credential.gate)) throw new WorkflowError('STATE_CONFLICT', 'Corrective-replan Human gate no longer matches current state.');
   const receiptCandidate = record(credential.receipt);
-  const confirmedAtMs = number(get(receiptCandidate, '/human/confirmedAtMs'));
+  const confirmedAtMs = number(get(receiptCandidate, candidate.delegation ? '/delegated/authorizedAtMs' : '/human/confirmedAtMs'));
   const issuedAtMs = number(receiptCandidate.issuedAtMs);
   if (!Number.isSafeInteger(confirmedAtMs) || confirmedAtMs !== issuedAtMs) throw new WorkflowError('INVALID_ARGUMENT', 'Corrective-replan receipt time is invalid.');
   chain.clock.set(confirmedAtMs);
-  const confirmation = accepted(chain.kernel.confirmHuman({
+  const confirmation = accepted(candidate.delegation ? chain.kernel.confirmDelegated({ challenge: chain.challenge }) : chain.kernel.confirmHuman({
     challenge: chain.challenge,
     confirmation: {
       kind: 'corrective-replan-human-confirmation', version: 1,
@@ -494,6 +513,7 @@ function trustedSnapshot(
   }
   const task = options.store.readTask(options.projectId, taskId);
   validateCandidate(task, candidate);
+  const delegatedAuthority = candidate.delegation ? delegatedReplanAuthority(options, task, candidate) : null;
   const taskRoot = options.store.taskRoot(options.projectId, taskId);
   if (options.store.hashArtifact(taskRoot, 'brief.md') !== task.briefHash
     || !task.planHash || options.store.hashArtifact(taskRoot, 'plan.md') !== task.planHash) {
@@ -537,6 +557,7 @@ function trustedSnapshot(
   const remediationTail = matchingRemediations.at(-1);
   if (!remediationTail || matchingRemediations.length !== posture.attemptCount) throw new WorkflowError('STATE_CORRUPT', 'Corrective-replan remediation tail is ambiguous.');
   assertCorrectiveReplanKnowledgeTransition(
+    options.store,
     options.repositoryRoot,
     task,
     posture.stepId,
@@ -601,6 +622,7 @@ function trustedSnapshot(
   });
   return {
     snapshotVersion: 2,
+    ...(delegatedAuthority ? { delegatedAuthority } : {}),
     bindingManifest: correctiveReplanBindingManifest,
     worktree,
     baseValues,
@@ -625,6 +647,7 @@ function trustedSnapshot(
 }
 
 function assertCorrectiveReplanKnowledgeTransition(
+  store: FileStateStore,
   repositoryRoot: string,
   task: TaskState,
   stepId: string,
@@ -634,6 +657,13 @@ function assertCorrectiveReplanKnowledgeTransition(
   targetKnowledgeHash: string,
 ): void {
   if (task.knowledgeMapRevision === targetKnowledgeRevision && task.knowledgeMapHash === targetKnowledgeHash) return;
+  const terminal = readRemediationEvents(store, task).filter(event => event.stepId === stepId).at(-1);
+  if (terminal?.failureEvidence.dirtyWorktreeHash) {
+    const transported = readFailedCheckpointDirtyTransport(store, repositoryRoot, task, stepId,
+      terminal.failureEvidence.completionCommit, terminal.failureEvidence.dirtyWorktreeHash);
+    if (transported && transported.targetHead === gitHead
+      && remediationEventIds.includes(terminal.eventId)) return;
+  }
   const compatibility = [...(task.dependencyProvenanceRecoveries ?? [])].reverse().find((record) =>
     record.commitSha === gitHead
     && record.packageVersion === PACKAGE_VERSION
@@ -712,6 +742,20 @@ function guardedStepWorktreeSnapshot(
   };
 }
 
+function delegatedReplanAuthority(options: ControllerOptions, task: TaskState, candidate: CorrectiveReplanPublicCandidate): JsonRecord {
+  const request = candidate.delegation!;
+  const grant = options.store.readDelegation(options.projectId, request.grantId);
+  const evidence = assertDelegationCanAuthorize(grant, 'task.execution_authorize', request.actor, task, (options.now ?? (() => new Date()))());
+  // These are public actor identifiers, not user confirmation or vault credentials.
+  const identityHash = (actor: string) => createHash('sha256').update(actor).digest('hex');
+  if (candidate.authority.actorIdentityHash !== identityHash(grant.delegate)
+    || candidate.authority.humanPrincipalIdentityHash !== identityHash(grant.principal))
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Delegated corrective actor/principal hashes must match the exact grant actors (SHA256 UTF-8).');
+  if (candidate.plan.objective !== task.planObjective)
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Delegated corrective replan cannot change the approved objective; return to Discovery.');
+  return { ...evidence, expiresAt: grant.expiresAt };
+}
+
 function validateCandidate(task: TaskState, candidate: CorrectiveReplanPublicCandidate): void {
   validatePlan(candidate.plan);
   for (const requirement of task.requirements) if (!candidate.plan.requirements.includes(requirement)) {

package/src/version.ts

@@ -1,2 +1,2 @@
 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';

package/src/workflow-blocker-route.ts

@@ -79,7 +79,7 @@ export function withWorkflowBlockerRoute(next: ObjectValue, packageVersion: stri
         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/src/workflow.ts

@@ -1,5 +1,7 @@
 import { assessNavigationDirtyCarryover } from './alpha6/navigation-dirty-carryover.js';
 import { navigationUpdateSource, assertNavigationSourceInstalled, inspectNavigationTransport, type NavigationUpdateReceipt } from './navigation-update.js';
+import { failedCheckpointUpdateSource, assertFailedCheckpointInstalled, inspectFailedCheckpointTransport, readFailedCheckpointDirtyTransport,
+  FAILED_CHECKPOINT_SOURCE, FAILED_CHECKPOINT_TARGET, type FailedCheckpointUpdateReceipt } from './failed-checkpoint-update.js';
 import { verifyNavigationUpdateArtifact } from './navigation-update-artifact.js';
 import type { CheckExecutionOptions } from './checks/runner.js';
 import { taskSyncChecks, taskSyncChecksHash, assertNoPendingBaseSyncValidation, assessPendingBaseSyncValidation, assertPendingBaseSyncValidationReady } from './checks/task-sync.js';
@@ -159,6 +161,7 @@ import {
 } from './alpha6/root-cause-replan-carryover.js';
 import {
   appendCorrectiveDecisionEvent,
+  firstFailurePlanningObstructionEvidence,
   appendPlanIntegrityRecoveryDecision,
   assertCorrectiveAuditorIndependence,
   assertGuardedRemediationAttemptAllowed,
@@ -226,6 +229,8 @@ import {
 } from './alpha6/review.js';
 import {
   applyMilestoneAutonomyContract,
+  bindMilestoneAutonomyToGrant,
+  milestoneSemanticScopeHash,
   assertAutonomousPlanEvolution,
   prepareMilestoneAutonomyContract,
   readMilestoneAutonomyEvents,
@@ -568,6 +573,10 @@ export class WorkflowService {
     };
   }
 
+  authorizeDelegatedCorrectiveReplan(repository: string, taskId: string, candidate: CorrectiveReplanPublicCandidate): CorrectiveReplanPublicCredential {
+    return this.correctiveReplanController(repository).authorizeDelegated({ taskId, candidate });
+  }
+
   prepareCorrectiveReplan(
     repository: string,
     taskId: string,
@@ -2022,6 +2031,19 @@ export class WorkflowService {
     }
   }
 
+  bindMilestoneAutonomy(repository: string, milestoneId: string, expectedRevision: number,
+    actor: string, grantId: string): ActiveMilestoneAutonomy {
+    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: string,
     milestoneId: string,
@@ -2824,7 +2846,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;
     if (
@@ -2935,7 +2957,7 @@ 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(
@@ -2943,8 +2965,12 @@ export class WorkflowService {
       scanProjectKnowledge(identity.repositoryRoot, identity.projectId, this.now()),
     );
     const transitions: string[] = [];
-    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;
@@ -2954,7 +2980,7 @@ export class WorkflowService {
       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.');
     }
 
@@ -3041,7 +3067,7 @@ export class WorkflowService {
         }
         transitions.push('task knowledge-rebind');
         // A stopped Plan may regain its Knowledge binding, never execution authority.
-        if (!planningRecovery) refreshedTask = this.authorizeTask(
+        if (!planningOnly) refreshedTask = this.authorizeTask(
           repository,
           taskId,
           refreshedTask.revision,
@@ -3051,9 +3077,9 @@ export class WorkflowService {
             : 'Delegated content-only context refresh.',
           delegationGrantId,
         );
-        if (!planningRecovery) transitions.push('task execution authorize');
+        if (!planningOnly) transitions.push('task execution authorize');
         return {
-          authority: planningRecovery ? 'planning-only' as const : 'execution' as const,
+          authority: planningOnly ? 'planning-only' as const : 'execution' as const,
           mode: refreshAssessment.mode,
           transitions,
           addedSources: refreshAssessment.addedSources,
@@ -3063,10 +3089,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)
@@ -5400,6 +5437,7 @@ export class WorkflowService {
     repository: string,
     actor: string,
     confirmationCode: string,
+    delegationGrantId: string | null = null,
   ): AdoptionPostureEvent {
     const context = this.#mutationContext(repository);
     const tasks = context.store.listTasks(context.identity.projectId);
@@ -5420,6 +5458,7 @@ export class WorkflowService {
       },
       actor,
       confirmationCode,
+      delegationGrantId,
     );
   }
 
@@ -5525,6 +5564,51 @@ export class WorkflowService {
     return { snapshot, task, root: snapshot.identity.repositoryRoot };
   }
 
+  failedCheckpointUpdateSourcePreflight(repository: string, taskId: string, tarball: string) {
+    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: [] as string[], receipt };
+    } catch (error) {
+      return { eligible: false, blockers: [error instanceof Error ? error.message : String(error)], receipt: null };
+    }
+  }
+
+  failedCheckpointUpdateTransportPreflight(repository: string, taskId: string, tarball: string, receipt: FailedCheckpointUpdateReceipt) {
+    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: [] as string[], 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: string, taskId: string, expectedRevision: number,
+    tarball: string, receipt: FailedCheckpointUpdateReceipt, actor: string, reason: string): TaskState {
+    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: TaskState = { ...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: string, taskId: string, tarball: string) {
     try {
       const { task, root } = this.navigationUpdateBoundary(repository, taskId);
@@ -6061,6 +6145,7 @@ export class WorkflowService {
         milestonesById,
         current,
         inspected,
+        identity.repositoryRoot,
       );
       if (refreshOwner) {
         throw new WorkflowError(
@@ -6259,7 +6344,16 @@ 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,
@@ -6268,7 +6362,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',
@@ -6290,6 +6384,36 @@ export class WorkflowService {
     }
     const withAdoption = (value: Record<string, unknown>): Record<string, unknown> => ({
       ...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)
@@ -6414,7 +6538,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;
+          status.projectId, status.tasks, milestonesById, approved, inspected, repositoryRoot)?.task ?? null;
       }
     }
     const activeTask = requestedTask
@@ -6466,6 +6590,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')) {
@@ -6807,6 +6942,7 @@ export class WorkflowService {
               activeTask,
               knowledgeMap,
               refreshAssessment.mode,
+              repositoryRoot,
             )
           : [];
         if (requestedTask && action === 'project-memory reconcile' && contextRefreshOptions.length === 0) {
@@ -6816,6 +6952,7 @@ export class WorkflowService {
             milestonesById,
             storedKnowledgeMap,
             knowledgeMap,
+            repositoryRoot,
           );
           if (refreshOwner && refreshOwner.task.id !== requestedTask.id) {
             throw new WorkflowError(
@@ -6847,7 +6984,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,
                 },
@@ -7511,12 +7648,13 @@ export class WorkflowService {
           : {};
     const correctiveReplanOverlay = (posture: Readonly<CorrectiveReplanPosture>): Record<string, unknown> => {
       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 {
@@ -7547,16 +7685,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.',
             },
           }
         : {
@@ -8114,12 +8255,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)
@@ -8139,12 +8282,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']
+          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;
@@ -8194,7 +8338,28 @@ export class WorkflowService {
     };
   }
 
-  private taskContextChangeBlocker(task: TaskState, operation: 'rebind' | 'refresh'): { error: WorkflowError; activeStep: boolean } | null {
+  private registeredPlanningContextTransport(task: TaskState, repositoryRoot?: string) {
+    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;
+  }
+
+  private taskContextChangeBlocker(task: TaskState, operation: 'rebind' | 'refresh', repositoryRoot?: string): { error: WorkflowError; activeStep: boolean } | null {
     const blocked = (error: WorkflowError) => ({ error, activeStep: false });
     if (readCurrentPreExecutionReplan(this.store, task)) {
       return blocked(new WorkflowError(
@@ -8213,6 +8378,7 @@ export class WorkflowService {
         },
       ));
     }
+    if (repositoryRoot && this.registeredPlanningContextTransport(task, repositoryRoot)) return null;
     const posture = this.taskTerminalCorrectivePosture(task);
     if (posture) {
       return blocked(new WorkflowError(
@@ -8330,10 +8496,12 @@ export class WorkflowService {
     task: TaskState,
     knowledgeMap: ProjectKnowledgeMap,
     mode: DelegatedKnowledgeRefreshMode,
+    repositoryRoot?: string,
   ): Array<DelegatedApprovalOption & { transitions: DelegationTransition[] }> {
     let planningRecovery;
     try {
-      planningRecovery = readFailedStepPlanningRecovery(this.store, task);
+      planningRecovery = this.registeredPlanningContextTransport(task, repositoryRoot)
+        ?? readFailedStepPlanningRecovery(this.store, task);
       if (!planningRecovery) readCurrentPlanRiskAudit(this.store, task);
     } catch (error) {
       if (error instanceof WorkflowError && error.code === 'TRANSITION_BLOCKED') return [];
@@ -8391,6 +8559,7 @@ export class WorkflowService {
     milestonesById: Map<string, MilestoneState>,
     approved: ProjectKnowledgeMap,
     inspected: ProjectKnowledgeMap,
+    repositoryRoot?: string,
   ): {
     task: TaskState;
     assessment: DelegatedKnowledgeRefreshAssessment;
@@ -8414,8 +8583,9 @@ export class WorkflowService {
         task,
         inspected,
         assessment.mode,
+        repositoryRoot,
       );
-      if (options.length > 0 && this.taskContextChangeBlocker(task, 'refresh') === null) return { task, assessment, options };
+      if (options.length > 0 && this.taskContextChangeBlocker(task, 'refresh', repositoryRoot) === null) return { task, assessment, options };
     }
     return null;
   }