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

package/src/cli.ts

@@ -70,6 +70,9 @@ interface CliHelpSpec {
 
 const CLI_HELP_SPECS: Record<string, CliHelpSpec> = {
   'update navigation-source-preflight': { requiredOptions: ['--id', '--tarball'], optionalOptions: ['--repo', '--json'] },
+  'update failed-checkpoint-source-preflight': { requiredOptions: ['--id', '--tarball'], optionalOptions: ['--repo', '--json'] },
+  'update failed-checkpoint-transport-preflight': { requiredOptions: ['--id', '--tarball', '--file'], optionalOptions: ['--repo', '--json'] },
+  'update failed-checkpoint-recover': { requiredOptions: ['--id', '--tarball', '--file', '--expected-revision', '--actor', '--reason'], optionalOptions: ['--repo', '--json'] },
   'update navigation-transport-preflight': { requiredOptions: ['--id', '--tarball', '--file'], optionalOptions: ['--repo', '--json'] },
   'update navigation-recover': { requiredOptions: ['--id', '--tarball', '--file', '--expected-revision', '--actor', '--reason'], optionalOptions: ['--repo', '--json'] },
   'change explain': { requiredOptions: ['--task', '--file'], optionalOptions: ['--repo', '--json'] },
@@ -113,6 +116,14 @@ const CLI_HELP_SPECS: Record<string, CliHelpSpec> = {
     requiredOptions: ['--id'],
     optionalOptions: ['--repo', '--json'],
   },
+  'state adoption-apply': {
+    requiredOptions: ['--actor', '--confirmation-code'],
+    optionalOptions: ['--delegation-grant', '--repo', '--json'],
+  },
+  'milestone autonomy-bind': {
+    requiredOptions: ['--id', '--expected-revision', '--actor', '--delegation-grant'],
+    optionalOptions: ['--repo', '--json'],
+  },
   'milestone authorize': {
     requiredOptions: ['--id', '--expected-revision'],
     optionalOptions: ['--actor', '--reason', '--delegation-grant', '--repo', '--json'],
@@ -172,6 +183,10 @@ const CLI_HELP_SPECS: Record<string, CliHelpSpec> = {
     requiredOptions: ['--id', '--transaction-id'],
     optionalOptions: ['--repo', '--json'],
   },
+  'task corrective-replan-authorize': {
+    requiredOptions: ['--id', '--file'],
+    optionalOptions: ['--repo', '--json'],
+  },
   'task corrective-replan-prepare': {
     requiredOptions: ['--id', '--file'],
     optionalOptions: ['--repo', '--json'],
@@ -567,6 +582,16 @@ async function dispatch(args: ParsedArguments): Promise<unknown> {
   if (noun === 'update' && action === 'navigation-source-preflight') {
     return workflow.navigationUpdateSourcePreflight(repo, required(args, 'id'), required(args, 'tarball'));
   }
+  if (noun === 'update' && action === 'failed-checkpoint-source-preflight') {
+    return workflow.failedCheckpointUpdateSourcePreflight(repo, required(args, 'id'), required(args, 'tarball'));
+  }
+  if (noun === 'update' && action === 'failed-checkpoint-transport-preflight') {
+    return workflow.failedCheckpointUpdateTransportPreflight(repo, required(args, 'id'), required(args, 'tarball'), jsonFile(args));
+  }
+  if (noun === 'update' && action === 'failed-checkpoint-recover') {
+    return workflow.recoverFailedCheckpointUpdate(repo, required(args, 'id'), revision(args), required(args, 'tarball'),
+      jsonFile(args), required(args, 'actor'), required(args, 'reason'));
+  }
   if (noun === 'update' && action === 'navigation-transport-preflight') {
     return workflow.navigationUpdateTransportPreflight(repo, required(args, 'id'), required(args, 'tarball'), jsonFile(args));
   }
@@ -685,6 +710,7 @@ async function dispatch(args: ParsedArguments): Promise<unknown> {
       repo,
       required(args, 'actor'),
       required(args, 'confirmation-code'),
+      option(args, 'delegation-grant') ?? null,
     );
   }
   if (noun === 'milestone' && action === 'recover') {
@@ -1087,6 +1113,9 @@ async function dispatch(args: ParsedArguments): Promise<unknown> {
   if (noun === 'task' && action === 'corrective-yield-recover') {
     return workflow.recoverCorrectiveYield(repo, required(args, 'id'), required(args, 'transaction-id'));
   }
+  if (noun === 'task' && action === 'corrective-replan-authorize') {
+    return workflow.authorizeDelegatedCorrectiveReplan(repo, required(args, 'id'), jsonFile<CorrectiveReplanPublicCandidate>(args));
+  }
   if (noun === 'task' && action === 'corrective-replan-prepare') {
     return workflow.prepareCorrectiveReplan(
       repo,
@@ -1339,6 +1368,10 @@ async function dispatch(args: ParsedArguments): Promise<unknown> {
       required(args, 'actor'),
     );
   }
+  if (noun === 'milestone' && action === 'autonomy-bind') {
+    return workflow.bindMilestoneAutonomy(repo, required(args, 'id'), revision(args),
+      required(args, 'actor'), required(args, 'delegation-grant'));
+  }
   if (noun === 'milestone' && action === 'authorize') {
     return workflow.authorizeMilestone(
       repo,

package/src/contracts.ts

@@ -39,6 +39,7 @@ export type AuthorizationKind = 'execution' | 'final_acceptance' | 'exception';
 export type AuthorizationMode = 'human' | 'delegated' | 'corrective-derived';
 export type DelegationStatus = 'active' | 'revoked';
 export type DelegationTransition =
+  | 'project.adopt'
   | 'project_memory.approve'
   | 'task.execution_authorize'
   | 'task.final_accept'
@@ -734,8 +735,23 @@ export interface CorrectiveDecisionEvent extends SidecarEventRecord {
   coveredFindingIds: string[];
   coveredEventIds: string[];
   planHash: string;
-  recoveryBasis?: 'plan-integrity';
+  recoveryBasis?: 'plan-integrity' | 'planning-obstruction';
   planIntegrityEvidence?: PlanIntegrityConflictEvidence;
+  planningObstructionEvidence?: {
+    kind: 'first-failure-rebound-planning-obstruction';
+    taskRevision: number;
+    sourcePlanHash: string;
+    baselinePlanHash: string;
+    baselineAuditEventId: string;
+    baselineAuditEventHash: string;
+    obstructionAuditEventId: string;
+    obstructionAuditEventHash: string;
+    priorAuthorizationHash: string;
+    remediationEventId: string;
+    remediationEventHash: string;
+    knowledgeRebindCount: number;
+    knowledgeRebindHash: string;
+  };
 }
 
 export interface CorrectiveDecisionRecoveryEvent extends SidecarEventRecord {
@@ -935,6 +951,7 @@ export interface AdoptionRepositoryIdentity {
 }
 
 export interface AdoptionPostureEvent extends SidecarEventRecord {
+  delegatedAuthorization?: DelegatedAuthorizationEvidence;
   projectId: string;
   eventType: AdoptionPostureEventType;
   actor: string | null;
@@ -1175,6 +1192,7 @@ export interface DependencyProvenanceRecoveryRecord {
   historicalStepProvenance?: HistoricalStepDependencyCompatibility;
   planIntegrity?: PlanIntegrityUpdateCompatibility;
   rootCauseReplan?: RootCauseReplanDirtyCarryoverCompatibility;
+  failedCheckpoint?: import('./failed-checkpoint-update.js').FailedCheckpointUpdateBinding;
 }
 
 export interface RootCauseReplanDirtyCarryoverCompatibility {

package/src/delegation.ts

@@ -12,6 +12,7 @@ import type {
 import { WorkflowError } from './errors.js';
 
 const TRANSITIONS: readonly DelegationTransition[] = [
+  'project.adopt',
   'project_memory.approve',
   'task.execution_authorize',
   'task.final_accept',
@@ -19,7 +20,7 @@ const TRANSITIONS: readonly DelegationTransition[] = [
   'milestone.final_accept',
 ];
 
-type DelegationTarget = TaskState | MilestoneState | ProjectKnowledgeMap;
+type DelegationTarget = TaskState | MilestoneState | ProjectKnowledgeMap | { kind: 'project'; id: string; milestoneId?: null };
 
 export function prepareDelegationGrantGate(
   projectId: string,
@@ -64,6 +65,9 @@ export function normalizeDelegationPolicy(
     });
   }
   transitions.sort();
+  if (transitions.includes('project.adopt') && scope.kind !== 'project') {
+    throw new WorkflowError('INVALID_ARGUMENT', 'project.adopt requires project scope.');
+  }
   if (transitions.includes('project_memory.approve') && scope.kind !== 'project') {
     throw new WorkflowError(
       'INVALID_ARGUMENT',

package/src/failed-checkpoint-update.ts

@@ -0,0 +1,203 @@
+import { createHash } from 'node:crypto';
+import { existsSync, lstatSync, readFileSync, readdirSync } from 'node:fs';
+import path from 'node:path';
+import type { TaskState } from './contracts.js';
+import type { FileStateStore } from './state/store.js';
+import { canonicalJsonStringify, sha256Hex } from './alpha6/store-sidecars.js';
+import { readCorrectiveDecisionEvents, readRemediationEvents } from './alpha6/remediation.js';
+import { readTaskC1Posture, readTaskHandoffEvents } from './alpha6/handoff.js';
+import { readPlanRiskAuditEvents } from './alpha6/plan-risk.js';
+import { verifiedHistoricalStepReviewBindings } from './alpha6/review.js';
+import { readVerifiedPlanArtifact } from './domain/plan-semantics.js';
+import { pathAllowed } from './domain/validation.js';
+import { validateTaskHistory } from './git.js';
+import { inspectBoundedWorkflowDependencyCommit, workflowDependencyVersionAt } from './dependency-provenance.js';
+import { inspectWorkflowVersions } from './diagnostics.js';
+import { changedFiles, currentBranch, headCommit, runGit } from './repository.js';
+import { PACKAGE_VERSION } from './version.js';
+
+export const FAILED_CHECKPOINT_SOURCE = '2.0.0-beta.14';
+export const FAILED_CHECKPOINT_TARGET = '2.0.0-beta.14.1';
+const hash = (value: unknown) => sha256Hex(canonicalJsonStringify(value));
+function require(condition: unknown, message: string): asserts condition {
+  if (!condition) throw new Error(`FAILED_CHECKPOINT_UPDATE_BLOCKED: ${message}`);
+}
+export interface FailedCheckpointUpdateReceipt {
+  protocol: 'failed-checkpoint-update-source-v1';
+  projectId: string; taskId: string; revision: number; issuedAt: string;
+  taskHash: string; artifactsHash: string; knowledgeHash: string; milestoneHash: string | null;
+  sourceHead: string; sourceBaseHead: string; taskBranch: string; baseBranch: string;
+  sourceVersion: string; targetVersion: string; actor: string; stepId: string;
+  dirtyFiles: string[]; sourceDirtyHash: string; remediationEventId: string; remediationEventHash: string;
+  artifact: { sha256: string; runtimeHash: string };
+}
+export interface FailedCheckpointUpdateBinding {
+  protocol: 'failed-checkpoint-update-v1';
+  sourceHead: string; sourcePlanHash: string; stepId: string;
+  sourceDirtyHash: string; targetDirtyHash: string; dirtyFiles: string[];
+  remediationEventId: string; remediationEventHash: string;
+  sourceReceiptHash: string; artifactHash: string;
+}
+function filesHash(root: string): string {
+  if (!existsSync(root)) return hash([]);
+  const visit = (directory: string): Array<[string, string]> => readdirSync(directory).sort().flatMap(name => {
+    const file = path.join(directory, name); const info = lstatSync(file);
+    require(!info.isSymbolicLink() && (info.isFile() || info.isDirectory()), 'State artifacts must be regular files.');
+    return info.isDirectory() ? visit(file) : [[path.relative(root, file), sha256Hex(readFileSync(file))]];
+  });
+  return hash(visit(root));
+}
+/** Reverse only the dependency string, retaining every other byte (including whitespace and product scripts). */
+function sourceManifestBytes(content: Buffer): Buffer {
+  const text = content.toString('utf8'); const manifest = JSON.parse(text);
+  require(manifest.devDependencies?.['codex-workflow-v2'] === FAILED_CHECKPOINT_TARGET
+    && !manifest.dependencies?.['codex-workflow-v2'], 'Target working manifest must have one exact dev dependency.');
+  const key = /("codex-workflow-v2"\s*:\s*)"2\.0\.0-beta\.14\.1"/g;
+  require([...text.matchAll(key)].length === 1, 'Working manifest must have one unambiguous literal target pin.');
+  return Buffer.from(text.replace(key, `$1"${FAILED_CHECKPOINT_SOURCE}"`));
+}
+/** Same byte framing as native failure evidence; no normalization of product content. */
+export function failedCheckpointDirtyHash(repository: string, files: readonly string[], transported = false): string {
+  const digest = createHash('sha256');
+  for (const file of [...files].sort()) {
+    const absolute = path.resolve(repository, file); const relative = path.relative(repository, absolute);
+    require(relative && !relative.startsWith('..') && !path.isAbsolute(relative), 'Dirty path escapes checkout.');
+    require(existsSync(absolute) && lstatSync(absolute).isFile() && !lstatSync(absolute).isSymbolicLink(),
+      'This checkpoint supports retained regular files only.');
+    let bytes: Buffer = readFileSync(absolute);
+    if (transported && file === 'package.json') bytes = sourceManifestBytes(bytes);
+    digest.update(`path\0${file}\0file\0`); digest.update(bytes); digest.update('\0');
+  }
+  return digest.digest('hex');
+}
+function assertPins(repository: string, commit: string, version: string): void {
+  const manifest = JSON.parse(runGit(repository, ['show', `${commit}:package.json`]));
+  const lock = JSON.parse(runGit(repository, ['show', `${commit}:package-lock.json`]));
+  require(manifest.devDependencies?.['codex-workflow-v2'] === version && !manifest.dependencies?.['codex-workflow-v2']
+    && workflowDependencyVersionAt(repository, commit) === version
+    && lock.packages?.['']?.devDependencies?.['codex-workflow-v2'] === version
+    && !lock.packages?.['']?.dependencies?.['codex-workflow-v2']
+    && lock.packages?.['node_modules/codex-workflow-v2']?.version === version,
+    'Exact source manifest and lock bindings are required.');
+}
+export function assertFailedCheckpointInstalled(repository: string, task: TaskState, version: string): void {
+  const versions = inspectWorkflowVersions(repository, [task.baseBranch]);
+  require([versions.declared, versions.locked, versions.installed, versions.currentBranch,
+    ...versions.milestoneBases.map(item => item.version)].every(value => value === version),
+    `Every installed and Git version surface must equal ${version}.`);
+}
+export function failedCheckpointUpdateSource(repository: string, store: FileStateStore, task: TaskState,
+  artifact: FailedCheckpointUpdateReceipt['artifact'],
+  sourceHead = headCommit(repository), sourceBaseHead = runGit(repository, ['rev-parse', task.baseBranch]),
+  transported = false): FailedCheckpointUpdateReceipt {
+  require(PACKAGE_VERSION === FAILED_CHECKPOINT_TARGET, 'Only the beta.14 to beta.14.1 repair is supported.');
+  require(task.status === 'awaiting_execution_authorization' && task.workspaceOwner === 'external',
+    'Expected an external failed Task awaiting its new Plan audit.');
+  require(readCorrectiveDecisionEvents(store, task).length === 0,
+    'A checkpoint with corrective decision history requires its own supported boundary.');
+  require(task.taskBranch && currentBranch(repository) === task.taskBranch, 'Expected the recorded Task branch.');
+  const failed = task.steps.filter(step => step.status === 'failed');
+  require(failed.length === 1 && !task.steps.some(step => step.status === 'in_progress'), 'Exactly one paused failed Step is required.');
+  const step = failed[0]!;
+  require(step.failurePause && step.evidence === null, 'Native failed-check evidence is required.');
+  require(task.planHash && task.briefHash, 'Current Brief and Plan are required.');
+  const taskRoot = store.taskRoot(task.projectId, task.id);
+  require(store.hashArtifact(taskRoot, 'brief.md') === task.briefHash && store.hashArtifact(taskRoot, 'plan.md') === task.planHash,
+    'Brief and Plan artifacts must match state.');
+  readVerifiedPlanArtifact(taskRoot, task.planHash, task.planHash);
+  const currentAudit = readPlanRiskAuditEvents(store, task).at(-1);
+  require(!currentAudit || currentAudit.planHash !== task.planHash
+    || currentAudit.decision === 'stop-escalate', 'The checkpoint must await its audit or retain a planning obstruction.');
+  assertPins(repository, sourceHead, FAILED_CHECKPOINT_SOURCE); assertPins(repository, sourceBaseHead, FAILED_CHECKPOINT_SOURCE);
+  validateTaskHistory(repository, task, sourceHead);
+  const completed = task.steps.filter(item => item.status === 'completed');
+  const reviews = verifiedHistoricalStepReviewBindings(store, task);
+  require(completed.length > 0 && completed.every(item => item.evidence
+    && reviews.some(review => review.stepId === item.id && review.commitSha === item.evidence!.commitSha)),
+    'Every retained completed Step must have immutable execution and independent review evidence.');
+  require(step.dependencies.every(id => completed.some(item => item.id === id)), 'Failed Step dependencies must be complete.');
+  const events = readRemediationEvents(store, task).filter(event => event.stepId === step.id && event.failureKind === 'checks-failed');
+  require(events.length === 1, 'This checkpoint supports exactly the first native check failure.');
+  const terminal = events.at(-1);
+  require(terminal && terminal.failureEvidence.completionCommit === sourceHead
+    && terminal.failureEvidence.dirtyWorktreeHash === step.failurePause.dirtyWorktreeHash,
+    'Native terminal failure must bind source HEAD and retained dirty bytes.');
+  const dirtyFiles = changedFiles(repository).sort();
+  require(dirtyFiles.length > 0 && !dirtyFiles.includes('package-lock.json')
+    && JSON.stringify(dirtyFiles) === JSON.stringify([...step.failurePause.dirtyFiles].sort()),
+    'Dirty paths must equal the native failure; dirty lockfile transport is unsupported.');
+  require(dirtyFiles.every(file => pathAllowed(file, step.allowedWrites) && !pathAllowed(file, step.forbiddenScope)),
+    'Retained dirty files must be inside the failed Step scope.');
+  const sourceDirtyHash = failedCheckpointDirtyHash(repository, dirtyFiles, transported);
+  require(sourceDirtyHash === terminal.failureEvidence.dirtyWorktreeHash, 'Product bytes changed since native failure.');
+  const posture = readTaskC1Posture(store, task);
+  const claim = readTaskHandoffEvents(store, task).filter(event => event.eventType === 'claim').at(-1);
+  require(posture.state === 'claimed' && claim && posture.claimant === claim.actor && claim.briefHash === task.briefHash,
+    'Original immutable Worker claim is required.');
+  return { protocol: 'failed-checkpoint-update-source-v1', projectId: task.projectId, taskId: task.id,
+    revision: task.revision, issuedAt: task.updatedAt, taskHash: hash(task), artifactsHash: filesHash(taskRoot),
+    knowledgeHash: hash(store.readKnowledgeMap(task.projectId)),
+    milestoneHash: task.milestoneId ? hash(store.readMilestone(task.projectId, task.milestoneId)) : null,
+    sourceHead, sourceBaseHead, taskBranch: task.taskBranch, baseBranch: task.baseBranch,
+    sourceVersion: FAILED_CHECKPOINT_SOURCE, targetVersion: FAILED_CHECKPOINT_TARGET, actor: claim.actor,
+    stepId: step.id, dirtyFiles, sourceDirtyHash, remediationEventId: terminal.eventId,
+    remediationEventHash: terminal.eventHash, artifact };
+}
+export function inspectFailedCheckpointTransport(repository: string, store: FileStateStore, task: TaskState,
+  receipt: FailedCheckpointUpdateReceipt, artifact: FailedCheckpointUpdateReceipt['artifact']) {
+  require(receipt?.protocol === 'failed-checkpoint-update-source-v1', 'Missing or foreign source receipt.');
+  const targetHead = headCommit(repository); const base = runGit(repository, ['rev-parse', task.baseBranch]);
+  const target = inspectBoundedWorkflowDependencyCommit(repository, targetHead);
+  const baseTransport = inspectBoundedWorkflowDependencyCommit(repository, base);
+  require([targetHead, base].every(commit => runGit(repository, ['rev-list', '--parents', '-n', '1', commit]).split(' ').length === 2),
+    'Transport commits must have exactly one parent.');
+  require(target?.parentCommitSha === receipt.sourceHead && target.packageVersion === FAILED_CHECKPOINT_TARGET
+    && baseTransport?.parentCommitSha === receipt.sourceBaseHead && baseTransport.packageVersion === FAILED_CHECKPOINT_TARGET,
+    'Exactly one dependency-only transport is required on each bound branch.');
+  const reconstructed = failedCheckpointUpdateSource(repository, store, task, artifact,
+    target.parentCommitSha, baseTransport.parentCommitSha, true);
+  require(canonicalJsonStringify(receipt) === canonicalJsonStringify(reconstructed),
+    'Source receipt no longer matches state, artifacts, product bytes, history or tarball.');
+  assertFailedCheckpointInstalled(repository, task, FAILED_CHECKPOINT_TARGET);
+  const binding: FailedCheckpointUpdateBinding = { protocol: 'failed-checkpoint-update-v1',
+    sourceHead: receipt.sourceHead, sourcePlanHash: task.planHash!, stepId: receipt.stepId,
+    sourceDirtyHash: receipt.sourceDirtyHash, targetDirtyHash: failedCheckpointDirtyHash(repository, receipt.dirtyFiles),
+    dirtyFiles: receipt.dirtyFiles, remediationEventId: receipt.remediationEventId,
+    remediationEventHash: receipt.remediationEventHash, sourceReceiptHash: hash(receipt), artifactHash: artifact.sha256 };
+  return { receipt: reconstructed, target, baseTransport: base, targetHead, binding };
+}
+
+/** Revalidate the registered byte-preserving transport when a later corrective gate reads native failure evidence.
+ * Returns no authority and never changes the original failure record or its hash. */
+export function readFailedCheckpointDirtyTransport(store: FileStateStore, repository: string, task: TaskState,
+  stepId: string, sourceHead: string, sourceDirtyHash: string) {
+  const records = (task.dependencyProvenanceRecoveries ?? []).filter(record => {
+    const binding = (record as typeof record & { failedCheckpoint?: FailedCheckpointUpdateBinding }).failedCheckpoint;
+    return binding?.stepId === stepId && binding.sourceHead === sourceHead && binding.sourceDirtyHash === sourceDirtyHash;
+  });
+  if (records.length === 0) return null;
+  require(records.length === 1, 'Registered failed checkpoint is ambiguous.');
+  const record = records[0]!;
+  const binding = (record as typeof record & { failedCheckpoint: FailedCheckpointUpdateBinding }).failedCheckpoint;
+  require(task.planHash, 'Current Plan is required to validate the historical checkpoint.');
+  readVerifiedPlanArtifact(store.taskRoot(task.projectId, task.id), binding.sourcePlanHash, task.planHash);
+  require(binding.protocol === 'failed-checkpoint-update-v1' && task.systemCommits.includes(record.commitSha)
+    && record.packageVersion === FAILED_CHECKPOINT_TARGET && record.packageName === 'codex-workflow-v2'
+    && record.parentCommitSha === sourceHead && JSON.stringify(record.files) === JSON.stringify(['package-lock.json','package.json']),
+    'Registered failed checkpoint dependency record is invalid.');
+  const inspected = inspectBoundedWorkflowDependencyCommit(repository, record.commitSha);
+  require(inspected?.parentCommitSha === sourceHead && inspected.packageVersion === FAILED_CHECKPOINT_TARGET,
+    'Registered failed checkpoint no longer identifies a dependency-only commit.');
+  require(headCommit(repository) === record.commitSha, 'Dirty checkpoint requires its exact transported HEAD.');
+  const terminal = readRemediationEvents(store, task).filter(event => event.stepId === stepId && event.failureKind === 'checks-failed').at(-1);
+  require(terminal?.eventId === binding.remediationEventId && terminal.eventHash === binding.remediationEventHash
+    && terminal.failureEvidence.completionCommit === sourceHead && terminal.failureEvidence.dirtyWorktreeHash === sourceDirtyHash,
+    'Registered failed checkpoint does not bind the terminal native failure.');
+  const dirty = changedFiles(repository).sort();
+  require(JSON.stringify(dirty) === JSON.stringify(binding.dirtyFiles)
+    && failedCheckpointDirtyHash(repository, dirty, true) === sourceDirtyHash
+    && failedCheckpointDirtyHash(repository, dirty) === binding.targetDirtyHash,
+    'Retained product bytes changed after the registered dependency transport.');
+  return { sourceHead, sourceDirtyHash, targetHead: record.commitSha, targetDirtyHash: binding.targetDirtyHash,
+    dirtyFiles: [...dirty], sourceReceiptHash: binding.sourceReceiptHash };
+}

package/src/lifecycle/corrective-replan-credential-core.ts

@@ -28,7 +28,7 @@ export interface CorrectiveReplanCredentialCorePorts {
   readonly validationEventTailSource: { readPlanValidationTail(taskId: string): unknown };
 }
 export interface CorrectiveReplanCredentialKernel {
-  issuePlanValidation(input: unknown): Result<JsonRecord>; issueHumanChallenge(input: unknown): Result<JsonRecord>; confirmHuman(input: unknown): Result<JsonRecord>; issueReceipt(input: unknown): Result<JsonRecord>;
+  issuePlanValidation(input: unknown): Result<JsonRecord>; issueHumanChallenge(input: unknown): Result<JsonRecord>; issueDelegatedChallenge(input: unknown): Result<JsonRecord>; confirmHuman(input: unknown): Result<JsonRecord>; confirmDelegated(input: unknown): Result<JsonRecord>; issueReceipt(input: unknown): Result<JsonRecord>;
   verifyReceipt(input: unknown): Verification<JsonRecord>; materializeStoredEvent(input: unknown): Result<JsonRecord>; verifyStoredEvent(input: unknown): Verification<JsonRecord>;
 }
 export interface CredentialFunctionBinding { readonly id: string; readonly version: 1; readonly kind: 'materializer' | 'verifier';
@@ -66,6 +66,8 @@ export function createCorrectiveReplanCredentialKernel(ports: CorrectiveReplanCr
   return deepFreeze({
     issuePlanValidation: (input: unknown) => totalResult(() => issuePlanValidation(issuer, input)),
     issueHumanChallenge: (input: unknown) => totalResult(() => issueHumanChallenge(issuer, input)),
+    issueDelegatedChallenge: (input: unknown) => totalResult(() => issueDelegatedChallenge(issuer, input)),
+    confirmDelegated: (input: unknown) => totalResult(() => confirmDelegated(issuer, input)),
     confirmHuman: (input: unknown) => totalResult(() => confirmHuman(issuer, input)),
     issueReceipt: (input: unknown) => totalResult(() => issueReceipt(issuer, input)),
     verifyReceipt: (input: unknown) => totalVerification(() => verifyReceipt(issuer, input)),
@@ -110,10 +112,11 @@ const issuePlanValidation = (issuer: unknown, input: unknown): Result<JsonRecord
     passed: true, findings: sortedFindings, dispositions: sortedDispositions, validatedAtMs: now, expiresAtMs: now + TTL };
   const planValidationHash = hashCanonical(validation); const values: JsonRecord = { ...clone(base), planValidationHash };
   if (!canonicalManifestValues(values, true)) return rejected('credential.binding.values-invalid', '/binding/values', 'binding');
+  const delegated = snapshot.delegatedAuthority;
   const capability = { id: 'capability.task.corrective-replan', version: 1,
-    issuer: { kind: 'human', identityHash: values.humanPrincipalIdentityHash }, source: 'human-confirmation',
+    issuer: { kind: delegated ? 'delegate' : 'human', identityHash: delegated ? values.actorIdentityHash : values.humanPrincipalIdentityHash }, source: delegated ? 'delegation-grant' : 'human-confirmation',
     scope: { transitionId: values.transitionId, taskId: values.taskId, candidatePlanHash: values.candidatePlanHash,
-      manifestSha256: correctiveReplanBindingManifest.manifestSha256 }, delegation: 'forbidden' };
+      manifestSha256: correctiveReplanBindingManifest.manifestSha256 }, delegation: delegated ?? 'forbidden' };
   const bindingBase = { schemaVersion: 1, manifestRef: { id: correctiveReplanBindingManifest.id, version: 1 },
     manifestSha256: correctiveReplanBindingManifest.manifestSha256, values, capability };
   const binding = { ...bindingBase, bindingSha256: hashCanonical(bindingBase) };
@@ -132,11 +135,12 @@ const issuePlanValidation = (issuer: unknown, input: unknown): Result<JsonRecord
   return accepted({ handle: handle as PlanValidationHandle, binding, attestation });
   } finally { if (!committed && kernel.preparations.get(preparationKey)?.generation === generation) kernel.preparations.delete(preparationKey); }
 };
-const issueHumanChallenge = (issuer: unknown, input: unknown): Result<JsonRecord> => {
+const issueHumanChallenge = (issuer: unknown, input: unknown, delegated = false): Result<JsonRecord> => {
   const kernel = kernels.get(object(issuer)); if (!kernel) return rejected('credential.provenance.invalid', '/', 'provenance');
   if (!exactKeys(input, ['planValidation'])) return rejected('credential.envelope.invalid', '/', 'schema');
   const handle = object((input as JsonRecord).planValidation); const plan = kernel.plans.get(handle);
   if (!plan) return rejected('credential.provenance.invalid', '/planValidation', 'provenance');
+  if (Boolean(plan.snapshot.delegatedAuthority) !== delegated) return rejected('credential.authority.mode-mismatch', '/planValidation', 'authority');
   if (!activePreparation(kernel, plan)) return rejected('credential.preparation.superseded', '/planValidation', 'provenance');
   if (kernel.challenged.has(handle)) return rejected('credential.provenance.invalid', '/planValidation', 'provenance');
   const now = safeTime(kernel.ports.now()); if (now === null) return rejected('credential.time.invalid', '/coreClock', 'time');
@@ -151,8 +155,11 @@ const issueHumanChallenge = (issuer: unknown, input: unknown): Result<JsonRecord
   const challenge = deepFreeze({ ...core, challengeHash: hashCanonical(core) }); const challengeHandle = opaque();
   kernel.challenges.set(challengeHandle, deepFreeze({ plan, challenge })); kernel.challenged.add(handle);
   return accepted({ handle: challengeHandle as HumanChallengeHandle,
-    delivery: { kind: 'corrective-replan-human-challenge-delivery', version: 1, challengeId, confirmationCode: code, expiresAtMs } });
+    delivery: delegated
+      ? { kind: 'corrective-replan-delegation-binding', version: 1, challengeId, expiresAtMs }
+      : { kind: 'corrective-replan-human-challenge-delivery', version: 1, challengeId, confirmationCode: code, expiresAtMs } });
 };
+const issueDelegatedChallenge = (issuer: unknown, input: unknown): Result<JsonRecord> => issueHumanChallenge(issuer, input, true);
 const confirmHuman = (issuer: unknown, input: unknown): Result<JsonRecord> => {
   const kernel = kernels.get(object(issuer)); if (!kernel) return rejected('credential.provenance.invalid', '/', 'provenance');
   if (!exactKeys(input, ['challenge', 'confirmation'])) return rejected('credential.envelope.invalid', '/', 'schema');
@@ -162,6 +169,7 @@ const confirmHuman = (issuer: unknown, input: unknown): Result<JsonRecord> => {
   if (!challenge) return rejected('credential.provenance.invalid', '/challenge', 'provenance');
   if (!activePreparation(kernel, challenge.plan)) return rejected('credential.preparation.superseded', '/challenge', 'provenance');
   if (kernel.confirmed.has(challengeHandle)) return rejected('credential.provenance.invalid', '/challenge', 'provenance');
+  if (challenge.plan.snapshot.delegatedAuthority) return rejected('credential.authority.mode-mismatch', '/challenge', 'authority');
   const candidate = confirmation as JsonRecord; const now = safeTime(kernel.ports.now());
   if (now === null) return rejected('credential.time.invalid', '/coreClock', 'time');
   const validatedAt = number(challenge.plan.attestation.validatedAtMs); const issuedAt = number(challenge.challenge.issuedAtMs);
@@ -176,6 +184,24 @@ const confirmHuman = (issuer: unknown, input: unknown): Result<JsonRecord> => {
   const handle = opaque(); kernel.confirmations.set(handle, deepFreeze({ challenge, projection })); kernel.confirmed.add(challengeHandle);
   return accepted({ handle: handle as VerifiedConfirmationHandle, projection });
 };
+// The authority comes exclusively from the Core snapshot, never from caller assertions.
+const confirmDelegated = (issuer: unknown, input: unknown): Result<JsonRecord> => {
+  const kernel = kernels.get(object(issuer));
+  if (!kernel || !exactKeys(input, ['challenge'])) return rejected('credential.provenance.invalid', '/', 'provenance');
+  const handle = object((input as JsonRecord).challenge); const challenge = kernel.challenges.get(handle);
+  if (!challenge || !challenge.plan.snapshot.delegatedAuthority || kernel.confirmed.has(handle))
+    return rejected('credential.authority.mode-mismatch', '/challenge', 'authority');
+  const freshness = receiptFreshnessIssue(kernel, challenge.plan);
+  if (freshness) return rejected(freshness.issueId, freshness.path, freshness.reasonClass);
+  const now = safeTime(kernel.ports.now());
+  if (now === null || now < number(challenge.challenge.issuedAtMs) || now >= number(challenge.challenge.expiresAtMs))
+    return rejected('credential.delegation.expired', '/challenge', 'time');
+  const projection = { challengeId: challenge.challenge.challengeId, challengeHash: challenge.challenge.challengeHash,
+    bindingSha256: challenge.plan.binding.bindingSha256, delegatedAuthority: challenge.plan.snapshot.delegatedAuthority,
+    confirmedAtMs: now };
+  const confirmation = opaque(); kernel.confirmations.set(confirmation, deepFreeze({ challenge, projection })); kernel.confirmed.add(handle);
+  return accepted({ handle: confirmation as VerifiedConfirmationHandle, projection });
+};
 const issueReceipt = (issuer: unknown, input: unknown): Result<JsonRecord> => {
   const kernel = kernels.get(object(issuer)); if (!kernel) return rejected('credential.provenance.invalid', '/', 'provenance');
   if (!exactKeys(input, ['planValidation', 'confirmation'])) return rejected('credential.envelope.invalid', '/', 'schema');
@@ -211,8 +237,10 @@ const issueReceipt = (issuer: unknown, input: unknown): Result<JsonRecord> => {
     expiresAtMs: plan.attestation.expiresAtMs };
   const base = { schemaVersion: 1, receiptId, domain: 'codex-workflow/corrective-replan-receipt/v1',
     binding: plan.binding, validation, audit: { riskAuditHash: values.riskAuditHash, riskAuditorIdentityHash: values.riskAuditorIdentityHash },
-    human: { challengeId: confirmation.projection.challengeId, challengeHash: confirmation.projection.challengeHash,
-      humanPrincipalIdentityHash: confirmation.projection.humanPrincipalIdentityHash, confirmedAtMs: confirmation.projection.confirmedAtMs },
+    ...(plan.snapshot.delegatedAuthority
+      ? { delegated: { authority: plan.snapshot.delegatedAuthority, authorizedAtMs: confirmation.projection.confirmedAtMs } }
+      : { human: { challengeId: confirmation.projection.challengeId, challengeHash: confirmation.projection.challengeHash,
+        humanPrincipalIdentityHash: confirmation.projection.humanPrincipalIdentityHash, confirmedAtMs: confirmation.projection.confirmedAtMs } }),
     supersession: { priorGrantHash: snapshotGrant.grantHash, disposition: 'superseded' },
     issuedAtMs: now, expiresAtMs };
   const withDomain = { ...base, domainHash: hashCanonical(base) }; const receipt = deepFreeze({ ...withDomain, receiptHash: hashCanonical(withDomain) });
@@ -266,11 +294,12 @@ const verifyStoredEvent = (issuer: unknown, input: unknown): Verification<JsonRe
   if (!same(candidate, recordValue.event)) return verificationRejected('credential.event.mismatch', '/candidate', 'integrity');
   return verified(recordValue.event);
 };
-const functions = [issuePlanValidation, issueHumanChallenge, confirmHuman, issueReceipt, verifyReceipt, materializeStoredEvent, verifyStoredEvent];
+const functions = [issuePlanValidation, issueHumanChallenge, confirmHuman, issueReceipt, verifyReceipt, materializeStoredEvent, verifyStoredEvent, issueDelegatedChallenge, confirmDelegated];
 const ids = ['credential-materializer.corrective-replan.plan-validation-attestation', 'credential-materializer.corrective-replan.expected-human-challenge',
   'credential-verifier.corrective-replan.human-confirmation', 'credential-materializer.corrective-replan.receipt',
   'credential-verifier.corrective-replan.receipt', 'credential-materializer.corrective-replan.stored-plan-validation-event',
-  'credential-verifier.corrective-replan.stored-plan-validation-event'] as const;
+  'credential-verifier.corrective-replan.stored-plan-validation-event',
+  'credential-materializer.corrective-replan.delegated-binding', 'credential-verifier.corrective-replan.delegated-authorization'] as const;
 export const correctiveReplanCredentialFunctionBindings: readonly CredentialFunctionBinding[] = deepFreeze(ids.map((id, index) => ({ id, version: 1,
   kind: id.includes('materializer') ? 'materializer' as const : 'verifier' as const, implementationId: `implementation.${id}` as const,
   implementationVersion: 1, wiring: 'invoked', callable: functions[index]! })));
@@ -289,7 +318,7 @@ function receiptFreshnessIssue(kernel: KernelRecord, plan: PlanRecord): Issue |
   return loaded.snapshotBindingHash === plan.snapshotBindingHash ? null : issue('credential.receipt.snapshot-stale', '/snapshotBindingHash', 'binding');
 }
 function snapshotIssue(snapshot: JsonRecord, taskId: unknown): Issue | null {
-  if (!exactKeys(snapshot, ['snapshotVersion', 'bindingManifest', 'worktree', 'baseValues', 'validationExpectation', 'priorPlanAuthorization']) || snapshot.snapshotVersion !== 2)
+  if (!exactKeys(snapshot, ['snapshotVersion', 'bindingManifest', 'worktree', 'baseValues', 'validationExpectation', 'priorPlanAuthorization', ...(snapshot.delegatedAuthority ? ['delegatedAuthority'] : [])]) || snapshot.snapshotVersion !== 2)
     return issue('credential.snapshot.invalid', '/snapshot', 'schema');
   const base = record(snapshot.baseValues); const expected = record(snapshot.validationExpectation);
   if (base.taskId !== taskId || base.transitionId !== 'task.plan.corrective-replan' || base.capabilityId !== 'capability.task.corrective-replan'

package/src/lifecycle/corrective-replan.ts

@@ -151,7 +151,7 @@ const decisionGuardMetadata = guardMetadata(
 );
 const attemptGuardMetadata = guardMetadata(
   'task.corrective-replan.attempt-threshold',
-  'The decision is bound either to the bounded first-failure Plan-integrity route or to the ordinary two-failure threshold.',
+  'The decision binds a proven first-failure Plan-integrity or rebound planning-obstruction route, or the ordinary two-failure threshold.',
   'availability',
   'observation',
   ['field.corrective-decision-triggering-attempt-count', 'field.remediation-attempt-count'],
@@ -193,7 +193,7 @@ const planValidationPassedGuardMetadata = guardMetadata(
   'execution', 'candidate', ['field.plan-validation-passed'], ['input.corrective-plan-validation'], 'candidate-blocker',
 );
 const receiptValidGuardMetadata = guardMetadata(
-  'task.corrective-replan.receipt-valid', 'The Human-confirmed receipt matches every current execution binding.',
+  'task.corrective-replan.receipt-valid', 'The Human-confirmed or explicitly delegated receipt matches every current execution binding.',
   'execution', 'authority', ['field.receipt-valid'], ['input.corrective-execution-receipt'], 'authority-blocker',
 );
 const riskAuditPassedGuardMetadata = guardMetadata(
@@ -264,12 +264,16 @@ const guards: readonly TransitionGuard<CorrectiveReplanSnapshot, CorrectiveRepla
         && decision?.triggeringAttemptCount === 2
         && decision.recoveryBasis === 'plan-integrity'
         && decision.planIntegrityEvidence !== undefined;
-      const passed = ordinaryThreshold || boundedPlanIntegrity;
+      const boundedPlanningObstruction = snapshot.remediationAttemptCount === 1
+        && decision?.triggeringAttemptCount === 2
+        && decision.recoveryBasis === 'planning-obstruction'
+        && decision.planningObstructionEvidence !== undefined;
+      const passed = ordinaryThreshold || boundedPlanIntegrity || boundedPlanningObstruction;
       return verdict(
         attemptGuardMetadata,
         passed,
         'ATTEMPT_BINDING_INVALID',
-        'Corrective replan requires either one bounded Plan-integrity failure or two ordinary failed attempts, with an exact next-ordinal decision.',
+        'Corrective replan requires one bounded Plan-integrity/planning-obstruction failure or two ordinary failed attempts, with an exact next-ordinal decision.',
       );
     },
   },
@@ -347,18 +351,18 @@ const metadata: TransitionDefinitionMetadata = {
     eligibleRoles: ['delivery-coordinator', 'technical-planner'],
     actor: {
       identity: v1('identity.actor'),
-      principalBasis: v1('principal-basis.human-confirmation'),
+      principalBasis: v1('principal-basis.bound-corrective-authority'),
       required: true,
     },
     principal: {
       identity: v1('identity.human-principal'),
-      principalBasis: v1('principal-basis.human-confirmation'),
+      principalBasis: v1('principal-basis.bound-corrective-authority'),
       issuer: v1('identity.human-principal'),
-      allowedKinds: ['human'],
+      allowedKinds: ['human', 'delegation-grant'],
     },
     capabilities: [{ capability: v1('capability.task.corrective-replan'), source: 'credential', required: true }],
     credentials: [v1('credential-policy.corrective-execution-receipt')],
-    delegation: v1('delegation.forbidden'),
+    delegation: v1('delegation.corrective-execution-exact'),
     ownership: v1('ownership.corrective-replan-clear'),
     executionBoundaries: ['human', 'coordinator', 'workflow-core'],
     separationOfDuty: [

package/src/lifecycle/semantic-registry.ts

@@ -232,15 +232,16 @@ export const transitionSemanticRegistry: SemanticRegistry = deepFreeze(validateS
   identities,
   identityComparators,
   principalBases: [
+    { id: 'principal-basis.bound-corrective-authority', version: 1, description: 'Core verifies an exact Human confirmation or a current task.execution_authorize grant for unchanged corrective scope.', principalKind: 'workflow-core', authoritySource: 'workflow-core-derived' },
     { id: 'principal-basis.human-confirmation', version: 1, description: 'Exact Human confirmation authority basis.', principalKind: 'human', authoritySource: 'human-confirmation' },
   ],
   capabilities: [{
-    id: 'capability.task.corrective-replan', version: 1, description: 'Human-issued capability for one exact replacement candidate.',
+    id: 'capability.task.corrective-replan', version: 1, description: 'Human-confirmed or exact execution-grant capability for one replacement candidate.',
     transitionId: 'task.plan.corrective-replan', issuer: v1('identity.human-principal'),
     scope: v1('projection.corrective-replan.execution-receipt'), exactCandidateBound: true,
   }],
   credentialPolicies: [{
-    id: 'credential-policy.corrective-execution-receipt', version: 1, description: 'Exact state-bound Human-confirmed receipt.',
+    id: 'credential-policy.corrective-execution-receipt', version: 1, description: 'Exact state-bound receipt with distinct Human or delegated authority evidence.',
     credentialKind: 'execution-receipt', schema: v1('schema.corrective-replan-receipt'),
     verifier: v1('credential-verifier.corrective-replan.receipt'), issuer: v1('identity.human-principal'),
     presentation: { mode: 'explicit-input', input: v1('input.corrective-execution-receipt') },
@@ -251,6 +252,7 @@ export const transitionSemanticRegistry: SemanticRegistry = deepFreeze(validateS
   credentialVerifiers: [{ id: 'credential-verifier.corrective-replan.receipt', version: 1, description: 'The invoked Core credential kernel recomputes receipt and all current bindings.', verifierKind: 'state-bound-sha256' }],
   clocks: [{ id: 'clock.workflow-core-utc', version: 1, description: 'Workflow Core injected UTC clock.', clockKind: 'workflow-core-utc' }],
   delegationPolicies: [
+    { id: 'delegation.corrective-execution-exact', version: 1, description: 'An explicit live task.execution_authorize grant may authorize a same-scope corrective candidate; independent validation and unchanged acceptance remain mandatory.', mode: 'allowed-exact', scopeBound: true, expiryRequired: true, redelegationAllowed: false },
     { id: 'delegation.forbidden', version: 1, description: 'Delegation is forbidden.', mode: 'forbidden', scopeBound: false, expiryRequired: false, redelegationAllowed: false },
   ],
   ownershipPolicies: [

package/src/observed-routes.ts

@@ -114,6 +114,9 @@ const OBSERVED_ROUTE_INVENTORY: readonly ObservedRouteDefinition[] = [
       diagnostic('update navigation-source-preflight'),
       diagnostic('update navigation-transport-preflight'),
       executable('update navigation-recover', 'recoverNavigationUpdate'),
+      diagnostic('update failed-checkpoint-source-preflight'),
+      diagnostic('update failed-checkpoint-transport-preflight'),
+      executable('update failed-checkpoint-recover', 'recoverFailedCheckpointUpdate'),
       executable('task historical-step-provenance-recover', 'recoverHistoricalStepProvenance'),
       executable('update historical-step-dependency-recover', 'recoverHistoricalStepDependencyProvenance'),
       executable('update dependency-provenance-recover', 'recoverDependencyProvenance'),
@@ -134,6 +137,7 @@ const OBSERVED_ROUTE_INVENTORY: readonly ObservedRouteDefinition[] = [
       executable('task corrective-decision', 'recordStepCorrectiveDecision'),
       executable('task corrective-yield', 'executeCorrectiveYield'),
       executable('task corrective-replan-prepare', 'prepareCorrectiveReplan'),
+      executable('task corrective-replan-authorize', 'authorizeDelegatedCorrectiveReplan'),
     ],
     successorWitness: {
       kind: 'reachable', routeIds: ['observed.task-lifecycle'],
@@ -231,6 +235,7 @@ const OBSERVED_ROUTE_INVENTORY: readonly ObservedRouteDefinition[] = [
       executable('milestone plan-set', 'setMilestonePlan'),
       executable('milestone scope-change-prepare', 'prepareMilestoneScopeChange'),
       executable('milestone autonomy-evolve', 'evolveMilestonePlanAutonomously'),
+      executable('milestone autonomy-bind', 'bindMilestoneAutonomy'),
       executable('milestone authorize', 'authorizeMilestone'),
       executable('milestone validate', 'validateMilestone'),
     ],

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

@@ -638,6 +638,7 @@ function materializeExecutionEvent(
     planRiskAuditEventHash: riskEvent.eventHash,
     actorIdentityHash: values.actorIdentityHash,
     humanPrincipalIdentityHash: values.humanPrincipalIdentityHash,
+    ...(receipt.delegated ? { delegatedAuthority: get(receipt, '/delegated/authority') } : {}),
     priorGrantHash: get(receipt, '/supersession/priorGrantHash'),
     taskStateSha256,
     planBytesSha256,