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

package/src/alpha7/corrective-recovery.ts

@@ -0,0 +1,1332 @@
+import { closeSync, existsSync, openSync, readFileSync, unlinkSync } from 'node:fs';
+import path from 'node:path';
+import type {
+  AuthorizationEvent,
+  CorrectiveDecisionEvent,
+  CorrectiveDecisionRecoveryEvent,
+  DelegationGrant,
+  DependencyProvenanceRecoveryRecord,
+  PlanRiskAuditEvent,
+  ProjectKnowledgeMap,
+  StopEscalateOverrideEvent,
+  TaskKnowledgeRebindRecord,
+  TaskState,
+  WriterLease,
+} from '../contracts.js';
+import { hashDelegationPolicy } from '../delegation.js';
+import { WorkflowError } from '../errors.js';
+import { hashKnowledgeMap } from '../memory.js';
+import type { FileStateStore } from '../state/store.js';
+import { createUlid } from '../ulid.js';
+import { readTaskC1Posture, readTaskHandoffEvents } from '../alpha6/handoff.js';
+import { readCurrentPlanRiskAudit, readPlanRiskAuditEvents } from '../alpha6/plan-risk.js';
+import { readMilestoneAutonomyEvents, type MilestoneAutonomyEvent } from './autonomy.js';
+import {
+  assertCorrectiveAuditorIndependence,
+  readCorrectiveDecisionEvents,
+  readRemediationEvents,
+  readStopEscalateOverrideEvents,
+} from '../alpha6/remediation.js';
+import { assertHash64, canonicalJsonStringify, sha256Hex } from '../alpha6/store-sidecars.js';
+import { gitIsAncestor, runGit } from '../repository.js';
+import { PACKAGE_NAME } from '../version.js';
+
+export const CORRECTIVE_DECISION_RECOVERIES_SIDECAR = 'corrective-decision-recoveries.jsonl';
+const RECOVERY_LOCK = '.corrective-decision-recovery.lock';
+const KNOWLEDGE_LINE = /^- Knowledge map: revision ([1-9]\d*), hash ([a-f0-9]{64})$/gm;
+const KNOWLEDGE_SENTINEL = '- Knowledge map: revision <context>, hash <context>';
+const REFRESH_REASONS = new Set([
+  'Delegated content-only context refresh.',
+  'Delegated Plan-bounded supporting-source context refresh.',
+]);
+
+export interface CorrectiveRecoveryAssessment {
+  task: TaskState;
+  decision: CorrectiveDecisionEvent;
+  directRebind: TaskKnowledgeRebindRecord;
+  semanticPlanHash: string;
+  sourceAudit: PlanRiskAuditEvent;
+  reboundAudit: PlanRiskAuditEvent;
+  knowledgeMapApprovalFingerprint: string;
+  taskAuthorizationFingerprint: string;
+  delegationGrantFingerprint: string;
+  c1EvidenceFingerprint: string;
+  evidenceFingerprint: string;
+}
+
+export interface StopOverrideContextRebindAssessment {
+  task: TaskState;
+  override: StopEscalateOverrideEvent;
+  stopDecision: CorrectiveDecisionEvent;
+  semanticPlanHash: string;
+}
+
+interface ContextOnlyPlanRebindEvidence {
+  directRebind: TaskKnowledgeRebindRecord;
+  semanticPlanHash: string;
+  sourceAudit: PlanRiskAuditEvent;
+  reboundAudit: PlanRiskAuditEvent;
+  planRiskAudits: PlanRiskAuditEvent[];
+  knowledgeMap: ProjectKnowledgeMap;
+  authorization: AuthorizationEvent;
+  grant: DelegationGrant;
+  autonomyContract: MilestoneAutonomyEvent | null;
+}
+
+interface AppendOnlyContextPlanRebindEvidence {
+  rebindChain: TaskKnowledgeRebindRecord[];
+  semanticPlanHash: string;
+  sourceAudit: PlanRiskAuditEvent;
+  reboundAudit: PlanRiskAuditEvent;
+  planRiskAudits: PlanRiskAuditEvent[];
+  knowledgeMap: ProjectKnowledgeMap;
+  authorization: AuthorizationEvent;
+  grant: DelegationGrant;
+  autonomyContract: MilestoneAutonomyEvent | null;
+}
+
+interface RecoveryChainSnapshot {
+  fingerprint: string;
+  matchingEvent: CorrectiveDecisionRecoveryEvent | null;
+}
+
+export function readCorrectiveDecisionRecoveryEvents(
+  store: FileStateStore,
+  task: TaskState,
+): CorrectiveDecisionRecoveryEvent[] {
+  return store.readSidecarEvents<CorrectiveDecisionRecoveryEvent>(
+    store.taskRoot(task.projectId, task.id),
+    CORRECTIVE_DECISION_RECOVERIES_SIDECAR,
+    { validateEvent: (event, context) => validateRecoveryEvent(event, task, context.file, context.line) },
+  );
+}
+
+export function assessCorrectiveDecisionRecovery(
+  store: FileStateStore,
+  task: TaskState,
+  stepId: string,
+  actor: string,
+  writerToken: string | null,
+): CorrectiveRecoveryAssessment {
+  const normalizedActor = actor.trim();
+  if (!normalizedActor) throw new WorkflowError('INVALID_ARGUMENT', 'Corrective recovery actor is required.');
+  if (!task.planHash || task.knowledgeMapRevision === null || !task.knowledgeMapHash) {
+    throw new WorkflowError('STATE_CORRUPT', `Task ${task.id} is missing current Plan or Knowledge bindings.`);
+  }
+  const step = task.steps.find((candidate) => candidate.id === stepId);
+  if (!step) throw new WorkflowError('NOT_FOUND', `Step not found: ${stepId}`);
+  if (!['planned', 'failed'].includes(step.status)) {
+    throw new WorkflowError('TRANSITION_BLOCKED', `Corrective recovery is unavailable while ${stepId} is ${step.status}.`);
+  }
+  const remediationEvents = readRemediationEvents(store, task);
+  const stepRemediations = remediationEvents.filter((event) => event.stepId === stepId);
+  if (stepRemediations.length !== 2) {
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Corrective recovery requires exactly two failed remediation attempts.', {
+      taskId: task.id,
+      stepId,
+      attemptCount: stepRemediations.length,
+    });
+  }
+  const correctiveDecisions = readCorrectiveDecisionEvents(store, task);
+  const matchingDecisions = correctiveDecisions.filter((event) =>
+    event.stepId === stepId && event.triggeringAttemptCount === 3,
+  );
+  if (matchingDecisions.length !== 1) {
+    throw new WorkflowError('STATE_CORRUPT', 'Corrective recovery requires one decision for the exact Step/ordinal.', {
+      taskId: task.id,
+      stepId,
+      matchingDecisionIds: matchingDecisions.map((event) => event.eventId),
+    });
+  }
+  const decision = matchingDecisions[0]!;
+  if (decision.decision !== 'continue-fix') {
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Only continue-fix may be recovered after context refresh.', {
+      taskId: task.id,
+      stepId,
+      decision: decision.decision,
+    });
+  }
+  if (decision.planHash === task.planHash) {
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Corrective decision already binds the current Plan; recovery is unnecessary.');
+  }
+  assertCorrectiveAuditorIndependence(store, task, stepId, decision.auditor);
+
+  const rebindEvidence = assessContextOnlyPlanRebindEvidence(store, task, stepId, decision);
+  const {
+    directRebind,
+    semanticPlanHash,
+    sourceAudit,
+    reboundAudit,
+    planRiskAudits,
+    knowledgeMap,
+    authorization,
+    grant,
+    autonomyContract,
+  } = rebindEvidence;
+  const c1 = requireC1Evidence(store, task, normalizedActor, writerToken);
+
+  const knowledgeMapApprovalFingerprint = hashEvidence(knowledgeMap.approval);
+  const taskAuthorizationFingerprint = hashEvidence(authorization);
+  const delegationGrantFingerprint = hashEvidence(grant);
+  const c1EvidenceFingerprint = hashEvidence(c1);
+  const evidenceFingerprint = hashEvidence({
+    task,
+    decisionPlanHash: decision.planHash,
+    reboundPlanHash: task.planHash,
+    semanticPlanHash,
+    remediationEvents,
+    correctiveDecisions,
+    planRiskAudits,
+    knowledgeMap,
+    grant,
+    autonomyContract,
+    handoffs: readTaskHandoffEvents(store, task),
+    c1,
+  });
+  return {
+    task,
+    decision,
+    directRebind,
+    semanticPlanHash,
+    sourceAudit,
+    reboundAudit,
+    knowledgeMapApprovalFingerprint,
+    taskAuthorizationFingerprint,
+    delegationGrantFingerprint,
+    c1EvidenceFingerprint,
+    evidenceFingerprint,
+  };
+}
+
+export function appendCorrectiveDecisionRecovery(
+  store: FileStateStore,
+  task: TaskState,
+  stepId: string,
+  expectedRevision: number,
+  actor: string,
+  writerToken: string | null,
+  now: Date,
+): CorrectiveDecisionRecoveryEvent {
+  if (task.revision !== expectedRevision) {
+    throw new WorkflowError('STATE_CONFLICT', `State revision conflict for ${task.id}`, {
+      expectedRevision,
+      actualRevision: task.revision,
+    });
+  }
+  const preflight = assessCorrectiveDecisionRecovery(store, task, stepId, actor, writerToken);
+  const preflightRecoveryChain = snapshotRecoveryChain(store, task, preflight, actor.trim());
+  const taskRoot = store.taskRoot(task.projectId, task.id);
+  const lockFile = path.join(taskRoot, RECOVERY_LOCK);
+  let descriptor: number;
+  try {
+    descriptor = openSync(lockFile, 'wx', 0o600);
+    closeSync(descriptor);
+  } catch (error) {
+    if (existsSync(lockFile)) {
+      throw new WorkflowError('LOCKED', `Corrective recovery for ${task.id} is already being serialized.`, {
+        taskId: task.id,
+        stepId,
+      });
+    }
+    throw error;
+  }
+  try {
+    const currentTask = store.readTask(task.projectId, task.id);
+    if (currentTask.revision !== expectedRevision) {
+      throw new WorkflowError('STATE_CONFLICT', `State revision conflict for ${task.id}`, {
+        expectedRevision,
+        actualRevision: currentTask.revision,
+      });
+    }
+    let underLock: CorrectiveRecoveryAssessment;
+    try {
+      underLock = assessCorrectiveDecisionRecovery(store, currentTask, stepId, actor, writerToken);
+    } catch (error) {
+      throw new WorkflowError('STATE_CONFLICT', 'Corrective recovery evidence changed after preflight.', {
+        taskId: task.id,
+        stepId,
+        cause: error instanceof Error ? error.message : String(error),
+      });
+    }
+    if (underLock.evidenceFingerprint !== preflight.evidenceFingerprint) {
+      throw new WorkflowError('STATE_CONFLICT', 'Corrective recovery evidence changed after preflight.', {
+        taskId: task.id,
+        stepId,
+        preflightEvidenceFingerprint: preflight.evidenceFingerprint,
+        currentEvidenceFingerprint: underLock.evidenceFingerprint,
+      });
+    }
+    const underLockRecoveryChain = snapshotRecoveryChain(store, currentTask, underLock, actor.trim());
+    if (underLockRecoveryChain.matchingEvent) {
+      return underLockRecoveryChain.matchingEvent;
+    }
+    if (underLockRecoveryChain.fingerprint !== preflightRecoveryChain.fingerprint) {
+      throw new WorkflowError('STATE_CONFLICT', 'Corrective recovery chain changed after preflight.', {
+        taskId: task.id,
+        stepId,
+        preflightRecoveryChainFingerprint: preflightRecoveryChain.fingerprint,
+        currentRecoveryChainFingerprint: underLockRecoveryChain.fingerprint,
+      });
+    }
+    return store.appendSidecarEvent<CorrectiveDecisionRecoveryEvent>(
+      taskRoot,
+      CORRECTIVE_DECISION_RECOVERIES_SIDECAR,
+      recoveryPayload(underLock, actor.trim(), now),
+      { validateEvent: (event, context) => validateRecoveryEvent(event, currentTask, context.file, context.line) },
+    );
+  } finally {
+    if (existsSync(lockFile)) unlinkSync(lockFile);
+  }
+}
+
+function snapshotRecoveryChain(
+  store: FileStateStore,
+  task: TaskState,
+  assessment: CorrectiveRecoveryAssessment,
+  actor: string,
+): RecoveryChainSnapshot {
+  const events = readCorrectiveDecisionRecoveryEvents(store, task);
+  const sameBinding = events.filter((event) =>
+    event.correctiveDecisionEventId === assessment.decision.eventId
+    && event.stepId === assessment.decision.stepId
+    && event.triggeringAttemptCount === assessment.decision.triggeringAttemptCount,
+  );
+  if (sameBinding.length > 1) {
+    throw new WorkflowError('STATE_CORRUPT', 'Multiple recoveries exist for one corrective decision binding.', {
+      taskId: task.id,
+      stepId: assessment.decision.stepId,
+      eventIds: sameBinding.map((event) => event.eventId),
+    });
+  }
+  const matchingEvent = sameBinding[0] ?? null;
+  if (matchingEvent) assertRecoveryMatchesAssessment(matchingEvent, assessment, actor);
+  return { fingerprint: hashEvidence(events), matchingEvent };
+}
+
+export function requireCorrectiveDecisionRecoveryForRun(
+  store: FileStateStore,
+  task: TaskState,
+  stepId: string,
+  actor: string,
+  writerToken: string | null,
+): CorrectiveDecisionRecoveryEvent {
+  const assessment = assessCorrectiveDecisionRecovery(store, task, stepId, actor, writerToken);
+  const events = readCorrectiveDecisionRecoveryEvents(store, task);
+  const matches = events.filter((event) =>
+    event.correctiveDecisionEventId === assessment.decision.eventId
+    && event.stepId === stepId
+    && event.triggeringAttemptCount === assessment.decision.triggeringAttemptCount,
+  );
+  if (matches.length !== 1) {
+    throw new WorkflowError('TRANSITION_BLOCKED', 'A validated corrective recovery is required before this run.', {
+      taskId: task.id,
+      stepId,
+      correctiveDecisionEventId: assessment.decision.eventId,
+      recoveryCount: matches.length,
+    });
+  }
+  const recovery = matches[0]!;
+  assertRecoveryMatchesAssessment(recovery, assessment, actor.trim());
+  return recovery;
+}
+
+export function assessCorrectiveDecisionRecoveryForNavigation(
+  store: FileStateStore,
+  task: TaskState,
+  stepId: string,
+): CorrectiveRecoveryAssessment {
+  const posture = readTaskC1Posture(store, task);
+  const lease = readWriterLease(store, task);
+  const actor = posture.state === 'claimed' ? posture.claimant : lease?.owner ?? 'worker';
+  return assessCorrectiveDecisionRecovery(store, task, stepId, actor, lease?.token ?? null);
+}
+
+export function readValidatedStopOverrideContextRebindIfApplicable(
+  store: FileStateStore,
+  task: TaskState,
+  stepId: string,
+  repositoryRoot: string,
+): StopOverrideContextRebindAssessment | null {
+  if (!task.planHash) return null;
+  const remediationEvents = readRemediationEvents(store, task).filter((event) => event.stepId === stepId);
+  const triggeringAttemptCount = remediationEvents.length + 1;
+  const staleStops = readCorrectiveDecisionEvents(store, task).filter((event) =>
+    event.stepId === stepId
+    && event.triggeringAttemptCount === triggeringAttemptCount
+    && event.decision === 'stop-escalate'
+    && event.planHash !== task.planHash,
+  );
+  if (staleStops.length === 0) return null;
+  if (staleStops.length !== 1) {
+    throw new WorkflowError('STATE_CORRUPT', 'Multiple stale stop decisions match one guarded retry binding.', {
+      taskId: task.id,
+      stepId,
+      triggeringAttemptCount,
+      decisionEventIds: staleStops.map((event) => event.eventId),
+    });
+  }
+  return assessStopOverrideContextRebind(store, task, stepId, staleStops[0]!, remediationEvents, repositoryRoot);
+}
+
+function assessStopOverrideContextRebind(
+  store: FileStateStore,
+  task: TaskState,
+  stepId: string,
+  stopDecision: CorrectiveDecisionEvent,
+  remediationEvents: ReturnType<typeof readRemediationEvents>,
+  repositoryRoot: string,
+): StopOverrideContextRebindAssessment {
+  const step = task.steps.find((candidate) => candidate.id === stepId) ?? null;
+  if (!step) throw new WorkflowError('NOT_FOUND', `Step not found: ${stepId}`);
+  if (!['planned', 'failed', 'in_progress'].includes(step.status)) {
+    throw new WorkflowError('TRANSITION_BLOCKED', `Attempt-four continuation is unavailable while ${stepId} is ${step.status}.`);
+  }
+  if (
+    remediationEvents.length !== 3
+    || remediationEvents[0]?.attemptOrdinal !== 1
+    || remediationEvents[0]?.mode !== 'ordinary'
+    || remediationEvents[1]?.attemptOrdinal !== 2
+    || remediationEvents[1]?.mode !== 'ordinary'
+    || remediationEvents[2]?.attemptOrdinal !== 3
+    || remediationEvents[2]?.mode !== 'corrective'
+  ) {
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Context-rebound stop override requires the exact three-attempt beta.11 history.', {
+      taskId: task.id,
+      stepId,
+      attempts: remediationEvents.map((event) => ({ ordinal: event.attemptOrdinal, mode: event.mode })),
+    });
+  }
+  const overrides = readStopEscalateOverrideEvents(store, task).filter((event) =>
+    event.stepId === stepId && event.stopDecisionEventId === stopDecision.eventId,
+  );
+  if (overrides.length !== 1) {
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Context-rebound attempt four requires one exact applied stop override.', {
+      taskId: task.id,
+      stepId,
+      stopDecisionEventId: stopDecision.eventId,
+      overrideEventIds: overrides.map((event) => event.eventId),
+    });
+  }
+  const override = overrides[0]!;
+  if (
+    stopDecision.triggeringAttemptCount !== 4
+    || stopDecision.planHash !== override.planHash
+    || task.planHash === override.planHash
+    || override.coveredEventIds.length !== remediationEvents.length
+    || override.coveredEventIds.some((eventId, index) => eventId !== remediationEvents[index]!.eventId)
+  ) {
+    throw new WorkflowError('STATE_CORRUPT', 'Context-rebound stop override no longer binds the exact source Plan/history.', {
+      taskId: task.id,
+      stepId,
+      overrideEventId: override.eventId,
+    });
+  }
+  assertCorrectiveAuditorIndependence(store, task, stepId, stopDecision.auditor);
+  const rebindEvidence = assessAppendOnlyContextPlanRebindEvidence(
+    store,
+    task,
+    stepId,
+    stopDecision,
+  );
+  const verifiedHeadRecoveries = requireStopOverrideHeadContinuity(
+    repositoryRoot,
+    task,
+    override,
+    rebindEvidence.authorization,
+  );
+  requireEvidenceBoundAuditTaskRevision(
+    task,
+    rebindEvidence.reboundAudit,
+    verifiedHeadRecoveries,
+    step.status === 'in_progress',
+  );
+  const stopAt = Date.parse(stopDecision.recordedAt);
+  const overrideAt = Date.parse(override.recordedAt);
+  const firstRebindAt = Date.parse(rebindEvidence.rebindChain[0]!.recordedAt);
+  const lastRebindAt = Date.parse(rebindEvidence.rebindChain.at(-1)!.recordedAt);
+  if (
+    ![stopAt, overrideAt, firstRebindAt, lastRebindAt].every(Number.isFinite)
+    || overrideAt < stopAt
+    || firstRebindAt < overrideAt
+    || lastRebindAt < firstRebindAt
+  ) {
+    throw new WorkflowError('STATE_CORRUPT', 'Stop override and context-rebind chronology is invalid.', {
+      taskId: task.id,
+      stepId,
+      stopDecisionRecordedAt: stopDecision.recordedAt,
+      overrideRecordedAt: override.recordedAt,
+      firstRebindRecordedAt: rebindEvidence.rebindChain[0]!.recordedAt,
+      lastRebindRecordedAt: rebindEvidence.rebindChain.at(-1)!.recordedAt,
+    });
+  }
+  return {
+    task,
+    override,
+    stopDecision,
+    semanticPlanHash: rebindEvidence.semanticPlanHash,
+  };
+}
+
+function recoveryPayload(
+  assessment: CorrectiveRecoveryAssessment,
+  actor: string,
+  now: Date,
+): Omit<CorrectiveDecisionRecoveryEvent, 'previousEventHash' | 'eventHash'> {
+  const { task, decision, directRebind, sourceAudit, reboundAudit } = assessment;
+  return {
+    eventId: `CDR-${createUlid(now.getTime())}`,
+    recordedAt: now.toISOString(),
+    taskId: task.id,
+    stepId: decision.stepId,
+    triggeringAttemptCount: decision.triggeringAttemptCount,
+    correctiveDecisionEventId: decision.eventId,
+    correctiveDecisionEventHash: decision.eventHash,
+    decisionPlanHash: decision.planHash,
+    reboundPlanHash: task.planHash!,
+    semanticPlanHash: assessment.semanticPlanHash,
+    fromKnowledgeMapRevision: directRebind.fromKnowledgeMapRevision,
+    fromKnowledgeMapHash: directRebind.fromKnowledgeMapHash,
+    toKnowledgeMapRevision: directRebind.toKnowledgeMapRevision,
+    toKnowledgeMapHash: directRebind.toKnowledgeMapHash,
+    rebindRecordedAt: directRebind.recordedAt,
+    sourcePlanRiskAuditEventId: sourceAudit.eventId,
+    sourcePlanRiskAuditEventHash: sourceAudit.eventHash,
+    reboundPlanRiskAuditEventId: reboundAudit.eventId,
+    reboundPlanRiskAuditEventHash: reboundAudit.eventHash,
+    knowledgeMapApprovalFingerprint: assessment.knowledgeMapApprovalFingerprint,
+    taskAuthorizationFingerprint: assessment.taskAuthorizationFingerprint,
+    delegationGrantFingerprint: assessment.delegationGrantFingerprint,
+    c1EvidenceFingerprint: assessment.c1EvidenceFingerprint,
+    evidenceFingerprint: assessment.evidenceFingerprint,
+    actor,
+  };
+}
+
+function hashEvidence(value: unknown): string {
+  return sha256Hex(canonicalJsonStringify(value));
+}
+
+function assessContextOnlyPlanRebindEvidence(
+  store: FileStateStore,
+  task: TaskState,
+  stepId: string,
+  sourceDecision: CorrectiveDecisionEvent,
+  options: { allowTaskRevisionAdvance?: boolean } = {},
+): ContextOnlyPlanRebindEvidence {
+  if (!task.planHash || task.knowledgeMapRevision === null || !task.knowledgeMapHash) {
+    throw new WorkflowError('STATE_CORRUPT', `Task ${task.id} is missing current Plan or Knowledge bindings.`);
+  }
+  if (sourceDecision.planHash === task.planHash) {
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Context-only Plan rebind validation requires distinct source and current Plan hashes.');
+  }
+  const taskRoot = store.taskRoot(task.projectId, task.id);
+  const planEvidence = comparePlanArtifacts(taskRoot, sourceDecision.planHash, task.planHash);
+  const currentAudit = readCurrentPlanRiskAudit(store, task);
+  if (!currentAudit || !currentAudit.reviewRequiredStepIds.includes(stepId)) {
+    throw new WorkflowError('TRANSITION_BLOCKED', `Step ${stepId} is not guarded by the current Plan Risk Audit.`);
+  }
+  const planRiskAudits = readPlanRiskAuditEvents(store, task);
+  const { sourceAudit, reboundAudit } = requireMechanicalAuditRebound(
+    task,
+    sourceDecision,
+    planRiskAudits,
+    options.allowTaskRevisionAdvance ?? false,
+  );
+  const directRebind = requireDirectRebind(task, sourceDecision, sourceAudit);
+  assertRebindMatchesPlans(directRebind, planEvidence);
+  if (
+    sourceAudit.knowledgeMapRevision !== directRebind.fromKnowledgeMapRevision
+    || sourceAudit.knowledgeMapHash !== directRebind.fromKnowledgeMapHash
+    || reboundAudit.knowledgeMapRevision !== directRebind.toKnowledgeMapRevision
+    || reboundAudit.knowledgeMapHash !== directRebind.toKnowledgeMapHash
+  ) {
+    throw new WorkflowError('STATE_CORRUPT', 'Plan Risk Audit pair does not bind the direct Knowledge rebind endpoints.');
+  }
+
+  const knowledgeMap = store.readKnowledgeMap(task.projectId);
+  const authorization = requireRefreshAuthorization(task);
+  const { grant, autonomyContract } = requireRefreshAuthority(
+    store,
+    task,
+    knowledgeMap,
+    authorization,
+    directRebind,
+  );
+  assertRefreshChronology(knowledgeMap, authorization, directRebind, reboundAudit);
+  return {
+    directRebind,
+    semanticPlanHash: planEvidence.semanticPlanHash,
+    sourceAudit,
+    reboundAudit,
+    planRiskAudits,
+    knowledgeMap,
+    authorization,
+    grant,
+    autonomyContract,
+  };
+}
+
+function assessAppendOnlyContextPlanRebindEvidence(
+  store: FileStateStore,
+  task: TaskState,
+  stepId: string,
+  sourceDecision: CorrectiveDecisionEvent,
+): AppendOnlyContextPlanRebindEvidence {
+  if (!task.planHash || task.knowledgeMapRevision === null || !task.knowledgeMapHash) {
+    throw new WorkflowError('STATE_CORRUPT', `Task ${task.id} is missing current Plan or Knowledge bindings.`);
+  }
+  if (sourceDecision.planHash === task.planHash) {
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Append-only Plan rebind validation requires distinct source and current Plan hashes.');
+  }
+  const planRiskAudits = readPlanRiskAuditEvents(store, task);
+  const rebindChain = requireAppendOnlyRebindChain(task, sourceDecision, planRiskAudits);
+  const planEvidence = comparePlanRebindChainArtifacts(
+    store.taskRoot(task.projectId, task.id),
+    sourceDecision.planHash,
+    task.planHash,
+    rebindChain,
+  );
+  const { sourceAudit, reboundAudit, auditChain } = requireMechanicalAuditReboundChain(
+    task,
+    sourceDecision,
+    planRiskAudits,
+    rebindChain,
+  );
+  if (!reboundAudit.stepClassifications.some((classification) =>
+    classification.stepId === stepId && classification.reviewRequired
+  )) {
+    throw new WorkflowError('TRANSITION_BLOCKED', `Step ${stepId} is not guarded by the current Plan Risk Audit.`);
+  }
+  for (let index = 0; index < rebindChain.length; index += 1) {
+    const rebind = rebindChain[index]!;
+    const fromBinding = planEvidence.bindings.get(rebind.previousPlanHash);
+    const toBinding = planEvidence.bindings.get(rebind.reboundPlanHash);
+    if (!fromBinding || !toBinding) {
+      throw new WorkflowError('STATE_CORRUPT', 'Append-only Knowledge rebind references an unverified Plan artifact.', {
+        previousPlanHash: rebind.previousPlanHash,
+        reboundPlanHash: rebind.reboundPlanHash,
+      });
+    }
+    assertRebindMatchesPlans(rebind, { decisionBinding: fromBinding, reboundBinding: toBinding });
+    const fromAudit = auditChain[index]!;
+    const toAudit = auditChain[index + 1]!;
+    if (
+      fromAudit.knowledgeMapRevision !== rebind.fromKnowledgeMapRevision
+      || fromAudit.knowledgeMapHash !== rebind.fromKnowledgeMapHash
+      || toAudit.knowledgeMapRevision !== rebind.toKnowledgeMapRevision
+      || toAudit.knowledgeMapHash !== rebind.toKnowledgeMapHash
+    ) {
+      throw new WorkflowError('STATE_CORRUPT', 'Plan Risk Audit chain does not bind every Knowledge rebind endpoint.', {
+        rebindIndex: index,
+      });
+    }
+  }
+
+  const knowledgeMap = store.readKnowledgeMap(task.projectId);
+  const authorization = requireRefreshAuthorization(task);
+  const finalRebind = rebindChain.at(-1)!;
+  const { grant, autonomyContract } = requireRefreshAuthority(
+    store,
+    task,
+    knowledgeMap,
+    authorization,
+    finalRebind,
+  );
+  assertRefreshChronology(knowledgeMap, authorization, finalRebind, reboundAudit);
+  return {
+    rebindChain,
+    semanticPlanHash: planEvidence.semanticPlanHash,
+    sourceAudit,
+    reboundAudit,
+    planRiskAudits,
+    knowledgeMap,
+    authorization,
+    grant,
+    autonomyContract,
+  };
+}
+
+function comparePlanRebindChainArtifacts(
+  taskRoot: string,
+  sourcePlanHash: string,
+  currentPlanHash: string,
+  rebindChain: TaskKnowledgeRebindRecord[],
+): {
+  semanticPlanHash: string;
+  bindings: Map<string, { revision: number; hash: string }>;
+} {
+  const planHashes = [sourcePlanHash, ...rebindChain.map((rebind) => rebind.reboundPlanHash)];
+  if (planHashes.at(-1) !== currentPlanHash || new Set(planHashes).size !== planHashes.length) {
+    throw new WorkflowError('STATE_CORRUPT', 'Knowledge rebind chain does not form one acyclic source-to-current Plan sequence.');
+  }
+  const contents = planHashes.map((planHash) => readVerifiedPlanArtifact(taskRoot, planHash, currentPlanHash));
+  const bindings = new Map<string, { revision: number; hash: string }>();
+  let semanticPlanHash: string | null = null;
+  for (let index = 0; index < contents.length; index += 1) {
+    const planHash = planHashes[index]!;
+    bindings.set(planHash, normalizePlanKnowledgeBinding(contents[index]!, `Plan ${planHash}`).binding);
+    if (index === 0) continue;
+    const adjacentSemanticHash = assertKnowledgeBindingOnlyPlanChange(contents[index - 1]!, contents[index]!);
+    if (semanticPlanHash !== null && semanticPlanHash !== adjacentSemanticHash) {
+      throw new WorkflowError('STATE_CORRUPT', 'Append-only Plan rebind chain does not preserve one semantic Plan identity.');
+    }
+    semanticPlanHash = adjacentSemanticHash;
+  }
+  if (!semanticPlanHash) {
+    throw new WorkflowError('STATE_CORRUPT', 'Append-only Plan rebind chain has no comparable Plan hop.');
+  }
+  return { semanticPlanHash, bindings };
+}
+
+function readVerifiedPlanArtifact(taskRoot: string, planHash: string, currentPlanHash: string): string {
+  assertHash64(planHash, 'Plan hash');
+  const file = planHash === currentPlanHash
+    ? path.join(taskRoot, 'plan.md')
+    : path.join(taskRoot, '.versions', `plan.md.${planHash}`);
+  if (!existsSync(file)) {
+    throw new WorkflowError('STATE_CORRUPT', 'Plan artifact required by the append-only rebind chain is missing.', {
+      planHash,
+      file,
+    });
+  }
+  const content = readFileSync(file, 'utf8');
+  if (sha256Hex(content) !== planHash) {
+    throw new WorkflowError('STATE_CORRUPT', 'Plan artifact content does not match its append-only rebind hash.', {
+      planHash,
+      file,
+    });
+  }
+  return content;
+}
+
+function comparePlanArtifacts(taskRoot: string, decisionPlanHash: string, reboundPlanHash: string): {
+  semanticPlanHash: string;
+  decisionBinding: { revision: number; hash: string };
+  reboundBinding: { revision: number; hash: string };
+} {
+  assertHash64(decisionPlanHash, 'Corrective decision Plan hash');
+  assertHash64(reboundPlanHash, 'Current Plan hash');
+  const historicalFile = path.join(taskRoot, '.versions', `plan.md.${decisionPlanHash}`);
+  if (!existsSync(historicalFile)) {
+    throw new WorkflowError('STATE_CORRUPT', 'Historical corrective-decision Plan artifact is missing.', {
+      decisionPlanHash,
+      historicalFile,
+    });
+  }
+  const historical = readFileSync(historicalFile, 'utf8');
+  const current = readFileSync(path.join(taskRoot, 'plan.md'), 'utf8');
+  if (sha256Hex(historical) !== decisionPlanHash || sha256Hex(current) !== reboundPlanHash) {
+    throw new WorkflowError('STATE_CORRUPT', 'Plan artifact content does not match its recorded hash.');
+  }
+  const semanticPlanHash = assertKnowledgeBindingOnlyPlanChange(historical, current);
+  const decision = normalizePlanKnowledgeBinding(historical, 'historical');
+  const rebound = normalizePlanKnowledgeBinding(current, 'current');
+  return {
+    semanticPlanHash,
+    decisionBinding: decision.binding,
+    reboundBinding: rebound.binding,
+  };
+}
+
+function normalizePlanKnowledgeBinding(content: string, label: string): {
+  normalized: string;
+  binding: { revision: number; hash: string };
+} {
+  const matches = [...content.matchAll(KNOWLEDGE_LINE)];
+  if (matches.length !== 1) {
+    throw new WorkflowError('STATE_CORRUPT', `${label} Plan must contain exactly one canonical Knowledge Map binding line.`, {
+      matchCount: matches.length,
+    });
+  }
+  const match = matches[0]!;
+  return {
+    normalized: content.slice(0, match.index) + KNOWLEDGE_SENTINEL + content.slice(match.index! + match[0].length),
+    binding: { revision: Number(match[1]), hash: match[2]! },
+  };
+}
+
+function requireMechanicalAuditRebound(
+  task: TaskState,
+  decision: CorrectiveDecisionEvent,
+  events: PlanRiskAuditEvent[],
+  allowTaskRevisionAdvance = false,
+): { sourceAudit: PlanRiskAuditEvent; reboundAudit: PlanRiskAuditEvent } {
+  const sources = events.filter((event) => event.planHash === decision.planHash);
+  const rebounds = events.filter((event) => event.planHash === task.planHash);
+  if (sources.length !== 1 || rebounds.length !== 1) {
+    throw new WorkflowError('STATE_CORRUPT', 'Recovery requires one source and one rebound Plan Risk Audit.', {
+      sourceAuditIds: sources.map((event) => event.eventId),
+      reboundAuditIds: rebounds.map((event) => event.eventId),
+    });
+  }
+  const sourceAudit = sources[0]!;
+  const reboundAudit = rebounds[0]!;
+  const sourceIndex = events.indexOf(sourceAudit);
+  const reboundIndex = events.indexOf(reboundAudit);
+  if (reboundIndex !== sourceIndex + 1 || reboundAudit.previousEventHash !== sourceAudit.eventHash || reboundIndex !== events.length - 1) {
+    throw new WorkflowError('STATE_CORRUPT', 'Plan Risk Audit rebound is not the immediate append-only successor of the source audit.');
+  }
+  const expectedSummary = `${sourceAudit.summary} Rebound automatically after content-only Task context refresh.`;
+  if (
+    reboundAudit.taskId !== sourceAudit.taskId
+    || reboundAudit.briefHash !== sourceAudit.briefHash
+    || reboundAudit.planner !== sourceAudit.planner
+    || reboundAudit.auditor !== sourceAudit.auditor
+    || reboundAudit.decision !== sourceAudit.decision
+    || reboundAudit.splitRationale !== sourceAudit.splitRationale
+    || reboundAudit.summary !== expectedSummary
+    || canonicalJsonStringify(reboundAudit.stepClassifications) !== canonicalJsonStringify(sourceAudit.stepClassifications)
+  ) {
+    throw new WorkflowError('STATE_CORRUPT', 'Current Plan Risk Audit is not a mechanical content-refresh rebound.');
+  }
+  if (sourceAudit.briefHash !== task.briefHash || reboundAudit.briefHash !== task.briefHash) {
+    throw new WorkflowError('STATE_CORRUPT', 'Plan Risk Audit rebound does not preserve the current Brief binding.');
+  }
+  const authorizedTaskRevision = reboundAudit.taskRevision + 1;
+  if (
+    (!allowTaskRevisionAdvance && authorizedTaskRevision !== task.revision)
+    || (allowTaskRevisionAdvance && authorizedTaskRevision > task.revision)
+  ) {
+    throw new WorkflowError('STATE_CORRUPT', 'Mechanical rebound audit does not bind the required Task authorization boundary.', {
+      reboundAuditTaskRevision: reboundAudit.taskRevision,
+      currentTaskRevision: task.revision,
+      allowTaskRevisionAdvance,
+    });
+  }
+  return { sourceAudit, reboundAudit };
+}
+
+function requireDirectRebind(
+  task: TaskState,
+  decision: CorrectiveDecisionEvent,
+  sourceAudit: PlanRiskAuditEvent,
+): TaskKnowledgeRebindRecord {
+  for (let index = 1; index < task.knowledgeRebinds.length; index += 1) {
+    if (Date.parse(task.knowledgeRebinds[index]!.recordedAt) <= Date.parse(task.knowledgeRebinds[index - 1]!.recordedAt)) {
+      throw new WorkflowError('STATE_CORRUPT', 'Task Knowledge rebind timestamps must be strictly increasing.');
+    }
+  }
+  const boundary = Math.max(Date.parse(decision.recordedAt), Date.parse(sourceAudit.recordedAt));
+  const afterBoundary = task.knowledgeRebinds.filter((record) => Date.parse(record.recordedAt) > boundary);
+  if (afterBoundary.length !== 1) {
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Legacy recovery requires exactly one Knowledge rebind after the decision/source-audit binding.', {
+      rebindCount: afterBoundary.length,
+    });
+  }
+  const selected = afterBoundary[0]!;
+  if (task.knowledgeRebinds.at(-1) !== selected || selected.previousPlanHash !== decision.planHash || selected.reboundPlanHash !== task.planHash) {
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Knowledge rebind provenance is not one direct decision-Plan to current-Plan hop.');
+  }
+  return selected;
+}
+
+function requireAppendOnlyRebindChain(
+  task: TaskState,
+  decision: CorrectiveDecisionEvent,
+  planRiskAudits: PlanRiskAuditEvent[],
+): TaskKnowledgeRebindRecord[] {
+  for (let index = 0; index < task.knowledgeRebinds.length; index += 1) {
+    const recordedAt = Date.parse(task.knowledgeRebinds[index]!.recordedAt);
+    if (
+      !Number.isFinite(recordedAt)
+      || (index > 0 && recordedAt <= Date.parse(task.knowledgeRebinds[index - 1]!.recordedAt))
+    ) {
+      throw new WorkflowError('STATE_CORRUPT', 'Task Knowledge rebind timestamps must be finite and strictly increasing.');
+    }
+  }
+  const sourceAudits = planRiskAudits.filter((event) => event.planHash === decision.planHash);
+  if (sourceAudits.length !== 1) {
+    throw new WorkflowError('STATE_CORRUPT', 'Append-only recovery requires one exact source Plan Risk Audit.', {
+      sourceAuditIds: sourceAudits.map((event) => event.eventId),
+    });
+  }
+  const boundary = Math.max(Date.parse(decision.recordedAt), Date.parse(sourceAudits[0]!.recordedAt));
+  if (!Number.isFinite(boundary)) {
+    throw new WorkflowError('STATE_CORRUPT', 'Stop decision or source Plan Risk Audit timestamp is invalid.');
+  }
+  const chain = task.knowledgeRebinds.filter((record) => Date.parse(record.recordedAt) > boundary);
+  if (chain.length < 1) {
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Stop-override continuation requires at least one Knowledge rebind after its source authority.');
+  }
+  if (task.knowledgeRebinds.at(-1) !== chain.at(-1)) {
+    throw new WorkflowError('STATE_CORRUPT', 'Append-only Knowledge rebind chain does not terminate at the current Task boundary.');
+  }
+  let expectedPlanHash = decision.planHash;
+  for (const record of chain) {
+    if (record.previousPlanHash !== expectedPlanHash || record.reboundPlanHash === record.previousPlanHash) {
+      throw new WorkflowError('TRANSITION_BLOCKED', 'Knowledge rebind provenance is not one contiguous source-to-current Plan chain.', {
+        expectedPreviousPlanHash: expectedPlanHash,
+        actualPreviousPlanHash: record.previousPlanHash,
+        reboundPlanHash: record.reboundPlanHash,
+      });
+    }
+    expectedPlanHash = record.reboundPlanHash;
+  }
+  if (expectedPlanHash !== task.planHash) {
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Knowledge rebind provenance does not terminate at the current Task Plan.', {
+      expectedCurrentPlanHash: task.planHash,
+      actualTerminalPlanHash: expectedPlanHash,
+    });
+  }
+  return chain;
+}
+
+function requireMechanicalAuditReboundChain(
+  task: TaskState,
+  decision: CorrectiveDecisionEvent,
+  events: PlanRiskAuditEvent[],
+  rebindChain: TaskKnowledgeRebindRecord[],
+): { sourceAudit: PlanRiskAuditEvent; reboundAudit: PlanRiskAuditEvent; auditChain: PlanRiskAuditEvent[] } {
+  const planHashes = [decision.planHash, ...rebindChain.map((record) => record.reboundPlanHash)];
+  const auditChain = planHashes.map((planHash) => {
+    const matches = events.filter((event) => event.planHash === planHash);
+    if (matches.length !== 1) {
+      throw new WorkflowError('STATE_CORRUPT', 'Append-only recovery requires one Plan Risk Audit for every Plan in the rebind chain.', {
+        planHash,
+        auditEventIds: matches.map((event) => event.eventId),
+      });
+    }
+    return matches[0]!;
+  });
+  const sourceIndex = events.indexOf(auditChain[0]!);
+  for (let index = 0; index < auditChain.length; index += 1) {
+    if (events[sourceIndex + index] !== auditChain[index]) {
+      throw new WorkflowError('STATE_CORRUPT', 'Plan Risk Audit rebind evidence is not one contiguous append-only chain.');
+    }
+    if (index > 0) assertMechanicalAuditSuccessor(task, auditChain[index - 1]!, auditChain[index]!);
+  }
+  if (sourceIndex < 0 || sourceIndex + auditChain.length !== events.length) {
+    throw new WorkflowError('STATE_CORRUPT', 'Plan Risk Audit rebind chain does not end at the current append-only boundary.');
+  }
+  const reboundAudit = auditChain.at(-1)!;
+  return { sourceAudit: auditChain[0]!, reboundAudit, auditChain };
+}
+
+function assertMechanicalAuditSuccessor(
+  task: TaskState,
+  sourceAudit: PlanRiskAuditEvent,
+  reboundAudit: PlanRiskAuditEvent,
+): void {
+  const expectedSummary = `${sourceAudit.summary} Rebound automatically after content-only Task context refresh.`;
+  if (
+    reboundAudit.previousEventHash !== sourceAudit.eventHash
+    || reboundAudit.taskId !== sourceAudit.taskId
+    || reboundAudit.briefHash !== sourceAudit.briefHash
+    || reboundAudit.briefHash !== task.briefHash
+    || reboundAudit.planner !== sourceAudit.planner
+    || reboundAudit.auditor !== sourceAudit.auditor
+    || reboundAudit.decision !== sourceAudit.decision
+    || reboundAudit.splitRationale !== sourceAudit.splitRationale
+    || reboundAudit.summary !== expectedSummary
+    || canonicalJsonStringify(reboundAudit.stepClassifications) !== canonicalJsonStringify(sourceAudit.stepClassifications)
+  ) {
+    throw new WorkflowError('STATE_CORRUPT', 'Plan Risk Audit successor is not a mechanical content-refresh rebound.');
+  }
+}
+
+function requireStopOverrideHeadContinuity(
+  repositoryRoot: string,
+  task: TaskState,
+  override: StopEscalateOverrideEvent,
+  authorization: AuthorizationEvent,
+): DependencyProvenanceRecoveryRecord[] {
+  const authorizedHead = authorization.headCommit;
+  if (!authorizedHead) {
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Current execution authorization does not bind a Git HEAD.');
+  }
+  if (authorizedHead === override.headCommit) return [];
+  if (!gitIsAncestor(repositoryRoot, override.headCommit, authorizedHead)) {
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Current execution HEAD is not an append-only descendant of the stop-override HEAD.', {
+      overrideHeadCommit: override.headCommit,
+      authorizedHeadCommit: authorizedHead,
+    });
+  }
+  const output = runGit(repositoryRoot, ['rev-list', '--reverse', `${override.headCommit}..${authorizedHead}`]);
+  const commits = output ? output.split('\n') : [];
+  if (commits.length < 1) {
+    throw new WorkflowError('STATE_CORRUPT', 'Git reports distinct stop-override and authorization HEADs without an intervening commit.');
+  }
+  let expectedParent = override.headCommit;
+  let previousRecoveryIndex = -1;
+  let previousRecoveryAt = Number.NEGATIVE_INFINITY;
+  const verifiedRecoveries: DependencyProvenanceRecoveryRecord[] = [];
+  for (const commit of commits) {
+    const matches = (task.dependencyProvenanceRecoveries ?? []).filter((record) => record.commitSha === commit);
+    if (matches.length !== 1) {
+      throw new WorkflowError('TRANSITION_BLOCKED', 'Git HEAD advanced through a commit without one exact dependency-provenance recovery.', {
+        commit,
+        recoveryCount: matches.length,
+      });
+    }
+    const recovery = matches[0]!;
+    const recoveryIndex = (task.dependencyProvenanceRecoveries ?? []).indexOf(recovery);
+    const recoveryAt = Date.parse(recovery.recordedAt);
+    const parents = runGit(repositoryRoot, ['show', '-s', '--format=%P', commit]).split(/\s+/).filter(Boolean);
+    const filesOutput = runGit(repositoryRoot, ['diff-tree', '--no-commit-id', '--name-only', '-r', commit]);
+    const files = filesOutput ? filesOutput.split('\n').sort() : [];
+    if (
+      parents.length !== 1
+      || parents[0] !== expectedParent
+      || recovery.parentCommitSha !== expectedParent
+      || recoveryIndex <= previousRecoveryIndex
+      || !Number.isFinite(recoveryAt)
+      || recoveryAt <= previousRecoveryAt
+      || recovery.packageName !== PACKAGE_NAME
+      || canonicalJsonStringify(recovery.files) !== canonicalJsonStringify(['package-lock.json', 'package.json'])
+      || canonicalJsonStringify(files) !== canonicalJsonStringify(['package-lock.json', 'package.json'])
+      || !task.systemCommits.includes(commit)
+    ) {
+      throw new WorkflowError('TRANSITION_BLOCKED', 'Dependency-only Git continuity from stop override to current authorization is invalid.', {
+        commit,
+        expectedParent,
+        recordedParent: recovery.parentCommitSha,
+        parents,
+        files,
+      });
+    }
+    verifiedRecoveries.push(recovery);
+    previousRecoveryIndex = recoveryIndex;
+    previousRecoveryAt = recoveryAt;
+    expectedParent = commit;
+  }
+  if (expectedParent !== authorizedHead) {
+    throw new WorkflowError('STATE_CORRUPT', 'Dependency-provenance Git chain does not terminate at the authorized HEAD.');
+  }
+  return verifiedRecoveries;
+}
+
+function requireEvidenceBoundAuditTaskRevision(
+  task: TaskState,
+  reboundAudit: PlanRiskAuditEvent,
+  verifiedHeadRecoveries: DependencyProvenanceRecoveryRecord[],
+  allowTaskRevisionAdvance: boolean,
+): void {
+  const auditAt = Date.parse(reboundAudit.recordedAt);
+  if (!Number.isFinite(auditAt)) {
+    throw new WorkflowError('STATE_CORRUPT', 'Current rebound Plan Risk Audit timestamp is invalid.');
+  }
+  const postAuditRecoveries = verifiedHeadRecoveries.filter(
+    (recovery) => Date.parse(recovery.recordedAt) > auditAt,
+  );
+  const evidenceBoundTaskRevision = reboundAudit.taskRevision + 1 + postAuditRecoveries.length;
+  if (
+    (!allowTaskRevisionAdvance && evidenceBoundTaskRevision !== task.revision)
+    || (allowTaskRevisionAdvance && evidenceBoundTaskRevision > task.revision)
+  ) {
+    throw new WorkflowError('STATE_CORRUPT', 'Mechanical rebound audit chain does not bind the evidence-accounted Task authorization boundary.', {
+      reboundAuditTaskRevision: reboundAudit.taskRevision,
+      currentTaskRevision: task.revision,
+      postAuditDependencyRecoveryCommits: postAuditRecoveries.map((recovery) => recovery.commitSha),
+      evidenceBoundTaskRevision,
+      allowTaskRevisionAdvance,
+    });
+  }
+}
+
+function assertRebindMatchesPlans(
+  rebind: TaskKnowledgeRebindRecord,
+  plans: {
+    decisionBinding: { revision: number; hash: string };
+    reboundBinding: { revision: number; hash: string };
+  },
+): void {
+  if (
+    rebind.fromKnowledgeMapRevision !== plans.decisionBinding.revision
+    || rebind.fromKnowledgeMapHash !== plans.decisionBinding.hash
+    || rebind.toKnowledgeMapRevision !== plans.reboundBinding.revision
+    || rebind.toKnowledgeMapHash !== plans.reboundBinding.hash
+  ) {
+    throw new WorkflowError('STATE_CORRUPT', 'Direct Knowledge rebind does not match the two verified Plan artifacts.');
+  }
+}
+
+function requireRefreshAuthorization(task: TaskState): AuthorizationEvent {
+  const matches = task.authorizations.filter((authorization) =>
+    authorization.kind === 'execution'
+    && authorization.decision === 'approved'
+    && authorization.planHash === task.planHash
+    && authorization.briefHash === task.briefHash,
+  );
+  if (matches.length !== 1) {
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Recovery requires one exact current execution authorization.', {
+      taskId: task.id,
+      authorizationCount: matches.length,
+    });
+  }
+  const authorization = matches[0]!;
+  if (
+    authorization.authorizationMode !== 'delegated'
+    || !authorization.delegation
+    || authorization.delegation.transition !== 'task.execution_authorize'
+    || !REFRESH_REASONS.has(authorization.reason)
+  ) {
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Current execution authorization is not confirmed delegated context-refresh evidence.');
+  }
+  return authorization;
+}
+
+function requireRefreshAuthority(
+  store: FileStateStore,
+  task: TaskState,
+  map: ProjectKnowledgeMap,
+  authorization: AuthorizationEvent,
+  rebind: TaskKnowledgeRebindRecord,
+): { grant: DelegationGrant; autonomyContract: MilestoneAutonomyEvent | null } {
+  const approval = map.approval;
+  const taskDelegation = authorization.delegation!;
+  if (
+    map.status !== 'active'
+    || !approval
+    || map.revision !== task.knowledgeMapRevision
+    || hashKnowledgeMap(map) !== task.knowledgeMapHash
+    || approval.mapHash !== task.knowledgeMapHash
+    || approval.authorizationMode !== 'delegated'
+    || !approval.delegation
+    || approval.delegation.transition !== 'project_memory.approve'
+  ) {
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Current Knowledge Map is not the delegated approved direct-rebind target.');
+  }
+  const mapDelegation = approval.delegation;
+  if (
+    approval.actor !== authorization.actor
+    || mapDelegation.grantId !== taskDelegation.grantId
+    || mapDelegation.policyHash !== taskDelegation.policyHash
+    || mapDelegation.principal !== taskDelegation.principal
+    || mapDelegation.delegate !== taskDelegation.delegate
+  ) {
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Knowledge Map and Task authorization do not share one delegated identity.');
+  }
+  const grant = store.readDelegation(task.projectId, taskDelegation.grantId);
+  const expectedPolicyHash = hashDelegationPolicy(grant.projectId, {
+    principal: grant.principal,
+    delegate: grant.delegate,
+    scope: grant.scope,
+    transitions: grant.transitions,
+    expiresAt: grant.expiresAt,
+  });
+  const autonomyContract = requireRefreshGrantScope(store, task, grant);
+  if (
+    grant.policyHash !== expectedPolicyHash
+    || grant.policyHash !== taskDelegation.policyHash
+    || grant.principal !== taskDelegation.principal
+    || grant.delegate !== taskDelegation.delegate
+    || approval.actor !== grant.delegate
+    || authorization.actor !== grant.delegate
+    || grant.status !== 'active'
+    || grant.revokedAt !== null
+    || !grant.transitions.includes('project_memory.approve')
+    || !grant.transitions.includes('task.execution_authorize')
+  ) {
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Delegation evidence is revoked, corrupt, mismatched, or insufficient for recovery.');
+  }
+  const createdAt = Date.parse(grant.createdAt);
+  const expiresAt = Date.parse(grant.expiresAt);
+  const approvalAt = Date.parse(approval.approvedAt);
+  const authorizationAt = Date.parse(authorization.recordedAt);
+  if (
+    ![createdAt, expiresAt, approvalAt, authorizationAt].every(Number.isFinite)
+    || approvalAt < createdAt
+    || authorizationAt < createdAt
+    || approvalAt >= expiresAt
+    || authorizationAt >= expiresAt
+  ) {
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Delegated context-refresh approvals were not recorded inside the historical grant validity window.');
+  }
+  if (
+    rebind.toKnowledgeMapRevision !== map.revision
+    || rebind.toKnowledgeMapHash !== approval.mapHash
+  ) {
+    throw new WorkflowError('STATE_CORRUPT', 'Knowledge Map approval does not bind the direct rebind target.');
+  }
+  return { grant, autonomyContract };
+}
+
+function requireRefreshGrantScope(
+  store: FileStateStore,
+  task: TaskState,
+  grant: DelegationGrant,
+): MilestoneAutonomyEvent | null {
+  if (grant.scope.kind === 'project') return null;
+  if (grant.scope.kind !== 'milestone' || grant.scope.id !== task.milestoneId) {
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Delegation scope cannot authorize the Knowledge Map refresh target.');
+  }
+  const contracts = readMilestoneAutonomyEvents(store, task.projectId, grant.scope.id);
+  const matches = contracts.filter((contract) =>
+    contract.delegationGrantId === grant.id
+    && contract.delegationPolicyHash === grant.policyHash
+    && contract.principal === grant.principal
+    && contract.delegate === grant.delegate
+    && contract.expiresAt === grant.expiresAt,
+  );
+  if (matches.length !== 1) {
+    throw new WorkflowError(
+      'TRANSITION_BLOCKED',
+      'Milestone-scoped context-refresh authority requires one exact alpha7 autonomy contract.',
+      { grantId: grant.id, contractCount: matches.length },
+    );
+  }
+  return matches[0]!;
+}
+
+function requireC1Evidence(
+  store: FileStateStore,
+  task: TaskState,
+  actor: string,
+  writerToken: string | null,
+): { posture: string; claimEventHash: string | null; owner: string | null; tokenHash: string | null } {
+  const posture = readTaskC1Posture(store, task);
+  const lease = readWriterLease(store, task);
+  if (posture.state === 'pending') {
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Pending C1 handoff must be claimed before corrective recovery.');
+  }
+  if (posture.state === 'claimed') {
+    const tokenHash = writerToken ? sha256Hex(writerToken) : null;
+    if (
+      !lease
+      || actor !== posture.claimant
+      || lease.owner !== posture.claimant
+      || !writerToken
+      || lease.token !== writerToken
+      || tokenHash !== posture.writerLeaseTokenHash
+    ) {
+      throw new WorkflowError('TRANSITION_BLOCKED', 'Corrective recovery requires the claimed C1 actor and exact bound writer lease token.', {
+        taskId: task.id,
+        claimant: posture.claimant,
+        leaseOwner: lease?.owner ?? null,
+      });
+    }
+    return { posture: 'claimed', claimEventHash: posture.latestEvent.eventHash, owner: lease.owner, tokenHash };
+  }
+  if (lease && (lease.owner !== actor || !writerToken || lease.token !== writerToken)) {
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Existing writer lease is not owned by the recovering actor/token.');
+  }
+  return {
+    posture: 'none',
+    claimEventHash: posture.latestEvent?.eventHash ?? null,
+    owner: lease?.owner ?? null,
+    tokenHash: lease ? sha256Hex(lease.token) : null,
+  };
+}
+
+function readWriterLease(store: FileStateStore, task: TaskState): WriterLease | null {
+  const file = path.join(store.lockRoot(task.projectId), `${task.id}.json`);
+  if (!existsSync(file)) return null;
+  let lease: WriterLease;
+  try {
+    lease = JSON.parse(readFileSync(file, 'utf8')) as WriterLease;
+  } catch {
+    throw new WorkflowError('STATE_CORRUPT', `Writer lease is unreadable: ${file}`);
+  }
+  if (lease.entityId !== task.id || typeof lease.owner !== 'string' || typeof lease.token !== 'string') {
+    throw new WorkflowError('STATE_CORRUPT', `Writer lease does not match Task ${task.id}.`);
+  }
+  return lease;
+}
+
+function assertRefreshChronology(
+  map: ProjectKnowledgeMap,
+  authorization: AuthorizationEvent,
+  rebind: TaskKnowledgeRebindRecord,
+  reboundAudit: PlanRiskAuditEvent,
+): void {
+  const values = [
+    Date.parse(map.approval!.approvedAt),
+    Date.parse(rebind.recordedAt),
+    Date.parse(reboundAudit.recordedAt),
+    Date.parse(authorization.recordedAt),
+  ];
+  if (values.some((value) => !Number.isFinite(value)) || values.some((value, index) => index > 0 && value < values[index - 1]!)) {
+    throw new WorkflowError('STATE_CORRUPT', 'Context-refresh evidence chronology is invalid.');
+  }
+}
+
+function assertRecoveryMatchesAssessment(
+  event: CorrectiveDecisionRecoveryEvent,
+  assessment: CorrectiveRecoveryAssessment,
+  actor: string,
+): void {
+  const expected = recoveryPayload(assessment, actor, new Date(event.recordedAt));
+  const ignored = new Set(['eventId', 'recordedAt']);
+  const mismatches = Object.entries(expected)
+    .filter(([key, value]) => !ignored.has(key) && event[key as keyof CorrectiveDecisionRecoveryEvent] !== value)
+    .map(([key]) => key);
+  if (mismatches.length > 0) {
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Corrective recovery event is stale or conflicts with current evidence.', {
+      taskId: event.taskId,
+      stepId: event.stepId,
+      eventId: event.eventId,
+      mismatches,
+    });
+  }
+}
+
+function validateRecoveryEvent(
+  event: CorrectiveDecisionRecoveryEvent,
+  task: TaskState,
+  file: string,
+  line: number,
+): void {
+  if (!/^CDR-[0-9A-HJKMNP-TV-Z]{26}$/.test(event.eventId) || event.taskId !== task.id) {
+    throw new WorkflowError('STATE_CORRUPT', 'Corrective recovery event identity is invalid.', { file, line });
+  }
+  if (typeof event.stepId !== 'string' || !event.stepId || event.triggeringAttemptCount !== 3) {
+    throw new WorkflowError('STATE_CORRUPT', 'Corrective recovery Step/ordinal binding is invalid.', { file, line });
+  }
+  const hashes = [
+    event.correctiveDecisionEventHash,
+    event.decisionPlanHash,
+    event.reboundPlanHash,
+    event.semanticPlanHash,
+    event.fromKnowledgeMapHash,
+    event.toKnowledgeMapHash,
+    event.sourcePlanRiskAuditEventHash,
+    event.reboundPlanRiskAuditEventHash,
+    event.knowledgeMapApprovalFingerprint,
+    event.taskAuthorizationFingerprint,
+    event.delegationGrantFingerprint,
+    event.c1EvidenceFingerprint,
+    event.evidenceFingerprint,
+  ];
+  for (const hash of hashes) assertHash64(hash, `Corrective recovery hash at ${file}:${line}`);
+  if (
+    !Number.isInteger(event.fromKnowledgeMapRevision)
+    || event.fromKnowledgeMapRevision < 1
+    || !Number.isInteger(event.toKnowledgeMapRevision)
+    || event.toKnowledgeMapRevision < 1
+    || typeof event.actor !== 'string'
+    || !event.actor.trim()
+  ) {
+    throw new WorkflowError('STATE_CORRUPT', 'Corrective recovery payload is malformed.', { file, line });
+  }
+}
+
+export function readValidatedCorrectiveDecisionRecoveryForNavigation(
+  store: FileStateStore,
+  task: TaskState,
+  stepId: string,
+): { assessment: CorrectiveRecoveryAssessment; recovery: CorrectiveDecisionRecoveryEvent | null } {
+  const posture = readTaskC1Posture(store, task);
+  const lease = readWriterLease(store, task);
+  const actor = posture.state === 'claimed' ? posture.claimant : lease?.owner ?? 'worker';
+  const assessment = assessCorrectiveDecisionRecovery(store, task, stepId, actor, lease?.token ?? null);
+  const matches = readCorrectiveDecisionRecoveryEvents(store, task).filter((event) =>
+    event.correctiveDecisionEventId === assessment.decision.eventId
+    && event.stepId === stepId
+    && event.triggeringAttemptCount === assessment.decision.triggeringAttemptCount,
+  );
+  if (matches.length > 1) {
+    throw new WorkflowError('STATE_CORRUPT', 'Multiple recoveries exist for one corrective decision binding.');
+  }
+  const recovery = matches[0] ?? null;
+  if (recovery) assertRecoveryMatchesAssessment(recovery, assessment, actor);
+  return { assessment, recovery };
+}
+
+export function assertKnowledgeBindingOnlyPlanChange(historical: string, current: string): string {
+  const decision = normalizePlanKnowledgeBinding(historical, 'historical');
+  const rebound = normalizePlanKnowledgeBinding(current, 'current');
+  if (decision.normalized !== rebound.normalized) {
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Corrective recovery permits only the Knowledge Map binding line to change.');
+  }
+  return sha256Hex(decision.normalized);
+}