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

package/schemas/adoption-posture-event.schema.json

@@ -25,6 +25,17 @@
     "eventHash"
   ],
   "properties": {
+    "delegatedAuthorization": {
+      "type": "object", "additionalProperties": false,
+      "required": ["grantId", "policyHash", "principal", "delegate", "transition"],
+      "properties": {
+        "grantId": { "type": "string", "pattern": "^DGR-[0-9A-HJKMNP-TV-Z]{26}$" },
+        "policyHash": { "$ref": "#/$defs/hash64" },
+        "principal": { "type": "string", "minLength": 1 },
+        "delegate": { "type": "string", "pattern": "^agent:.+" },
+        "transition": { "const": "project.adopt" }
+      }
+    },
     "eventId": { "type": "string", "minLength": 1 },
     "projectId": { "type": "string", "pattern": "^[a-f0-9]{24}$" },
     "eventType": { "enum": ["project-registration", "adoption-apply"] },

package/schemas/authorization-event.schema.json

@@ -52,7 +52,7 @@
         "delegate": { "type": "string", "minLength": 1 },
         "transition": {
           "enum": [
-            "project_memory.approve",
+            "project.adopt", "project_memory.approve",
             "task.execution_authorize", "task.final_accept",
             "milestone.execution_authorize", "milestone.final_accept"
           ]

package/schemas/corrective-decision-event.schema.json

@@ -38,8 +38,9 @@
       "items": { "type": "string", "minLength": 1 }
     },
     "planHash": { "$ref": "#/$defs/hash64" },
-    "recoveryBasis": { "const": "plan-integrity" },
+    "recoveryBasis": { "enum": ["plan-integrity", "planning-obstruction"] },
     "planIntegrityEvidence": { "$ref": "#/$defs/planIntegrityEvidence" },
+    "planningObstructionEvidence": { "$ref": "#/$defs/planningObstructionEvidence" },
     "previousEventHash": { "$ref": "#/$defs/nullableHash64" },
     "recordedAt": { "type": "string", "format": "date-time" },
     "eventHash": { "$ref": "#/$defs/hash64" }
@@ -48,17 +49,22 @@
     {
       "if": { "properties": { "triggeringAttemptCount": { "const": 2 } }, "required": ["triggeringAttemptCount"] },
       "then": {
-        "required": ["recoveryBasis", "planIntegrityEvidence"],
+        "required": ["recoveryBasis"],
         "properties": { "decision": { "enum": ["continue-fix", "replan-required"] } }
       }
     },
     {
-      "if": { "required": ["recoveryBasis"] },
+      "if": { "properties": { "recoveryBasis": { "const": "plan-integrity" } }, "required": ["recoveryBasis"] },
       "then": {
         "required": ["planIntegrityEvidence"]
       },
       "else": { "not": { "required": ["planIntegrityEvidence"] } }
     },
+    {
+      "if": { "properties": { "recoveryBasis": { "const": "planning-obstruction" } }, "required": ["recoveryBasis"] },
+      "then": { "required": ["planningObstructionEvidence"], "properties": { "triggeringAttemptCount": { "const": 2 }, "decision": { "const": "replan-required" } } },
+      "else": { "not": { "required": ["planningObstructionEvidence"] } }
+    },
     {
       "if": {
         "properties": {
@@ -83,6 +89,20 @@
     }
   ],
   "$defs": {
+    "planningObstructionEvidence": {
+      "type": "object", "additionalProperties": false,
+      "required": ["kind", "taskRevision", "sourcePlanHash", "baselinePlanHash", "baselineAuditEventId", "baselineAuditEventHash", "obstructionAuditEventId", "obstructionAuditEventHash", "priorAuthorizationHash", "remediationEventId", "remediationEventHash", "knowledgeRebindCount", "knowledgeRebindHash"],
+      "properties": {
+        "kind": { "const": "first-failure-rebound-planning-obstruction" },
+        "taskRevision": { "type": "integer", "minimum": 1 },
+        "sourcePlanHash": { "$ref": "#/$defs/hash64" }, "baselinePlanHash": { "$ref": "#/$defs/hash64" },
+        "baselineAuditEventId": { "type": "string", "minLength": 1 }, "baselineAuditEventHash": { "$ref": "#/$defs/hash64" },
+        "obstructionAuditEventId": { "type": "string", "minLength": 1 }, "obstructionAuditEventHash": { "$ref": "#/$defs/hash64" },
+        "priorAuthorizationHash": { "$ref": "#/$defs/hash64" },
+        "remediationEventId": { "type": "string", "minLength": 1 }, "remediationEventHash": { "$ref": "#/$defs/hash64" },
+        "knowledgeRebindCount": { "type": "integer", "minimum": 1 }, "knowledgeRebindHash": { "$ref": "#/$defs/hash64" }
+      }
+    },
     "taskId": { "type": "string", "pattern": "^TASK-[0-9A-HJKMNP-TV-Z]{26}$" },
     "stepId": { "type": "string", "pattern": "^STEP-[0-9]{3}(?:-[A-Z0-9-]+)?$" },
     "hash64": { "type": "string", "pattern": "^[a-f0-9]{64}$" },

package/schemas/corrective-replan-credentials.private.schema.json

@@ -10,6 +10,7 @@
       "required": ["id", "version"],
       "properties": { "id": { "$ref": "#/$defs/id" }, "version": { "const": 1 } }
     },
+    "delegatedAuthority": {"type": "object", "additionalProperties": false, "required": ["grantId", "policyHash", "principal", "delegate", "transition", "expiresAt"], "properties": {"grantId": {"$ref": "#/$defs/id"}, "policyHash": {"$ref": "#/$defs/hash"}, "principal": {"$ref": "#/$defs/id"}, "delegate": {"$ref": "#/$defs/id"}, "transition": {"const": "task.execution_authorize"}, "expiresAt": {"type": "string", "format": "date-time"}}},
     "bindingValues": {
       "type": "object", "additionalProperties": false,
       "required": ["transitionId", "runtimeFingerprint", "catalogHash", "lifecycleEpoch", "taskId", "revision", "currentPlanHash", "briefHash", "knowledgeRevision", "knowledgeHash", "targetKnowledgeRevision", "targetKnowledgeHash", "gitHead", "guardedStepId", "correctiveDecisionEventId", "correctiveDecisionHash", "attemptCount", "remediationTailHash", "candidatePlanHash", "candidateStepSetHash", "planAuthorIdentityHash", "planValidationHash", "planValidatorIdentityHash", "riskAuditHash", "riskAuditorIdentityHash", "actorIdentityHash", "actorRole", "humanPrincipalIdentityHash", "capabilityId", "capabilityVersion"],
@@ -23,7 +24,7 @@
         "targetKnowledgeRevision": { "type": "integer", "minimum": 0, "maximum": 9007199254740991 },
         "targetKnowledgeHash": { "$ref": "#/$defs/hash" }, "gitHead": { "type": "string", "pattern": "^(?:[a-f0-9]{40}|[a-f0-9]{64})$" },
         "guardedStepId": { "$ref": "#/$defs/id" }, "correctiveDecisionEventId": { "$ref": "#/$defs/id" },
-        "correctiveDecisionHash": { "$ref": "#/$defs/hash" }, "attemptCount": { "type": "integer", "minimum": 2, "maximum": 9007199254740991 },
+        "correctiveDecisionHash": { "$ref": "#/$defs/hash" }, "attemptCount": { "type": "integer", "minimum": 1, "maximum": 9007199254740991 },
         "remediationTailHash": { "$ref": "#/$defs/hash" }, "candidatePlanHash": { "$ref": "#/$defs/hash" },
         "candidateStepSetHash": { "$ref": "#/$defs/hash" }, "planAuthorIdentityHash": { "$ref": "#/$defs/hash" },
         "planValidationHash": { "$ref": "#/$defs/hash" }, "planValidatorIdentityHash": { "$ref": "#/$defs/hash" },
@@ -45,10 +46,10 @@
           "required": ["id", "version", "issuer", "source", "scope", "delegation"],
           "properties": {
             "id": { "const": "capability.task.corrective-replan" }, "version": { "const": 1 },
-            "issuer": { "type": "object", "additionalProperties": false, "required": ["kind", "identityHash"], "properties": { "kind": { "const": "human" }, "identityHash": { "$ref": "#/$defs/hash" } } },
-            "source": { "const": "human-confirmation" },
+            "issuer": { "type": "object", "additionalProperties": false, "required": ["kind", "identityHash"], "properties": { "kind": { "enum": ["human", "delegate"] }, "identityHash": { "$ref": "#/$defs/hash" } } },
+            "source": { "enum": ["human-confirmation", "delegation-grant"] },
             "scope": { "type": "object", "additionalProperties": false, "required": ["transitionId", "taskId", "candidatePlanHash", "manifestSha256"], "properties": { "transitionId": { "const": "task.plan.corrective-replan" }, "taskId": { "$ref": "#/$defs/id" }, "candidatePlanHash": { "$ref": "#/$defs/hash" }, "manifestSha256": { "$ref": "#/$defs/hash" } } },
-            "delegation": { "const": "forbidden" }
+            "delegation": { "oneOf": [{ "const": "forbidden" }, { "$ref": "#/$defs/delegatedAuthority" }] }
           }
         },
         "bindingSha256": { "$ref": "#/$defs/hash" }
@@ -82,10 +83,12 @@
     "receiptValidation": { "type": "object", "additionalProperties": false, "required": ["attestationId", "attestationHash", "planValidationHash", "snapshotBindingHash", "planAuthorIdentityHash", "planValidatorIdentityHash", "findingsHash", "dispositionsHash", "validatedAtMs", "expiresAtMs"], "properties": { "attestationId": { "$ref": "#/$defs/id" }, "attestationHash": { "$ref": "#/$defs/hash" }, "planValidationHash": { "$ref": "#/$defs/hash" }, "snapshotBindingHash": { "$ref": "#/$defs/hash" }, "planAuthorIdentityHash": { "$ref": "#/$defs/hash" }, "planValidatorIdentityHash": { "$ref": "#/$defs/hash" }, "findingsHash": { "$ref": "#/$defs/hash" }, "dispositionsHash": { "$ref": "#/$defs/hash" }, "validatedAtMs": { "$ref": "#/$defs/time" }, "expiresAtMs": { "$ref": "#/$defs/time" } } },
     "correctiveReplanReceiptV1": {
       "type": "object", "additionalProperties": false,
-      "required": ["schemaVersion", "receiptId", "domain", "binding", "validation", "audit", "human", "supersession", "issuedAtMs", "expiresAtMs", "domainHash", "receiptHash"],
+      "oneOf": [{ "required": ["human"], "properties": { "human": {}, "delegated": false } }, { "required": ["delegated"], "properties": { "delegated": {}, "human": false } }],
+      "required": ["schemaVersion", "receiptId", "domain", "binding", "validation", "audit", "supersession", "issuedAtMs", "expiresAtMs", "domainHash", "receiptHash"],
       "properties": {
         "schemaVersion": { "const": 1 }, "receiptId": { "$ref": "#/$defs/id" }, "domain": { "const": "codex-workflow/corrective-replan-receipt/v1" }, "binding": { "$ref": "#/$defs/correctiveReplanBindingV1" }, "validation": { "$ref": "#/$defs/receiptValidation" },
         "audit": { "type": "object", "additionalProperties": false, "required": ["riskAuditHash", "riskAuditorIdentityHash"], "properties": { "riskAuditHash": { "$ref": "#/$defs/hash" }, "riskAuditorIdentityHash": { "$ref": "#/$defs/hash" } } },
+        "delegated": { "type": "object", "additionalProperties": false, "required": ["authority", "authorizedAtMs"], "properties": { "authority": { "$ref": "#/$defs/delegatedAuthority" }, "authorizedAtMs": { "$ref": "#/$defs/time" } } },
         "human": { "type": "object", "additionalProperties": false, "required": ["challengeId", "challengeHash", "humanPrincipalIdentityHash", "confirmedAtMs"], "properties": { "challengeId": { "$ref": "#/$defs/id" }, "challengeHash": { "$ref": "#/$defs/hash" }, "humanPrincipalIdentityHash": { "$ref": "#/$defs/hash" }, "confirmedAtMs": { "$ref": "#/$defs/time" } } },
         "supersession": { "type": "object", "additionalProperties": false, "required": ["priorGrantHash", "disposition"], "properties": { "priorGrantHash": { "$ref": "#/$defs/hash" }, "disposition": { "const": "superseded" } } },
         "issuedAtMs": { "$ref": "#/$defs/time" }, "expiresAtMs": { "$ref": "#/$defs/time" }, "domainHash": { "$ref": "#/$defs/hash" }, "receiptHash": { "$ref": "#/$defs/hash" }

package/schemas/corrective-replan-execution-event.private.schema.json

@@ -42,6 +42,15 @@
     "planRiskAuditEventHash": { "$ref": "#/$defs/hash" },
     "actorIdentityHash": { "$ref": "#/$defs/hash" },
     "humanPrincipalIdentityHash": { "$ref": "#/$defs/hash" },
+    "delegatedAuthority": {
+      "type": "object", "additionalProperties": false,
+      "required": ["grantId", "policyHash", "principal", "delegate", "transition", "expiresAt"],
+      "properties": {
+        "grantId": { "type": "string", "minLength": 1 }, "policyHash": { "$ref": "#/$defs/hash" },
+        "principal": { "type": "string", "minLength": 1 }, "delegate": { "type": "string", "minLength": 1 },
+        "transition": { "const": "task.execution_authorize" }, "expiresAt": { "type": "string", "format": "date-time" }
+      }
+    },
     "priorGrantHash": { "$ref": "#/$defs/hash" },
     "taskStateSha256": { "$ref": "#/$defs/hash" },
     "planBytesSha256": { "$ref": "#/$defs/hash" },

package/schemas/corrective-replan-public.schema.json

@@ -10,6 +10,7 @@
       "additionalProperties": false,
       "required": ["plan", "validation", "riskAudit", "authority"],
       "properties": {
+        "delegation": { "type": "object", "additionalProperties": false, "required": ["grantId", "actor"], "properties": { "grantId": { "$ref": "#/$defs/id" }, "actor": { "$ref": "#/$defs/id" } } },
         "plan": { "$ref": "https://codex-workflow.local/schemas/transition-payloads.schema.json#/$defs/taskPlanInput" },
         "validation": {
           "type": "object",
@@ -69,7 +70,7 @@
       "additionalProperties": false,
       "required": ["kind", "version", "taskId", "preparedAtMs", "expiresAtMs", "candidatePlanHash", "bindingSha256", "attestationId", "attestationHash", "challengeId", "runtimeFingerprint", "catalogHash", "lifecycleEpoch", "preparationSha256"],
       "properties": {
-        "kind": { "const": "corrective-replan-human-gate" },
+        "kind": { "enum": ["corrective-replan-human-gate", "corrective-replan-delegated-binding"] },
         "version": { "const": 1 },
         "taskId": { "$ref": "#/$defs/id" },
         "preparedAtMs": { "$ref": "#/$defs/time" },

package/schemas/delegation-grant.schema.json

@@ -54,7 +54,7 @@
       "uniqueItems": true,
       "items": {
         "enum": [
-          "project_memory.approve",
+          "project.adopt", "project_memory.approve",
           "task.execution_authorize", "task.final_accept",
           "milestone.execution_authorize", "milestone.final_accept"
         ]

package/schemas/task.schema.json

@@ -233,6 +233,24 @@
             },
             "additionalProperties": false
           },
+          "failedCheckpoint": {
+            "type": "object",
+            "required": ["protocol", "sourceHead", "sourcePlanHash", "stepId", "sourceDirtyHash", "targetDirtyHash", "dirtyFiles", "remediationEventId", "remediationEventHash", "sourceReceiptHash", "artifactHash"],
+            "properties": {
+              "protocol": { "const": "failed-checkpoint-update-v1" },
+              "sourceHead": { "type": "string", "pattern": "^[a-f0-9]{40}$" },
+              "sourcePlanHash": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+              "stepId": { "type": "string", "pattern": "^STEP-[A-Z0-9][A-Z0-9-]{2,63}$" },
+              "sourceDirtyHash": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+              "targetDirtyHash": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+              "dirtyFiles": { "type": "array", "minItems": 1, "uniqueItems": true, "items": { "type": "string", "minLength": 1 } },
+              "remediationEventId": { "type": "string", "pattern": "^RME-[0-9A-HJKMNP-TV-Z]{26}$" },
+              "remediationEventHash": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+              "sourceReceiptHash": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+              "artifactHash": { "type": "string", "pattern": "^[a-f0-9]{64}$" }
+            },
+            "additionalProperties": false
+          },
           "rootCauseReplan": {
             "type": "object",
             "required": [

package/schemas/transition-definition.schema.json

@@ -296,6 +296,7 @@
           "credential-verifier.corrective-replan.receipt@1"
         ],
         "delegationPolicies": [
+          "delegation.corrective-execution-exact@1",
           "delegation.forbidden@1"
         ],
         "effectAdapters": [
@@ -360,6 +361,7 @@
           "ownership.corrective-replan-clear@1"
         ],
         "principalBases": [
+          "principal-basis.bound-corrective-authority@1",
           "principal-basis.human-confirmation@1"
         ],
         "projections": [
@@ -763,6 +765,7 @@
       "properties": {
         "id": {
           "enum": [
+            "principal-basis.bound-corrective-authority",
             "principal-basis.human-confirmation"
           ]
         },
@@ -835,6 +838,7 @@
       "properties": {
         "id": {
           "enum": [
+            "delegation.corrective-execution-exact",
             "delegation.forbidden"
           ]
         },

package/src/alpha6/adoption.ts

@@ -1,5 +1,6 @@
 import type {
   AdoptionPostureEvent,
+  DelegatedAuthorizationEvidence,
   AdoptionRepositoryIdentity,
   AdoptionTaskBaseline,
   AdoptionTaskStepSnapshot,
@@ -8,6 +9,7 @@ import type {
   TaskStatus,
 } from '../contracts.js';
 import { PROTOCOL_VERSION, STATE_SCHEMA_VERSION } from '../contracts.js';
+import { assertDelegationCanAuthorize } from '../delegation.js';
 import { WorkflowError } from '../errors.js';
 import type { RepositoryIdentity } from '../repository.js';
 import type { FileStateStore } from '../state/store.js';
@@ -243,8 +245,15 @@ export function applyAdoptionPosture(
   input: AdoptionPreparationInput,
   actor: string,
   confirmationCode: string,
+  grantId: string | null = null,
 ): AdoptionPostureEvent {
-  const normalizedActor = normalizeHumanActor(actor, 'Adoption apply actor');
+  let delegatedAuthorization: DelegatedAuthorizationEvidence | undefined;
+  if (grantId) {
+    const grant = store.readDelegation(input.projectId, grantId);
+    delegatedAuthorization = assertDelegationCanAuthorize(grant, 'project.adopt', actor,
+      { kind: 'project', id: input.projectId }, input.now);
+  }
+  const normalizedActor = delegatedAuthorization ? actor.trim() : normalizeHumanActor(actor, 'Adoption apply actor');
   const currentPosture = readCurrentAdoptionPosture(store, input.projectId);
   if (currentPosture) {
     throw new WorkflowError('TRANSITION_BLOCKED', `Project ${input.projectId} already has an adoption posture.`, {
@@ -279,6 +288,7 @@ export function applyAdoptionPosture(
     adoptionBoundaryAt: input.now.toISOString(),
     recordedAt: input.now.toISOString(),
     actor: normalizedActor,
+    ...(delegatedAuthorization ? { delegatedAuthorization } : {}),
     confirmationCodeBindingHash: prepared.confirmationCodeBindingHash,
   };
   event.eventHash = computeSidecarEventHash(event);
@@ -403,6 +413,7 @@ function validateAdoptionPostureEvent(
     'projectId',
     'eventType',
     'actor',
+    'delegatedAuthorization',
     'packageVersion',
     'protocolVersion',
     'stateSchemaVersion',
@@ -504,7 +515,7 @@ function validateAdoptionPostureEvent(
   validateTerminalTasks(event, file, line);
   validateActiveTasks(event, file, line);
   if (event.eventType === 'project-registration') {
-    if (event.actor !== null || event.confirmationCodeBindingHash !== null) {
+    if (event.actor !== null || event.confirmationCodeBindingHash !== null || event.delegatedAuthorization !== undefined) {
       throw new WorkflowError('STATE_CORRUPT', 'Project registration adoption posture must not record actor or confirmation binding.', {
         file,
         line,
@@ -518,11 +529,23 @@ function validateAdoptionPostureEvent(
       eventId: event.eventId,
     });
   } else {
-    validateStoredHumanActor(event.actor, 'Adoption apply actor', {
-      file,
-      line,
-      eventId: event.eventId,
-    });
+    if (event.delegatedAuthorization !== undefined) {
+      const evidence = event.delegatedAuthorization;
+      assertPlainObject(evidence, 'Adoption delegated authority', file, line);
+      assertExactKeys(evidence as unknown as Record<string, unknown>,
+        ['grantId', 'transition', 'principal', 'delegate', 'policyHash'],
+        'Adoption delegated authority contains unexpected fields.', file, line);
+      if (['grantId', 'transition', 'principal', 'delegate', 'policyHash'].some((key) =>
+        typeof (evidence as unknown as Record<string, unknown>)[key] !== 'string')) {
+        throw new WorkflowError('STATE_CORRUPT', 'Adoption delegated authority fields must be strings.', { file, line });
+      }
+      if (!event.actor.startsWith('agent:') || evidence.delegate !== event.actor
+        || evidence.transition !== 'project.adopt' || !/^DGR-[0-9A-HJKMNP-TV-Z]{26}$/.test(evidence.grantId)
+        || !/^[a-f0-9]{64}$/.test(evidence.policyHash) || !evidence.principal || evidence.principal.startsWith('agent:'))
+        throw new WorkflowError('STATE_CORRUPT', 'Adoption delegated authority is invalid.');
+    } else {
+      validateStoredHumanActor(event.actor, 'Adoption apply actor', { file, line, eventId: event.eventId });
+    }
     if (event.confirmationCodeBindingHash === null) {
       throw new WorkflowError('STATE_CORRUPT', 'Adoption apply posture must record confirmationCodeBindingHash.', {
         file,

package/src/alpha6/corrective-decision-boundary.ts

@@ -7,6 +7,8 @@ import { changedFiles, currentBranch, headCommit } from '../repository.js';
 import type { FileStateStore } from '../state/store.js';
 import { hashDirtyWorktree } from './downstream-proof.js';
 import { effectiveStepAllowedWrites, readRemediationEvents } from './remediation.js';
+import { readTaskC1Posture } from './handoff.js';
+import { readFailedCheckpointDirtyTransport } from '../failed-checkpoint-update.js';
 
 /** Checkout eligibility only: never an audit, writer credential, or permission to widen scope. */
 export function correctiveDecisionCheckoutEligible(
@@ -18,13 +20,17 @@ export function correctiveDecisionCheckoutEligible(
   validateTaskHistory(repository, task);
   const dirty = changedFiles(repository).sort();
   if (dirty.length === 0) return true;
-  if (task.workspaceOwner !== 'local' || task.steps.some(step => step.status === 'in_progress')) return false;
+  if (!['local', 'external'].includes(task.workspaceOwner ?? '') || task.steps.some(step => step.status === 'in_progress')) return false;
+  if (task.workspaceOwner === 'external' && readTaskC1Posture(store, task).state !== 'claimed') return false;
   const step = task.steps.find(candidate => candidate.id === stepId);
   const pause = step?.failurePause;
   if (step?.status !== 'failed' || !pause) return false;
   const terminal = readRemediationEvents(store, task).filter(event => event.stepId === stepId).at(-1);
+  const transport = terminal?.failureEvidence.dirtyWorktreeHash
+    ? readFailedCheckpointDirtyTransport(store, repository, task, stepId,
+      terminal.failureEvidence.completionCommit, terminal.failureEvidence.dirtyWorktreeHash) : null;
   if (!terminal || terminal.failureKind !== 'checks-failed'
-    || terminal.failureEvidence.completionCommit !== headCommit(repository)
+    || (transport?.targetHead ?? terminal.failureEvidence.completionCommit) !== headCommit(repository)
     || terminal.failureEvidence.checksHash !== pause.checksHash
     || terminal.failureEvidence.dirtyWorktreeHash !== pause.dirtyWorktreeHash
     || JSON.stringify(dirty) !== JSON.stringify([...pause.dirtyFiles].sort())) return false;
@@ -35,5 +41,5 @@ export function correctiveDecisionCheckoutEligible(
     try { if (!lstatSync(path.join(repository, file)).isFile()) return false; }
     catch (error) { if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error; }
   }
-  return hashDirtyWorktree(repository, dirty) === pause.dirtyWorktreeHash;
+  return hashDirtyWorktree(repository, dirty) === (transport?.targetDirtyHash ?? pause.dirtyWorktreeHash);
 }

package/src/alpha6/remediation.ts

@@ -38,6 +38,7 @@ import {
 import { correctiveReplanBoundaryMatchesStep, readCompletedCorrectiveReplanHistory } from '../state/corrective-replan-executor.js';
 import { semanticBoundaryHash, validLiteralTestInvocationEvidence } from './component-owner.js';
 import { reviewerCauseFingerprint } from './remediation-cause.js';
+import { readFailedStepPlanningRecovery } from './failed-step-planning-recovery.js';
 
 export const REMEDIATION_EVENTS_SIDECAR = 'remediation-events.jsonl';
 export const CORRECTIVE_DECISIONS_SIDECAR = 'corrective-decisions.jsonl';
@@ -419,6 +420,27 @@ function findCorrectiveRecoveryDecisionIdForFailure(
   return recoveries[0]?.correctiveDecisionEventId ?? null;
 }
 
+/** A first failed execution plus immutable rebound obstruction is planning evidence, not permission to retry. */
+export function firstFailurePlanningObstructionEvidence(
+  store: FileStateStore,
+  task: TaskState,
+  stepId: string,
+): NonNullable<CorrectiveDecisionEvent['planningObstructionEvidence']> | null {
+  const failures = readRemediationEvents(store, task).filter(event => event.stepId === stepId);
+  if (failures.length !== 1 || task.steps.find(step => step.id === stepId)?.status !== 'failed') return null;
+  const recovery = readFailedStepPlanningRecovery(store, task);
+  if (!recovery || !recovery.current.reviewRequiredStepIds.includes(stepId)) return null;
+  return {
+    kind: 'first-failure-rebound-planning-obstruction', taskRevision: task.revision,
+    sourcePlanHash: task.planHash!, baselinePlanHash: recovery.baseline.planHash,
+    baselineAuditEventId: recovery.baseline.eventId, baselineAuditEventHash: recovery.baseline.eventHash,
+    obstructionAuditEventId: recovery.current.audit.eventId, obstructionAuditEventHash: recovery.current.audit.eventHash,
+    priorAuthorizationHash: hashCanonical(recovery.priorAuthorization),
+    remediationEventId: failures[0]!.eventId, remediationEventHash: failures[0]!.eventHash,
+    knowledgeRebindCount: task.knowledgeRebinds.length, knowledgeRebindHash: hashCanonical(task.knowledgeRebinds),
+  };
+}
+
 export function appendCorrectiveDecisionEvent(
   store: FileStateStore,
   task: TaskState,
@@ -431,7 +453,9 @@ export function appendCorrectiveDecisionEvent(
   validateCorrectiveDecisionAudit(correctiveAudit);
   const remediationEvents = readRemediationEvents(store, task).filter((event) => event.stepId === stepId);
   const triggeringAttemptCount = remediationEvents.length + 1;
-  if (triggeringAttemptCount < 3) {
+  const planningObstructionEvidence = triggeringAttemptCount === 2 && correctiveAudit.decision === 'replan-required'
+    ? firstFailurePlanningObstructionEvidence(store, task, stepId) : null;
+  if (triggeringAttemptCount < 3 && !planningObstructionEvidence) {
     throw new WorkflowError(
       'TRANSITION_BLOCKED',
       `Corrective decision is not available for ${stepId} before two guarded remediation failures exist.`,
@@ -500,6 +524,7 @@ export function appendCorrectiveDecisionEvent(
       stepId,
       triggeringAttemptCount,
       decision: correctiveAudit.decision,
+      ...(planningObstructionEvidence ? { recoveryBasis: 'planning-obstruction' as const, planningObstructionEvidence } : {}),
       auditor: correctiveAudit.auditor.trim(),
       coveredFindingIds,
       coveredEventIds,
@@ -645,6 +670,11 @@ export function readGuardedRemediationPostureForStep(
     ? findCurrentCorrectiveDecision(task, stepId, 2, history.correctiveDecisions)
     : null;
   const currentDecision = findCurrentCorrectiveDecision(task, stepId, history.nextAttemptOrdinal, history.correctiveDecisions);
+  if (remediationEvents.length === 1 && currentDecision === null
+    && firstFailurePlanningObstructionEvidence(store, task, stepId)) {
+    return { stepId, guardedCategory: requireGuardedCategory(planRiskAudit, stepId), attemptCount: 1,
+      nextAttemptOrdinal: history.nextAttemptOrdinal, mode: 'corrective', correctiveDecision: null, posture: 'decision-required' };
+  }
   if (remediationEvents.length < 2 && earlyPlanIntegrityDecision?.recoveryBasis !== 'plan-integrity'
     && currentDecision === null
     && deriveCurrentCauseDecision(remediationEvents, history.priorRemediationEvents) !== 'root-cause-replan') return null;
@@ -908,6 +938,11 @@ function deriveAttemptGateFromHistory(
     nextAttemptOrdinal,
     correctiveDecisions,
   );
+  if (currentCorrectiveDecision?.recoveryBasis === 'planning-obstruction') {
+    return { stepId, guardedCategory, attemptCount, nextAttemptOrdinal, mode: 'ordinary',
+      correctiveDecision: currentCorrectiveDecision,
+      posture: currentCorrectiveDecision.planHash === task.planHash ? 'replan-required' : 'replan-ready' };
+  }
   const planIntegrityDecision = currentCorrectiveDecision;
   if (planIntegrityDecision?.recoveryBasis === 'plan-integrity'
     && (planIntegrityDecision.planHash === task.planHash || planIntegrityDecision.decision === 'replan-required'
@@ -1414,7 +1449,19 @@ function validateStoredCorrectiveDecisionEvent(
   normalizeStringList(event.coveredFindingIds, 'Corrective decision coveredFindingIds');
   normalizeStringList(event.coveredEventIds, 'Corrective decision coveredEventIds');
   assertHash64(event.planHash, `Corrective decision planHash at ${file}:${line}`);
-  if (event.recoveryBasis === 'plan-integrity' || event.planIntegrityEvidence !== undefined) {
+  if (event.recoveryBasis === 'planning-obstruction' || event.planningObstructionEvidence !== undefined) {
+    const evidence = event.planningObstructionEvidence;
+    if (!evidence || event.recoveryBasis !== 'planning-obstruction' || event.planIntegrityEvidence !== undefined
+      || evidence.kind !== 'first-failure-rebound-planning-obstruction' || event.decision !== 'replan-required'
+      || event.triggeringAttemptCount !== 2 || evidence.sourcePlanHash !== event.planHash
+      || !Number.isSafeInteger(evidence.taskRevision) || evidence.taskRevision < 1
+      || !Number.isSafeInteger(evidence.knowledgeRebindCount) || evidence.knowledgeRebindCount < 1
+      || event.coveredEventIds.length !== 1 || event.coveredEventIds[0] !== evidence.remediationEventId) {
+      throw new WorkflowError('STATE_CORRUPT', 'First-failure planning obstruction requires exact bounded proof.', { file, line, taskId: task.id });
+    }
+    for (const key of ['sourcePlanHash', 'baselinePlanHash', 'baselineAuditEventHash', 'obstructionAuditEventHash',
+      'priorAuthorizationHash', 'remediationEventHash', 'knowledgeRebindHash'] as const) assertHash64(evidence[key], `Planning obstruction ${key}`);
+  } else if (event.recoveryBasis === 'plan-integrity' || event.planIntegrityEvidence !== undefined) {
     validatePlanIntegrityDecision(event, task, file, line);
   } else if (event.triggeringAttemptCount === 2) {
     throw new WorkflowError('STATE_CORRUPT', 'A second-attempt corrective decision requires bounded Plan-integrity evidence.', {
@@ -2200,6 +2247,26 @@ function validateCorrectiveDecisionCoverage(
         });
       }
     }
+    if (decision.recoveryBasis === 'planning-obstruction') {
+      const proof = decision.planningObstructionEvidence!;
+      const audits = readPlanRiskAuditEvents(store, task);
+      const baseline = audits.find(event => event.eventId === proof.baselineAuditEventId && event.eventHash === proof.baselineAuditEventHash);
+      const obstruction = audits.find(event => event.eventId === proof.obstructionAuditEventId && event.eventHash === proof.obstructionAuditEventHash);
+      const failed = priorEvents[0];
+      if (!baseline || !obstruction || !['approved', 'approved-with-rationale'].includes(baseline.decision)
+        || obstruction.decision !== 'stop-escalate' || audits.indexOf(baseline) >= audits.indexOf(obstruction)
+        || baseline.planHash !== proof.baselinePlanHash || obstruction.planHash !== proof.sourcePlanHash
+        || obstruction.taskRevision !== proof.taskRevision
+        || baseline.briefHash !== obstruction.briefHash || baseline.briefHash !== task.briefHash
+        || !failed || priorEvents.length !== 1 || failed.eventId !== proof.remediationEventId || failed.eventHash !== proof.remediationEventHash
+        || !task.authorizations.some(authorization => authorization.kind === 'execution' && authorization.decision === 'superseded'
+          && authorization.planHash === baseline.planHash && authorization.briefHash === baseline.briefHash
+          && hashCanonical(authorization) === proof.priorAuthorizationHash)
+        || task.knowledgeRebinds.length < proof.knowledgeRebindCount
+        || hashCanonical(task.knowledgeRebinds.slice(0, proof.knowledgeRebindCount)) !== proof.knowledgeRebindHash) {
+        throw new WorkflowError('STATE_CORRUPT', 'Planning-obstruction decision does not match immutable audit, authorization, rebind and failure history.', { taskId: task.id, decisionEventId: decision.eventId });
+      }
+    }
     if (decision.recoveryBasis === 'plan-integrity') {
       const evidence = decision.planIntegrityEvidence;
       const bindings = evidence?.kind === 'missing-npm-script-outside-allowed-writes'

package/src/alpha7/autonomy.ts

@@ -6,7 +6,7 @@ import type {
   SidecarEventRecord,
 } from '../contracts.js';
 import { STATE_SCHEMA_VERSION } from '../contracts.js';
-import { hashDelegationPolicy } from '../delegation.js';
+import { assertDelegationCanAuthorize, hashDelegationPolicy } from '../delegation.js';
 import { WorkflowError } from '../errors.js';
 import type { FileStateStore } from '../state/store.js';
 import { createEntityId, createUlid } from '../ulid.js';
@@ -284,6 +284,44 @@ export function applyMilestoneAutonomyContract(options: {
   return { contract: event, grant };
 }
 
+/** Derive a contract without issuing, extending or reactivating a grant. */
+export function bindMilestoneAutonomyToGrant(options: {
+  store: FileStateStore; projectId: string; milestone: MilestoneState;
+  actor: string; grantId: string; now: Date;
+}): ActiveMilestoneAutonomy {
+  const { store, projectId, milestone, actor, now } = options;
+  if (!['awaiting_execution_authorization', 'active'].includes(milestone.status) || !milestone.planHash)
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Autonomy binding requires a complete active Milestone Plan.');
+  const grant = store.readDelegation(projectId, options.grantId);
+  if (grant.scope.kind !== 'milestone' || grant.scope.id !== milestone.id)
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Autonomy binding requires an exact Milestone grant.');
+  for (const transition of AUTONOMY_TRANSITIONS) {
+    if (transition !== 'project_memory.approve' && !grant.transitions.includes(transition))
+      throw new WorkflowError('TRANSITION_BLOCKED', `Autonomy binding requires ${transition}; request grant expansion.`);
+  }
+  assertDelegationCanAuthorize(grant, 'milestone.execution_authorize', actor, milestone, now);
+  const previous = readMilestoneAutonomyEvents(store, projectId, milestone.id).at(-1);
+  if (previous) {
+    if (previous.delegationGrantId === grant.id) return requireActiveMilestoneAutonomy(options);
+    if (previous.semanticScopeHash !== milestoneSemanticScopeHash(milestone))
+      throw new WorkflowError('TRANSITION_BLOCKED', 'Autonomy rebinding cannot change the approved semantic scope.');
+    let previousGrant: DelegationGrant | null = null;
+    try { previousGrant = store.readDelegation(projectId, previous.delegationGrantId); }
+    catch (error) { if (!(error instanceof WorkflowError) || error.code !== 'NOT_FOUND') throw error; }
+    if (previousGrant?.status === 'active' && Date.parse(previousGrant.expiresAt) > now.getTime())
+      throw new WorkflowError('TRANSITION_BLOCKED', 'Revoke the existing active grant before replacing its autonomy binding.');
+  }
+  const contract = store.appendSidecarEvent<MilestoneAutonomyEvent>(
+    store.milestoneRoot(projectId, milestone.id), AUTONOMY_SIDECAR, {
+      eventId: `MAC-${createUlid(now.getTime())}`, recordedAt: now.toISOString(), eventType: 'issued',
+      projectId, milestoneId: milestone.id, milestoneRevision: milestone.revision,
+      principal: grant.principal, delegate: grant.delegate, issuedAt: now.toISOString(), expiresAt: grant.expiresAt,
+      semanticScopeHash: milestoneSemanticScopeHash(milestone), delegationGrantId: grant.id,
+      delegationPolicyHash: grant.policyHash,
+    }, { validateEvent: candidate => validateMilestoneAutonomyEvent(candidate, projectId, milestone.id) });
+  return { contract, grant };
+}
+
 export function requireActiveMilestoneAutonomy(options: {
   store: FileStateStore;
   projectId: string;

package/src/beta1/project-transaction.ts

@@ -1,9 +1,9 @@
-import { createHash } from 'node:crypto';
-import { existsSync, lstatSync, readFileSync, readdirSync, rmSync } from 'node:fs';
+import { createHash, randomUUID } from 'node:crypto';
+import { existsSync, lstatSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 import { WorkflowError } from '../errors.js';
-import { ensureDirectory, writeJsonAtomic, writeTextAtomic } from '../fs-utils.js';
+import { ensureDirectory, writeJsonAtomic } from '../fs-utils.js';
 
 type TransactionPhase = 'prepared' | 'applying' | 'applied' | 'rolled_back';
 
@@ -311,7 +311,16 @@ function restoreSnapshot(file: string, snapshot: Snapshot): void {
     rmSync(file, { force: true });
     return;
   }
-  writeTextAtomic(file, Buffer.from(snapshot.contentBase64!, 'base64').toString('utf8'));
+  // Snapshots preserve bytes; text normalization would corrupt newline-less or binary preimages.
+  const directory = path.dirname(file);
+  ensureDirectory(directory);
+  const temporary = path.join(directory, `.${path.basename(file)}.${randomUUID()}.tmp`);
+  try {
+    writeFileSync(temporary, Buffer.from(snapshot.contentBase64!, 'base64'), { mode: 0o600 });
+    renameSync(temporary, file);
+  } finally {
+    rmSync(temporary, { force: true });
+  }
   if (!snapshotsEqual(captureSnapshot(file), snapshot)) {
     throw new WorkflowError('STATE_CORRUPT', `Project transaction snapshot restore failed: ${file}`);
   }

package/src/cli-actions.ts

@@ -12,6 +12,9 @@ const CLI_ACTIONS_LITERAL = {
     'navigation-source-preflight',
     'navigation-transport-preflight',
     'navigation-recover',
+    'failed-checkpoint-source-preflight',
+    'failed-checkpoint-transport-preflight',
+    'failed-checkpoint-recover',
     'dependency-provenance-preflight',
     'dependency-provenance-recover',
     'historical-step-dependency-preflight',
@@ -51,6 +54,7 @@ const CLI_ACTIONS_LITERAL = {
     'corrective-yield',
     'corrective-yield-recover',
     'corrective-replan-prepare',
+    'corrective-replan-authorize',
     'corrective-replan-confirm',
     'corrective-replan-execute',
     'corrective-replan-recover',
@@ -80,6 +84,7 @@ const CLI_ACTIONS_LITERAL = {
     'scope-change-apply',
     'autonomy-prepare',
     'autonomy-grant',
+    'autonomy-bind',
     'autonomy-evolve',
     'authorize',
     'validate',