codex-workflow-v2 2.0.0-beta.13.14 → 2.0.0-beta.13.16

package/src/alpha6/remediation.ts

@@ -0,0 +1,2965 @@
+import { closeSync, existsSync, openSync, readFileSync, unlinkSync } from 'node:fs';
+import path from 'node:path';
+import type {
+  CorrectiveDecisionEvent,
+  CorrectiveDecisionRecoveryEvent,
+  CorrectivePlanAuditInput,
+  GuardedRiskCategory,
+  PlanIntegrityConflictEvidence,
+  PlanRiskAuditEvent,
+  RemediationEvent,
+  RemediationCauseBinding,
+  RemediationFailureEvidence,
+  RemediationFailureKind,
+  RemediationMode,
+  RemediationModeRecoveryEvent,
+  StopEscalateOverrideEvent,
+  StopEscalateOverridePreparation,
+  TaskState,
+  WriterLease,
+} from '../contracts.js';
+import { assertKnowledgeBindingOnlyPlanChange, normalizePlanKnowledgeBinding, readVerifiedPlanArtifact } from '../domain/plan-semantics.js';
+import { pathAllowed } from '../domain/validation.js';
+import { WorkflowError } from '../errors.js';
+import { hashCanonical } from '../lifecycle/fingerprint.js';
+import type { FileStateStore } from '../state/store.js';
+import { createUlid } from '../ulid.js';
+import { PACKAGE_VERSION } from '../version.js';
+import { readPlanRiskAuditEvents, type CurrentPlanRiskAudit } from './plan-risk.js';
+import {
+  assertHash64,
+  canonicalJsonStringify,
+  prepareSidecarAppend,
+  sha256Hex,
+} from './store-sidecars.js';
+import { readTaskC1Posture } from './handoff.js';
+import {
+  buildCurrentStrictStepReviewCycle,
+  latestPassedVerifiedStepReviewEvent,
+  readReviewerAttestations,
+  readStepReviewEvents,
+} from './review.js';
+import { correctiveReplanBoundaryMatchesStep, readCompletedCorrectiveReplanHistory } from '../state/corrective-replan-executor.js';
+import { semanticBoundaryHash, validLiteralTestInvocationEvidence } from './component-owner.js';
+import { reviewerCauseFingerprint } from './remediation-cause.js';
+
+export const REMEDIATION_EVENTS_SIDECAR = 'remediation-events.jsonl';
+export const CORRECTIVE_DECISIONS_SIDECAR = 'corrective-decisions.jsonl';
+export const CORRECTIVE_DECISION_RECOVERIES_SIDECAR = 'corrective-decision-recoveries.jsonl';
+export const REMEDIATION_MODE_RECOVERIES_SIDECAR = 'remediation-mode-recoveries.jsonl';
+export const STOP_ESCALATE_OVERRIDES_SIDECAR = 'stop-escalate-overrides.jsonl';
+const REMEDIATION_MODE_RECOVERY_LOCK = '.remediation-mode-recovery.lock';
+const STOP_ESCALATE_OVERRIDE_LOCK = '.stop-escalate-override.lock';
+const LEGACY_STOP_OVERRIDE_POLICY = 'beta11-attempt4-stop-compatibility-v1' as const;
+
+const COMMIT_SHA_PATTERN = /^[a-f0-9]{40}$/;
+const REMEDIATION_FAILURE_KINDS = new Set<RemediationFailureKind>([
+  'checks-failed',
+  'review-failed',
+  'review-unverified',
+]);
+const REMEDIATION_MODES = new Set<RemediationMode>(['ordinary', 'corrective']);
+const CORRECTIVE_DECISION_VALUES = new Set<CorrectiveDecisionEvent['decision']>([
+  'continue-fix',
+  'replan-required',
+  'split-required',
+  'stop-escalate',
+]);
+
+export interface GuardedRemediationAttemptGate {
+  stepId: string;
+  guardedCategory: GuardedRiskCategory;
+  attemptCount: number;
+  nextAttemptOrdinal: number;
+  mode: RemediationMode;
+  correctiveDecision: CorrectiveDecisionEvent | null;
+  posture:
+    | 'ordinary'
+    | 'decision-required'
+    | 'continue-fix'
+    | 'replan-required'
+    | 'replan-ready'
+    | 'split-required'
+    | 'stop-escalate';
+}
+
+export interface RemediationModeRecoveryAssessment {
+  task: TaskState;
+  remediation: RemediationEvent;
+  decision: CorrectiveDecisionEvent;
+  correctiveRecovery: CorrectiveDecisionRecoveryEvent;
+  existingRecovery: RemediationModeRecoveryEvent | null;
+  actor: string;
+  c1ClaimEventHash: string | null;
+  writerLeaseTokenHash: string | null;
+  evidenceFingerprint: string;
+}
+
+export interface PreparedRemediationEvent {
+  event: RemediationEvent;
+  postimage: string | null;
+}
+
+export function readRemediationEvents(
+  store: FileStateStore,
+  task: TaskState,
+): RemediationEvent[] {
+  return validateRemediationHistory(store, task).remediationEvents;
+}
+
+export function readCorrectiveDecisionEvents(
+  store: FileStateStore,
+  task: TaskState,
+): CorrectiveDecisionEvent[] {
+  return validateRemediationHistory(store, task).correctiveDecisionEvents;
+}
+
+export function defaultCorrectiveAuditorActor(taskId: string): string {
+  if (!/^TASK-[0-9A-HJKMNP-TV-Z]{26}$/.test(taskId)) {
+    throw new WorkflowError('INVALID_ARGUMENT', `Cannot derive a corrective Auditor actor from invalid Task ID ${taskId}.`);
+  }
+  return `agent:corrective-auditor:${taskId.toLowerCase()}`;
+}
+
+export function assertCorrectiveAuditorIndependence(
+  store: FileStateStore,
+  task: TaskState,
+  stepId: string,
+  auditor: string,
+): void {
+  const remediationEvents = readRemediationEvents(store, task).filter((event) => event.stepId === stepId);
+  const latestRemediationEvent = remediationEvents.at(-1) ?? null;
+  if (!latestRemediationEvent || latestRemediationEvent.failureKind === 'checks-failed') return;
+  const reviewerAttestationHash = latestRemediationEvent.failureEvidence.reviewerAttestationHash;
+  if (!reviewerAttestationHash) {
+    throw new WorkflowError('STATE_CORRUPT', 'Latest guarded remediation event is missing its strict-review attestation binding.', {
+      taskId: task.id,
+      stepId,
+      eventId: latestRemediationEvent.eventId,
+    });
+  }
+  const attestation = readReviewerAttestations(store, task)
+    .find((event) => event.eventHash === reviewerAttestationHash) ?? null;
+  if (!attestation) {
+    throw new WorkflowError('STATE_CORRUPT', 'Latest guarded remediation event references a missing reviewer attestation.', {
+      taskId: task.id,
+      stepId,
+      reviewerAttestationHash,
+    });
+  }
+  if (attestation.reviewer.trim() === auditor.trim()) {
+    throw new WorkflowError('TRANSITION_BLOCKED', `Corrective decision for ${stepId} must be recorded by an auditor distinct from the latest strict reviewer.`, {
+      taskId: task.id,
+      stepId,
+      reviewer: attestation.reviewer,
+      auditor: auditor.trim(),
+    });
+  }
+}
+
+function validateRemediationHistory(
+  store: FileStateStore,
+  task: TaskState,
+): {
+  remediationEvents: RemediationEvent[];
+  correctiveDecisionEvents: CorrectiveDecisionEvent[];
+} {
+  const remediationEvents = readRawRemediationEvents(store, task);
+  const correctiveDecisionEvents = readRawCorrectiveDecisionEvents(store, task);
+  const modeRecoveries = readRemediationModeRecoveryEvents(store, task);
+  const overriddenStopDecisionEventIds = validateStopEscalateOverrideHistory(
+    task,
+    remediationEvents,
+    correctiveDecisionEvents,
+    readRawStopEscalateOverrideEvents(store, task),
+  );
+  validateRemediationAttemptOrdinals(remediationEvents, task);
+  validateRemediationReviewReferences(store, task, remediationEvents);
+  validateCorrectiveDecisionCoverage(store, task, correctiveDecisionEvents, remediationEvents);
+  const recoveredEventIds = validateRemediationModeRecoveries(
+    store,
+    task,
+    remediationEvents,
+    correctiveDecisionEvents,
+    modeRecoveries,
+  );
+  validateHistoricalRemediationModesForAllSteps(
+    store,
+    task,
+    remediationEvents,
+    correctiveDecisionEvents,
+    recoveredEventIds,
+    overriddenStopDecisionEventIds,
+  );
+  return {
+    remediationEvents,
+    correctiveDecisionEvents,
+  };
+}
+
+export function readRemediationModeRecoveryEvents(
+  store: FileStateStore,
+  task: TaskState,
+): RemediationModeRecoveryEvent[] {
+  const root = store.taskRoot(task.projectId, task.id);
+  const file = path.join(root, REMEDIATION_MODE_RECOVERIES_SIDECAR);
+  if (!existsSync(file)) return [];
+  return store.readSidecarEvents<RemediationModeRecoveryEvent>(root, REMEDIATION_MODE_RECOVERIES_SIDECAR, {
+    validateEvent: (event, context) => validateStoredRemediationModeRecovery(event, task, context.file, context.line),
+  });
+}
+
+function readRawCorrectiveDecisionRecoveries(
+  store: FileStateStore,
+  task: TaskState,
+): CorrectiveDecisionRecoveryEvent[] {
+  const root = store.taskRoot(task.projectId, task.id);
+  const file = path.join(root, CORRECTIVE_DECISION_RECOVERIES_SIDECAR);
+  if (!existsSync(file)) return [];
+  return store.readSidecarEvents<CorrectiveDecisionRecoveryEvent>(root, CORRECTIVE_DECISION_RECOVERIES_SIDECAR, {
+    validateEvent: (event, context) => validateStoredCorrectiveDecisionRecoveryReference(event, task, context.file, context.line),
+  });
+}
+
+function readRawRemediationEvents(
+  store: FileStateStore,
+  task: TaskState,
+): RemediationEvent[] {
+  const sidecarFile = path.join(store.taskRoot(task.projectId, task.id), REMEDIATION_EVENTS_SIDECAR);
+  if (!existsSync(sidecarFile)) return [];
+  return store.readSidecarEvents<RemediationEvent>(
+    store.taskRoot(task.projectId, task.id),
+    REMEDIATION_EVENTS_SIDECAR,
+    {
+      validateEvent: (event, context) => validateStoredRemediationEvent(event, task, context.file, context.line),
+    },
+  );
+}
+
+function readRawCorrectiveDecisionEvents(
+  store: FileStateStore,
+  task: TaskState,
+): CorrectiveDecisionEvent[] {
+  const sidecarFile = path.join(store.taskRoot(task.projectId, task.id), CORRECTIVE_DECISIONS_SIDECAR);
+  if (!existsSync(sidecarFile)) return [];
+  return store.readSidecarEvents<CorrectiveDecisionEvent>(
+    store.taskRoot(task.projectId, task.id),
+    CORRECTIVE_DECISIONS_SIDECAR,
+    {
+      validateEvent: (event, context) => validateStoredCorrectiveDecisionEvent(event, task, context.file, context.line),
+    },
+  );
+}
+
+function readRawStopEscalateOverrideEvents(
+  store: FileStateStore,
+  task: TaskState,
+): StopEscalateOverrideEvent[] {
+  const root = store.taskRoot(task.projectId, task.id);
+  const sidecarFile = path.join(root, STOP_ESCALATE_OVERRIDES_SIDECAR);
+  if (!existsSync(sidecarFile)) return [];
+  return store.readSidecarEvents<StopEscalateOverrideEvent>(root, STOP_ESCALATE_OVERRIDES_SIDECAR, {
+    validateEvent: (event, context) => validateStoredStopEscalateOverride(event, task, context.file, context.line),
+  });
+}
+
+export function readStopEscalateOverrideEvents(
+  store: FileStateStore,
+  task: TaskState,
+): StopEscalateOverrideEvent[] {
+  const remediations = readRawRemediationEvents(store, task);
+  const decisions = readRawCorrectiveDecisionEvents(store, task);
+  const overrides = readRawStopEscalateOverrideEvents(store, task);
+  validateRemediationAttemptOrdinals(remediations, task);
+  validateCorrectiveDecisionCoverage(store, task, decisions, remediations);
+  validateStopEscalateOverrideHistory(task, remediations, decisions, overrides);
+  return overrides;
+}
+
+export function stopEscalateOverrideDecisionEventIds(
+  store: FileStateStore,
+  task: TaskState,
+): ReadonlySet<string> {
+  const remediations = readRawRemediationEvents(store, task);
+  const decisions = readRawCorrectiveDecisionEvents(store, task);
+  const overrides = readRawStopEscalateOverrideEvents(store, task);
+  validateRemediationAttemptOrdinals(remediations, task);
+  validateCorrectiveDecisionCoverage(store, task, decisions, remediations);
+  return validateStopEscalateOverrideHistory(task, remediations, decisions, overrides);
+}
+
+export function appendRemediationEvent(
+  store: FileStateStore,
+  task: TaskState,
+  stepId: string,
+  failureKind: RemediationFailureKind,
+  failureEvidence: RemediationFailureEvidence,
+  planRiskAudit: CurrentPlanRiskAudit,
+  now: Date,
+  reboundStopOverrideDecisionEventId: string | null = null,
+  causeBindings: readonly RemediationCauseBinding[] = [],
+): RemediationEvent {
+  const prepared = prepareRemediationEvent(
+    store,
+    task,
+    stepId,
+    failureKind,
+    failureEvidence,
+    planRiskAudit,
+    now,
+    reboundStopOverrideDecisionEventId,
+    causeBindings,
+  );
+  if (prepared.postimage === null) return prepared.event;
+  return store.appendSidecarEvent<RemediationEvent>(
+    store.taskRoot(task.projectId, task.id),
+    REMEDIATION_EVENTS_SIDECAR,
+    prepared.event,
+    {
+      validateEvent: (event, context) => validateStoredRemediationEvent(event, task, context.file, context.line),
+    },
+  );
+}
+
+export function prepareRemediationEvent(
+  store: FileStateStore,
+  task: TaskState,
+  stepId: string,
+  failureKind: RemediationFailureKind,
+  failureEvidence: RemediationFailureEvidence,
+  planRiskAudit: CurrentPlanRiskAudit,
+  now: Date,
+  reboundStopOverrideDecisionEventId: string | null = null,
+  causeBindings: readonly RemediationCauseBinding[] = [],
+): PreparedRemediationEvent {
+  const recoveredDecisionEventId = findCorrectiveRecoveryDecisionIdForFailure(store, task, stepId);
+  const allExisting = readRemediationEvents(store, task);
+  const existing = allExisting.filter((event) => event.stepId === stepId);
+  const correctiveDecisions = readCorrectiveDecisionEvents(store, task);
+  const matching = existing.filter((event) => remediationEventMatchesFailure(event, failureKind, failureEvidence));
+  if (matching.length > 1) {
+    throw new WorkflowError('STATE_CORRUPT', 'Multiple remediation events match the same failure identity.', {
+      taskId: task.id,
+      stepId,
+      failureKind,
+      matchingEventIds: matching.map((event) => event.eventId),
+    });
+  }
+  if (matching.length === 1) {
+    const reused = matching[0]!;
+    if (canonicalJsonStringify(reused.failureEvidence) !== canonicalJsonStringify(failureEvidence)) {
+      throw new WorkflowError('STATE_CONFLICT', 'Remediation failure evidence changed within the same execution identity.', {
+        taskId: task.id,
+        stepId,
+        eventId: reused.eventId,
+        executionTaskRevision: failureEvidence.executionTaskRevision ?? null,
+      });
+    }
+    const priorEvents = existing.filter((event) => event.attemptOrdinal < reused.attemptOrdinal);
+    const cycle = selectCurrentPlanRemediationCycle(store, task, priorEvents, correctiveDecisions);
+    const gate = deriveAttemptGateFromHistory(store, task, stepId, planRiskAudit, cycle.remediationEvents, cycle.correctiveDecisions, {
+      recoveredDecisionEventId,
+      reboundStopOverrideDecisionEventId,
+      overriddenStopDecisionEventIds: stopEscalateOverrideDecisionEventIds(store, task),
+      priorRemediationEvents: cycle.priorRemediationEvents,
+      nextAttemptOrdinal: reused.attemptOrdinal,
+    });
+    if (reused.attemptOrdinal !== gate.nextAttemptOrdinal || reused.mode !== gate.mode || reused.guardedCategory !== gate.guardedCategory) {
+      throw new WorkflowError('STATE_CORRUPT', 'Existing remediation event conflicts with the current guarded retry binding.', {
+        taskId: task.id,
+        stepId,
+        eventId: reused.eventId,
+        expectedAttemptOrdinal: gate.nextAttemptOrdinal,
+        actualAttemptOrdinal: reused.attemptOrdinal,
+        expectedMode: gate.mode,
+        actualMode: reused.mode,
+      });
+    }
+    return { event: reused, postimage: null };
+  }
+  const cycle = selectCurrentPlanRemediationCycle(store, task, existing, correctiveDecisions);
+  const gate = deriveAttemptGateFromHistory(store, task, stepId, planRiskAudit, cycle.remediationEvents, cycle.correctiveDecisions, {
+    recoveredDecisionEventId,
+    reboundStopOverrideDecisionEventId,
+    overriddenStopDecisionEventIds: stopEscalateOverrideDecisionEventIds(store, task),
+    priorRemediationEvents: cycle.priorRemediationEvents,
+    nextAttemptOrdinal: existing.length + 1,
+  });
+  const prepared = prepareSidecarAppend<RemediationEvent>(
+    allExisting,
+    {
+      eventId: `RME-${createUlid(now.getTime())}`,
+      recordedAt: now.toISOString(),
+      taskId: task.id,
+      stepId,
+      guardedCategory: gate.guardedCategory,
+      failureKind,
+      failureEvidence,
+      attemptOrdinal: gate.nextAttemptOrdinal,
+      mode: gate.mode,
+      causeBindings: causeBindings.map((binding) => ({ ...binding })),
+    }, {
+      validateEvent: (event, context) => validateStoredRemediationEvent(event, task, context.file, context.line),
+    },
+  );
+  return { event: prepared.event, postimage: prepared.content };
+}
+
+function findCorrectiveRecoveryDecisionIdForFailure(
+  store: FileStateStore,
+  task: TaskState,
+  stepId: string,
+): string | null {
+  const remediations = readRawRemediationEvents(store, task).filter((event) => event.stepId === stepId);
+  if (remediations.length !== 2) return null;
+  const decisions = readRawCorrectiveDecisionEvents(store, task).filter((event) =>
+    event.stepId === stepId
+    && event.triggeringAttemptCount === 3
+    && event.decision === 'continue-fix'
+    && event.planHash !== task.planHash,
+  );
+  if (decisions.length !== 1) return null;
+  const recoveries = readRawCorrectiveDecisionRecoveries(store, task).filter((event) =>
+    event.stepId === stepId
+    && event.triggeringAttemptCount === 3
+    && event.correctiveDecisionEventId === decisions[0]!.eventId
+    && event.correctiveDecisionEventHash === decisions[0]!.eventHash
+    && event.reboundPlanHash === task.planHash,
+  );
+  if (recoveries.length > 1) {
+    throw new WorkflowError('STATE_CORRUPT', 'Multiple corrective recoveries match one remediation attempt.', {
+      taskId: task.id,
+      stepId,
+      recoveryEventIds: recoveries.map((event) => event.eventId),
+    });
+  }
+  return recoveries[0]?.correctiveDecisionEventId ?? null;
+}
+
+export function findRemediationModeRecoveryCandidate(
+  store: FileStateStore,
+  task: TaskState,
+  options: { authorityMode?: 'enforce' | 'observe' } = {},
+): RemediationModeRecoveryAssessment | null {
+  const raw = readRawRemediationEvents(store, task);
+  const candidates = raw.filter((event) => event.attemptOrdinal > 2 && event.mode === 'ordinary');
+  if (candidates.length === 0) return null;
+  if (candidates.length !== 1) {
+    throw new WorkflowError('STATE_CORRUPT', 'Multiple malformed remediation modes are not recoverable.', {
+      taskId: task.id,
+      eventIds: candidates.map((event) => event.eventId),
+    });
+  }
+  const posture = readTaskC1Posture(store, task);
+  const lease = readWriterLeaseForModeRecovery(store, task);
+  const actor = posture.state === 'claimed' ? posture.claimant : lease?.owner ?? 'worker';
+  return assessRemediationModeRecovery(
+    store,
+    task,
+    candidates[0]!.stepId,
+    actor,
+    lease?.token ?? null,
+    options,
+  );
+}
+
+export function assessRemediationModeRecovery(
+  store: FileStateStore,
+  task: TaskState,
+  stepId: string,
+  actor: string,
+  writerToken: string | null,
+  options: { authorityMode?: 'enforce' | 'observe' } = {},
+): RemediationModeRecoveryAssessment {
+  const normalizedActor = actor.trim();
+  if (!normalizedActor) throw new WorkflowError('INVALID_ARGUMENT', 'Remediation mode recovery actor is required.');
+  const step = task.steps.find((candidate) => candidate.id === stepId) ?? null;
+  if (!step) throw new WorkflowError('NOT_FOUND', `Step not found: ${stepId}`);
+  if (task.status !== 'needs_fix' || step.status !== 'failed') {
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Remediation mode recovery requires the exact failed Task/Step posture.', {
+      taskId: task.id,
+      taskStatus: task.status,
+      stepId,
+      stepStatus: step.status,
+    });
+  }
+  if (!task.planHash) throw new WorkflowError('STATE_CORRUPT', `Task ${task.id} is missing its Plan hash.`);
+
+  const remediations = readRawRemediationEvents(store, task);
+  const decisions = readRawCorrectiveDecisionEvents(store, task);
+  validateRemediationAttemptOrdinals(remediations, task);
+  validateRemediationReviewReferences(store, task, remediations);
+  validateCorrectiveDecisionCoverage(store, task, decisions, remediations);
+  const malformed = remediations.filter((event) => event.attemptOrdinal > 2 && event.mode === 'ordinary');
+  if (malformed.length !== 1 || malformed[0]!.stepId !== stepId || malformed[0]!.attemptOrdinal !== 3) {
+    throw new WorkflowError('STATE_CORRUPT', 'State does not contain the one exact alpha.7.2 remediation mode omission.', {
+      taskId: task.id,
+      stepId,
+      malformedEventIds: malformed.map((event) => event.eventId),
+    });
+  }
+  const stepRemediations = remediations.filter((event) => event.stepId === stepId);
+  if (
+    stepRemediations.length !== 3
+    || stepRemediations[0]!.mode !== 'ordinary'
+    || stepRemediations[1]!.mode !== 'ordinary'
+    || stepRemediations[2]!.eventId !== malformed[0]!.eventId
+  ) {
+    throw new WorkflowError('STATE_CORRUPT', 'Remediation mode recovery requires exactly two ordinary attempts and one malformed third attempt.', {
+      taskId: task.id,
+      stepId,
+    });
+  }
+  const decisionMatches = decisions.filter((event) =>
+    event.stepId === stepId
+    && event.triggeringAttemptCount === 3
+    && event.decision === 'continue-fix'
+    && sameStringArray(event.coveredEventIds, stepRemediations.slice(0, 2).map((event) => event.eventId)),
+  );
+  if (decisionMatches.length !== 1) {
+    throw new WorkflowError('STATE_CORRUPT', 'Remediation mode recovery requires one exact continue-fix decision.', {
+      taskId: task.id,
+      stepId,
+      decisionEventIds: decisionMatches.map((event) => event.eventId),
+    });
+  }
+  const decision = decisionMatches[0]!;
+  const correctiveRecoveries = readRawCorrectiveDecisionRecoveries(store, task).filter((event) =>
+    event.stepId === stepId
+    && event.triggeringAttemptCount === 3
+    && event.correctiveDecisionEventId === decision.eventId
+    && event.correctiveDecisionEventHash === decision.eventHash
+    && event.reboundPlanHash === task.planHash,
+  );
+  if (correctiveRecoveries.length !== 1) {
+    throw new WorkflowError('STATE_CORRUPT', 'Remediation mode recovery requires one exact corrective-decision recovery.', {
+      taskId: task.id,
+      stepId,
+      recoveryEventIds: correctiveRecoveries.map((event) => event.eventId),
+    });
+  }
+  const correctiveRecovery = correctiveRecoveries[0]!;
+  const authority = options.authorityMode === 'observe'
+    ? observeRemediationModeRecoveryAuthority(store, task)
+    : requireRemediationModeRecoveryAuthority(store, task, normalizedActor, writerToken);
+  const existing = readRemediationModeRecoveryEvents(store, task).filter((event) =>
+    event.remediationEventId === malformed[0]!.eventId,
+  );
+  if (existing.length > 1) {
+    throw new WorkflowError('STATE_CORRUPT', 'Multiple remediation mode recoveries target one event.', {
+      taskId: task.id,
+      remediationEventId: malformed[0]!.eventId,
+    });
+  }
+  if (existing[0]) {
+    validateRemediationModeRecoveryBinding(existing[0], malformed[0]!, decision, correctiveRecovery);
+    const retryMismatches = [
+      existing[0].taskRevision !== task.revision ? 'taskRevision' : null,
+      existing[0].planHash !== task.planHash ? 'planHash' : null,
+      existing[0].actor !== normalizedActor ? 'actor' : null,
+      existing[0].c1ClaimEventHash !== authority.c1ClaimEventHash ? 'c1ClaimEventHash' : null,
+      existing[0].writerLeaseTokenHash !== authority.writerLeaseTokenHash ? 'writerLeaseTokenHash' : null,
+    ].filter((value): value is string => value !== null);
+    if (retryMismatches.length > 0) {
+      throw new WorkflowError('STATE_CONFLICT', 'Existing remediation mode recovery conflicts with the requested retry binding.', {
+        taskId: task.id,
+        stepId,
+        recoveryEventId: existing[0].eventId,
+        mismatches: retryMismatches,
+      });
+    }
+  }
+  const evidenceFingerprint = sha256Hex(canonicalJsonStringify({
+    taskId: task.id,
+    taskRevision: task.revision,
+    stepId,
+    planHash: task.planHash,
+    remediationEventHash: malformed[0]!.eventHash,
+    correctiveDecisionEventHash: decision.eventHash,
+    correctiveDecisionRecoveryEventHash: correctiveRecovery.eventHash,
+    actor: normalizedActor,
+    c1ClaimEventHash: authority.c1ClaimEventHash,
+    writerLeaseTokenHash: authority.writerLeaseTokenHash,
+  }));
+  return {
+    task,
+    remediation: malformed[0]!,
+    decision,
+    correctiveRecovery,
+    existingRecovery: existing[0] ?? null,
+    actor: normalizedActor,
+    c1ClaimEventHash: authority.c1ClaimEventHash,
+    writerLeaseTokenHash: authority.writerLeaseTokenHash,
+    evidenceFingerprint,
+  };
+}
+
+function observeRemediationModeRecoveryAuthority(
+  store: FileStateStore,
+  task: TaskState,
+): { c1ClaimEventHash: string | null; writerLeaseTokenHash: string | null } {
+  const posture = readTaskC1Posture(store, task);
+  const lease = readWriterLeaseForModeRecovery(store, task);
+  return {
+    c1ClaimEventHash: posture.state === 'none' ? null : posture.latestEvent.eventHash,
+    writerLeaseTokenHash: lease ? sha256Hex(lease.token) : null,
+  };
+}
+
+export function appendRemediationModeRecovery(
+  store: FileStateStore,
+  task: TaskState,
+  stepId: string,
+  expectedRevision: number,
+  actor: string,
+  writerToken: string | null,
+  now: Date,
+): RemediationModeRecoveryEvent {
+  if (task.revision !== expectedRevision) {
+    throw new WorkflowError('STATE_CONFLICT', `State revision conflict for ${task.id}`, {
+      expectedRevision,
+      actualRevision: task.revision,
+    });
+  }
+  const preflight = assessRemediationModeRecovery(store, task, stepId, actor, writerToken);
+  const root = store.taskRoot(task.projectId, task.id);
+  const lockFile = path.join(root, REMEDIATION_MODE_RECOVERY_LOCK);
+  let descriptor: number;
+  try {
+    descriptor = openSync(lockFile, 'wx', 0o600);
+    closeSync(descriptor);
+  } catch (error) {
+    if (existsSync(lockFile)) {
+      throw new WorkflowError('LOCKED', `Remediation mode 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: RemediationModeRecoveryAssessment;
+    try {
+      underLock = assessRemediationModeRecovery(store, currentTask, stepId, actor, writerToken);
+    } catch (error) {
+      throw new WorkflowError('STATE_CONFLICT', 'Remediation mode recovery evidence changed after preflight.', {
+        taskId: task.id,
+        stepId,
+        cause: error instanceof Error ? error.message : String(error),
+      });
+    }
+    if (underLock.existingRecovery) return underLock.existingRecovery;
+    if (underLock.evidenceFingerprint !== preflight.evidenceFingerprint) {
+      throw new WorkflowError('STATE_CONFLICT', 'Remediation mode recovery evidence changed after preflight.', {
+        taskId: task.id,
+        stepId,
+      });
+    }
+    return store.appendSidecarEvent<RemediationModeRecoveryEvent>(root, REMEDIATION_MODE_RECOVERIES_SIDECAR, {
+      eventId: `RMR-${createUlid(now.getTime())}`,
+      recordedAt: now.toISOString(),
+      taskId: task.id,
+      stepId,
+      taskRevision: expectedRevision,
+      remediationEventId: underLock.remediation.eventId,
+      remediationEventHash: underLock.remediation.eventHash,
+      correctiveDecisionEventId: underLock.decision.eventId,
+      correctiveDecisionEventHash: underLock.decision.eventHash,
+      correctiveDecisionRecoveryEventId: underLock.correctiveRecovery.eventId,
+      correctiveDecisionRecoveryEventHash: underLock.correctiveRecovery.eventHash,
+      attemptOrdinal: 3,
+      planHash: currentTask.planHash!,
+      actor: underLock.actor,
+      c1ClaimEventHash: underLock.c1ClaimEventHash,
+      writerLeaseTokenHash: underLock.writerLeaseTokenHash,
+      fromMode: 'ordinary',
+      toMode: 'corrective',
+      reason: 'alpha7.2-recovered-continue-fix-mode-omission',
+    }, {
+      validateEvent: (event, context) => validateStoredRemediationModeRecovery(event, currentTask, context.file, context.line),
+    });
+  } finally {
+    if (existsSync(lockFile)) unlinkSync(lockFile);
+  }
+}
+
+function requireRemediationModeRecoveryAuthority(
+  store: FileStateStore,
+  task: TaskState,
+  actor: string,
+  writerToken: string | null,
+): { c1ClaimEventHash: string | null; writerLeaseTokenHash: string | null } {
+  const posture = readTaskC1Posture(store, task);
+  const lease = readWriterLeaseForModeRecovery(store, task);
+  if (posture.state === 'pending') {
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Pending C1 handoff must be claimed before remediation mode 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', 'Remediation mode recovery requires the claimed C1 actor and exact writer token.', {
+        taskId: task.id,
+        claimant: posture.claimant,
+        leaseOwner: lease?.owner ?? null,
+      });
+    }
+    return { c1ClaimEventHash: posture.latestEvent.eventHash, writerLeaseTokenHash: tokenHash };
+  }
+  if (lease && (lease.owner !== actor || !writerToken || lease.token !== writerToken)) {
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Existing writer lease is not owned by the remediation recovery actor/token.');
+  }
+  if (!lease && writerToken) {
+    throw new WorkflowError('TRANSITION_BLOCKED', 'A writer token was provided without an existing writer lease.');
+  }
+  return {
+    c1ClaimEventHash: posture.latestEvent?.eventHash ?? null,
+    writerLeaseTokenHash: lease ? sha256Hex(lease.token) : null,
+  };
+}
+
+function readWriterLeaseForModeRecovery(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;
+}
+
+export function appendCorrectiveDecisionEvent(
+  store: FileStateStore,
+  task: TaskState,
+  stepId: string,
+  correctiveAudit: CorrectivePlanAuditInput,
+  planRiskAudit: CurrentPlanRiskAudit,
+  planHash: string,
+  now: Date,
+): CorrectiveDecisionEvent {
+  validateCorrectiveDecisionAudit(correctiveAudit);
+  const remediationEvents = readRemediationEvents(store, task).filter((event) => event.stepId === stepId);
+  const triggeringAttemptCount = remediationEvents.length + 1;
+  if (triggeringAttemptCount < 3) {
+    throw new WorkflowError(
+      'TRANSITION_BLOCKED',
+      `Corrective decision is not available for ${stepId} before two guarded remediation failures exist.`,
+      {
+        taskId: task.id,
+        stepId,
+        triggeringAttemptCount,
+      },
+    );
+  }
+  const decisions = readCorrectiveDecisionEvents(store, task);
+  const matching = decisions.filter((event) =>
+    event.taskId === task.id
+    && event.stepId === stepId
+    && event.triggeringAttemptCount === triggeringAttemptCount,
+  );
+  if (matching.length > 1) {
+    throw new WorkflowError(
+      'STATE_CORRUPT',
+      'Multiple corrective decisions exist for the current guarded remediation binding.',
+      {
+        taskId: task.id,
+        stepId,
+        triggeringAttemptCount,
+        eventIds: matching.map((event) => event.eventId),
+      },
+    );
+  }
+  const coveredFindingIds = normalizeStringList(correctiveAudit.reviewedFindingIds, 'Corrective decision reviewedFindingIds');
+  const coveredEventIds = remediationEvents.map((event) => event.eventId);
+  if (matching.length === 1) {
+    const reused = matching[0]!;
+    if (reused.planHash !== planHash) {
+      throw new WorkflowError('STATE_CONFLICT', 'A corrective decision already exists for this Step and triggering ordinal under a different Plan hash.', {
+        taskId: task.id,
+        stepId,
+        triggeringAttemptCount,
+        existingPlanHash: reused.planHash,
+        requestedPlanHash: planHash,
+        eventId: reused.eventId,
+      });
+    }
+    if (
+      reused.decision !== correctiveAudit.decision
+      || reused.auditor !== correctiveAudit.auditor.trim()
+      || !sameStringArray(reused.coveredFindingIds, coveredFindingIds)
+      || !sameStringArray(reused.coveredEventIds, coveredEventIds)
+    ) {
+      throw new WorkflowError('STATE_CONFLICT', 'Existing corrective decision payload does not match the requested guarded remediation binding.', {
+        taskId: task.id,
+        stepId,
+        triggeringAttemptCount,
+        eventId: reused.eventId,
+      });
+    }
+    return reused;
+  }
+  requireGuardedCategory(planRiskAudit, stepId);
+  return store.appendSidecarEvent<CorrectiveDecisionEvent>(
+    store.taskRoot(task.projectId, task.id),
+    CORRECTIVE_DECISIONS_SIDECAR,
+    {
+      eventId: `CRD-${createUlid(now.getTime())}`,
+      recordedAt: now.toISOString(),
+      taskId: task.id,
+      stepId,
+      triggeringAttemptCount,
+      decision: correctiveAudit.decision,
+      auditor: correctiveAudit.auditor.trim(),
+      coveredFindingIds,
+      coveredEventIds,
+      planHash,
+    },
+    {
+      validateEvent: (event, context) => validateStoredCorrectiveDecisionEvent(event, task, context.file, context.line),
+    },
+  );
+}
+
+export function prepareStopEscalateOverride(
+  store: FileStateStore,
+  task: TaskState,
+  stepId: string,
+  expectedRevision: number,
+  actor: string,
+  reason: string,
+  headCommit: string,
+): StopEscalateOverridePreparation {
+  if (task.revision !== expectedRevision) {
+    throw new WorkflowError('STATE_CONFLICT', `State revision conflict for ${task.id}`, {
+      expectedRevision,
+      actualRevision: task.revision,
+    });
+  }
+  const normalizedActor = actor.trim();
+  const normalizedReason = reason.trim();
+  if (!normalizedActor) throw new WorkflowError('INVALID_ARGUMENT', 'Stop override requires a human actor.');
+  if (!normalizedReason) throw new WorkflowError('INVALID_ARGUMENT', 'Stop override requires a reason.');
+  if (!COMMIT_SHA_PATTERN.test(headCommit)) {
+    throw new WorkflowError('INVALID_ARGUMENT', 'Stop override requires the exact current Git HEAD.');
+  }
+  if (task.status !== 'needs_fix') {
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Stop override requires a needs_fix Task.', {
+      taskId: task.id,
+      taskStatus: task.status,
+    });
+  }
+  const step = task.steps.find((candidate) => candidate.id === stepId) ?? null;
+  if (!step) throw new WorkflowError('NOT_FOUND', `Step not found: ${stepId}`);
+  if (step.status !== 'failed') {
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Stop override requires the exact failed Step.', {
+      taskId: task.id,
+      stepId,
+      stepStatus: step.status,
+    });
+  }
+  if (!task.planHash) throw new WorkflowError('STATE_CORRUPT', `Task ${task.id} is missing its Plan hash.`);
+
+  const history = readOpenGuardedRemediationHistory(store, task, stepId);
+  const remediations = history.remediationEvents;
+  if (
+    remediations.length !== 3
+    || remediations[0]?.attemptOrdinal !== 1
+    || remediations[0]?.mode !== 'ordinary'
+    || remediations[1]?.attemptOrdinal !== 2
+    || remediations[1]?.mode !== 'ordinary'
+    || remediations[2]?.attemptOrdinal !== 3
+    || remediations[2]?.mode !== 'corrective'
+  ) {
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Stop override is limited to the exact beta.11 three-failure history.', {
+      taskId: task.id,
+      stepId,
+      attempts: remediations.map((event) => ({ eventId: event.eventId, ordinal: event.attemptOrdinal, mode: event.mode })),
+    });
+  }
+  const priorContinueMatches = history.correctiveDecisions.filter((event) =>
+    event.triggeringAttemptCount === 3
+    && event.decision === 'continue-fix'
+    && event.planHash === task.planHash
+    && sameStringArray(event.coveredEventIds, remediations.slice(0, 2).map((candidate) => candidate.eventId)),
+  );
+  const stopMatches = history.correctiveDecisions.filter((event) =>
+    event.triggeringAttemptCount === 4
+    && event.decision === 'stop-escalate'
+    && event.planHash === task.planHash
+    && sameStringArray(event.coveredEventIds, remediations.map((candidate) => candidate.eventId)),
+  );
+  if (priorContinueMatches.length !== 1 || stopMatches.length !== 1) {
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Stop override requires one exact attempt-3 continue decision and one exact attempt-4 stop decision.', {
+      taskId: task.id,
+      stepId,
+      priorContinueDecisionEventIds: priorContinueMatches.map((event) => event.eventId),
+      stopDecisionEventIds: stopMatches.map((event) => event.eventId),
+    });
+  }
+  const priorContinue = priorContinueMatches[0]!;
+  const stopDecision = stopMatches[0]!;
+  const binding = {
+    taskId: task.id,
+    taskRevision: task.revision,
+    stepId,
+    stopDecisionEventId: stopDecision.eventId,
+    stopDecisionEventHash: stopDecision.eventHash,
+    priorContinueDecisionEventId: priorContinue.eventId,
+    priorContinueDecisionEventHash: priorContinue.eventHash,
+    triggeringAttemptCount: 4 as const,
+    coveredEventIds: remediations.map((event) => event.eventId),
+    planHash: task.planHash,
+    headCommit,
+    actor: normalizedActor,
+    reason: normalizedReason,
+    packageVersion: PACKAGE_VERSION,
+    policy: LEGACY_STOP_OVERRIDE_POLICY,
+  };
+  const confirmationCodeBindingHash = stopEscalateOverrideBindingHash(binding);
+  const existing = readStopEscalateOverrideEvents(store, task).find(
+    (event) => event.stopDecisionEventId === stopDecision.eventId,
+  ) ?? null;
+  if (existing && existing.confirmationCodeBindingHash !== confirmationCodeBindingHash) {
+    throw new WorkflowError('STATE_CONFLICT', 'The stop decision already has an override with a different human binding.', {
+      taskId: task.id,
+      stepId,
+      overrideEventId: existing.eventId,
+    });
+  }
+  return {
+    eligible: true,
+    action: 'task stop-override-apply',
+    ...binding,
+    confirmationCodeBindingHash,
+    confirmationCode: `SOO-${confirmationCodeBindingHash.slice(0, 24).toUpperCase()}`,
+    appendOnly: true,
+    preservesOriginalDecision: true,
+    delegatedApprovalAllowed: false,
+  };
+}
+
+export function appendStopEscalateOverride(
+  store: FileStateStore,
+  task: TaskState,
+  stepId: string,
+  expectedRevision: number,
+  actor: string,
+  reason: string,
+  headCommit: string,
+  confirmationCode: string,
+  now: Date,
+): StopEscalateOverrideEvent {
+  const prepared = prepareStopEscalateOverride(
+    store,
+    task,
+    stepId,
+    expectedRevision,
+    actor,
+    reason,
+    headCommit,
+  );
+  if (confirmationCode.trim() !== prepared.confirmationCode) {
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Stop override confirmation code does not match the current state binding.', {
+      taskId: task.id,
+      stepId,
+      confirmationCodeBindingHash: prepared.confirmationCodeBindingHash,
+    });
+  }
+  const root = store.taskRoot(task.projectId, task.id);
+  const existing = readStopEscalateOverrideEvents(store, task).find(
+    (event) => event.stopDecisionEventId === prepared.stopDecisionEventId,
+  ) ?? null;
+  if (existing) return existing;
+
+  const lockFile = path.join(root, STOP_ESCALATE_OVERRIDE_LOCK);
+  let descriptor: number;
+  try {
+    descriptor = openSync(lockFile, 'wx', 0o600);
+    closeSync(descriptor);
+  } catch (error) {
+    if (existsSync(lockFile)) {
+      throw new WorkflowError('LOCKED', `Stop override for ${task.id} is already being serialized.`, {
+        taskId: task.id,
+        stepId,
+      });
+    }
+    throw error;
+  }
+  try {
+    const currentTask = store.readTask(task.projectId, task.id);
+    const underLock = prepareStopEscalateOverride(
+      store,
+      currentTask,
+      stepId,
+      expectedRevision,
+      actor,
+      reason,
+      headCommit,
+    );
+    if (
+      underLock.confirmationCode !== prepared.confirmationCode
+      || underLock.confirmationCodeBindingHash !== prepared.confirmationCodeBindingHash
+    ) {
+      throw new WorkflowError('STATE_CONFLICT', 'Stop override evidence changed after preparation.', {
+        taskId: task.id,
+        stepId,
+      });
+    }
+    return store.appendSidecarEvent<StopEscalateOverrideEvent>(root, STOP_ESCALATE_OVERRIDES_SIDECAR, {
+      eventId: `SOO-${createUlid(now.getTime())}`,
+      recordedAt: now.toISOString(),
+      taskId: underLock.taskId,
+      taskRevision: underLock.taskRevision,
+      stepId: underLock.stepId,
+      stopDecisionEventId: underLock.stopDecisionEventId,
+      stopDecisionEventHash: underLock.stopDecisionEventHash,
+      priorContinueDecisionEventId: underLock.priorContinueDecisionEventId,
+      priorContinueDecisionEventHash: underLock.priorContinueDecisionEventHash,
+      triggeringAttemptCount: 4,
+      coveredEventIds: underLock.coveredEventIds,
+      planHash: underLock.planHash,
+      headCommit: underLock.headCommit,
+      actor: underLock.actor,
+      reason: underLock.reason,
+      packageVersion: underLock.packageVersion,
+      confirmationCodeBindingHash: underLock.confirmationCodeBindingHash,
+      policy: LEGACY_STOP_OVERRIDE_POLICY,
+    }, {
+      validateEvent: (event, context) => validateStoredStopEscalateOverride(event, currentTask, context.file, context.line),
+    });
+  } finally {
+    if (existsSync(lockFile)) unlinkSync(lockFile);
+  }
+}
+
+export function appendPlanIntegrityRecoveryDecision(
+  store: FileStateStore,
+  task: TaskState,
+  stepId: string,
+  auditor: string,
+  evidence: PlanIntegrityConflictEvidence,
+  now: Date,
+): CorrectiveDecisionEvent {
+  if (!task.planHash) {
+    throw new WorkflowError('STATE_CORRUPT', `Task ${task.id} has no Plan hash for Plan-integrity recovery.`);
+  }
+  if (!auditor.trim()) {
+    throw new WorkflowError('INVALID_ARGUMENT', 'Plan-integrity recovery requires a derived auditor identity.');
+  }
+  const allRemediationEvents = readRemediationEvents(store, task).filter(event => event.stepId === stepId);
+  const support = evidence.kind === 'check-support-anchor-outside-allowed-writes' || evidence.kind === 'failed-check-component-owner-outside-allowed-writes';
+  const remediationEvents = support ? selectPlanIntegrityRemediations(store, task, allRemediationEvents,
+    readCorrectiveDecisionEvents(store, task).filter(event => event.stepId === stepId)) : allRemediationEvents;
+  if (!remediationEvents) throw new WorkflowError('TRANSITION_BLOCKED', 'Mechanical recovery lacks a verified current Plan cycle.');
+  const expectedBindings = evidence.kind === 'missing-npm-script-outside-allowed-writes'
+    ? [{
+        eventId: evidence.remediationEventId,
+        eventHash: evidence.remediationEventHash,
+        attemptOrdinal: 1,
+      }]
+    : evidence.remediationEvents;
+  if (remediationEvents.length !== expectedBindings.length
+    || remediationEvents.some((event, index) => {
+      const binding = expectedBindings[index];
+      return event.failureKind !== 'checks-failed'
+        || event.eventId !== binding?.eventId
+        || event.eventHash !== binding.eventHash
+        || event.attemptOrdinal !== binding.attemptOrdinal;
+    })) {
+    throw new WorkflowError('TRANSITION_BLOCKED', 'Plan-integrity recovery requires the exact checks-failed remediation history.', {
+      taskId: task.id,
+      stepId,
+      remediationEventIds: remediationEvents.map((event) => event.eventId),
+    });
+  }
+  const triggeringAttemptCount = allRemediationEvents.length + 1;
+  const recoveryDecision = evidence.kind === 'check-support-anchor-outside-allowed-writes'
+    || evidence.kind === 'failed-check-component-owner-outside-allowed-writes'
+    ? 'continue-fix' as const
+    : 'replan-required' as const;
+  const decisions = readCorrectiveDecisionEvents(store, task).filter((event) =>
+    event.stepId === stepId && event.triggeringAttemptCount === triggeringAttemptCount);
+  const findingId = `PLAN-INTEGRITY-${evidence.conflictHash.slice(0, 16).toUpperCase()}`;
+  if (decisions.length > 1) {
+    throw new WorkflowError('STATE_CORRUPT', 'Multiple Plan-integrity recovery decisions exist for the same Step.', {
+      taskId: task.id,
+      stepId,
+      eventIds: decisions.map((event) => event.eventId),
+    });
+  }
+  if (decisions.length === 1) {
+    const existing = decisions[0]!;
+    if (
+      existing.planHash !== task.planHash
+      || existing.decision !== recoveryDecision
+      || existing.auditor !== auditor.trim()
+      || existing.planIntegrityEvidence?.conflictHash !== evidence.conflictHash
+    ) {
+      throw new WorkflowError('STATE_CONFLICT', 'Existing Plan-integrity recovery decision does not match the requested conflict.', {
+        taskId: task.id,
+        stepId,
+        eventId: existing.eventId,
+      });
+    }
+    return existing;
+  }
+  return store.appendSidecarEvent<CorrectiveDecisionEvent>(
+    store.taskRoot(task.projectId, task.id),
+    CORRECTIVE_DECISIONS_SIDECAR,
+    {
+      eventId: `CRD-${createUlid(now.getTime())}`,
+      recordedAt: now.toISOString(),
+      taskId: task.id,
+      stepId,
+      triggeringAttemptCount,
+      decision: recoveryDecision,
+      auditor: auditor.trim(),
+      coveredFindingIds: [findingId],
+      coveredEventIds: allRemediationEvents.map((event) => event.eventId),
+      planHash: task.planHash,
+      recoveryBasis: 'plan-integrity',
+      planIntegrityEvidence: evidence,
+    },
+    {
+      validateEvent: (event, context) => validateStoredCorrectiveDecisionEvent(event, task, context.file, context.line),
+    },
+  );
+}
+
+export function assertGuardedRemediationAttemptAllowed(
+  store: FileStateStore,
+  task: TaskState,
+  stepId: string,
+  planRiskAudit: CurrentPlanRiskAudit,
+  recoveredDecisionEventId: string | null = null,
+  reboundStopOverrideDecisionEventId: string | null = null,
+): GuardedRemediationAttemptGate {
+  const history = readOpenGuardedRemediationHistory(store, task, stepId);
+  return deriveAttemptGateFromHistory(store, task, stepId, planRiskAudit, history.remediationEvents, history.correctiveDecisions, {
+    enforceRuntimeGate: true,
+    recoveredDecisionEventId,
+    reboundStopOverrideDecisionEventId,
+    overriddenStopDecisionEventIds: stopEscalateOverrideDecisionEventIds(store, task),
+    priorRemediationEvents: history.priorRemediationEvents,
+    nextAttemptOrdinal: history.nextAttemptOrdinal,
+  });
+}
+
+export function readGuardedRemediationPostureForStep(
+  store: FileStateStore,
+  task: TaskState,
+  stepId: string,
+  planRiskAudit: CurrentPlanRiskAudit,
+): GuardedRemediationAttemptGate | null {
+  if (!planRiskAudit.reviewRequiredStepIds.includes(stepId)) return null;
+  const step = task.steps.find((candidate) => candidate.id === stepId) ?? null;
+  if (!step) {
+    throw new WorkflowError('STATE_CORRUPT', `Task ${task.id} is missing guarded Step ${stepId}.`, {
+      taskId: task.id,
+      stepId,
+    });
+  }
+  const history = readOpenGuardedRemediationHistory(store, task, stepId);
+  const remediationEvents = history.remediationEvents;
+  const earlyPlanIntegrityDecision = remediationEvents.length === 1
+    ? findCurrentCorrectiveDecision(task, stepId, 2, history.correctiveDecisions)
+    : null;
+  const currentDecision = findCurrentCorrectiveDecision(task, stepId, history.nextAttemptOrdinal, history.correctiveDecisions);
+  if (remediationEvents.length < 2 && earlyPlanIntegrityDecision?.recoveryBasis !== 'plan-integrity'
+    && currentDecision === null
+    && deriveCurrentCauseDecision(remediationEvents, history.priorRemediationEvents) !== 'root-cause-replan') return null;
+  if (step.status === 'failed' || step.status === 'planned') {
+    return deriveAttemptGateFromHistory(store, task, stepId, planRiskAudit, remediationEvents, history.correctiveDecisions, {
+      overriddenStopDecisionEventIds: stopEscalateOverrideDecisionEventIds(store, task),
+      priorRemediationEvents: history.priorRemediationEvents,
+      nextAttemptOrdinal: history.nextAttemptOrdinal,
+    });
+  }
+  if (task.status !== 'blocked' || step.status !== 'in_progress' || !step.evidence) return null;
+  const currentCycle = buildCurrentStrictStepReviewCycle(store, task, stepId);
+  if (currentCycle.resolution !== 'unverified') return null;
+  return deriveAttemptGateFromHistory(store, task, stepId, planRiskAudit, remediationEvents, history.correctiveDecisions, {
+    overriddenStopDecisionEventIds: stopEscalateOverrideDecisionEventIds(store, task),
+    priorRemediationEvents: history.priorRemediationEvents,
+    nextAttemptOrdinal: history.nextAttemptOrdinal,
+  });
+}
+
+interface GuardedRemediationHistory {
+  remediationEvents: RemediationEvent[];
+  priorRemediationEvents: RemediationEvent[];
+  correctiveDecisions: CorrectiveDecisionEvent[];
+  nextAttemptOrdinal: number;
+}
+
+interface RemediationPlanCycleBinding {
+  semanticHash: string;
+  planHash: string;
+  sourceTaskRevision: number;
+}
+
+function readOpenGuardedRemediationHistory(
+  store: FileStateStore,
+  task: TaskState,
+  stepId: string,
+): GuardedRemediationHistory {
+  const allStepRemediations = readRemediationEvents(store, task).filter((event) => event.stepId === stepId);
+  const allStepDecisions = readCorrectiveDecisionEvents(store, task).filter((event) => event.stepId === stepId);
+  const passedBoundary = latestPassedVerifiedStepReviewEvent(store, task, stepId);
+  const remediationEvents = passedBoundary
+    ? allStepRemediations.filter((event) => event.recordedAt > passedBoundary.recordedAt)
+    : allStepRemediations;
+  const correctiveDecisions = passedBoundary
+    ? allStepDecisions.filter((event) => event.recordedAt > passedBoundary.recordedAt)
+    : allStepDecisions;
+  return {
+    ...selectCurrentPlanRemediationCycle(store, task, remediationEvents, correctiveDecisions),
+    nextAttemptOrdinal: allStepRemediations.length + 1,
+  };
+}
+
+function selectCurrentPlanRemediationCycle(
+  store: FileStateStore,
+  task: TaskState,
+  remediationEvents: readonly RemediationEvent[],
+  correctiveDecisions: readonly CorrectiveDecisionEvent[],
+  canonicalPlanHash = task.planHash,
+): Omit<GuardedRemediationHistory, 'nextAttemptOrdinal'> {
+  const unchanged = () => ({
+    remediationEvents: [...remediationEvents],
+    priorRemediationEvents: [],
+    correctiveDecisions: [...correctiveDecisions],
+  });
+  if (remediationEvents.length === 0 || !task.planHash) return unchanged();
+  const audits = readPlanRiskAuditEvents(store, task);
+  const currentAudit = [...audits].reverse().find((event) =>
+    event.planHash === task.planHash
+    && event.taskRevision <= task.revision
+    && event.decision !== 'split-required'
+    && event.decision !== 'stop-escalate') ?? null;
+  if (!currentAudit) return unchanged();
+  const taskRoot = store.taskRoot(task.projectId, task.id);
+  let currentSemanticHash: string;
+  try {
+    currentSemanticHash = normalizePlanKnowledgeBinding(
+      readVerifiedPlanArtifact(taskRoot, task.planHash, canonicalPlanHash!),
+      'current',
+    ).semanticHash;
+  } catch {
+    return unchanged();
+  }
+  const reviews = readStepReviewEvents(store, task);
+  const bindings = remediationEvents.map((event) =>
+    resolveRemediationPlanCycleBinding(taskRoot, canonicalPlanHash!, event, reviews, audits));
+  if (bindings.some((binding) => binding === null)) return unchanged();
+  let cycleStart = remediationEvents.length;
+  while (cycleStart > 0 && bindings[cycleStart - 1]!.semanticHash === currentSemanticHash) cycleStart -= 1;
+  if (cycleStart === remediationEvents.length
+    && currentAudit.taskRevision <= bindings.at(-1)!.sourceTaskRevision) return unchanged();
+  return {
+    remediationEvents: remediationEvents.slice(cycleStart),
+    priorRemediationEvents: remediationEvents.slice(0, cycleStart),
+    // Corrective decisions remain globally authoritative. The semantic cycle scopes
+    // cause counting only; filtering decisions could discard stop/split authority.
+    correctiveDecisions: [...correctiveDecisions],
+  };
+}
+
+/** Scope mechanical support evidence only; global corrective authority is never discarded. */
+export function selectPlanIntegrityRemediations(
+  store: FileStateStore, task: TaskState, events: readonly RemediationEvent[], decisions: readonly CorrectiveDecisionEvent[],
+  canonicalPlanHash = task.planHash,
+): RemediationEvent[] | null {
+  if (events.length === 0) return null;
+  const stepId = events[0]!.stepId;
+  if (events.some(event => event.stepId !== stepId) || decisions.some(event => event.stepId !== stepId)) return null;
+  const cycle = selectCurrentPlanRemediationCycle(store, task, events, decisions, canonicalPlanHash);
+  if (cycle.priorRemediationEvents.length === 0) return decisions.length === 0 ? [...events] : null;
+  if (!task.planHash || cycle.remediationEvents.length === 0
+    || decisions.some(d => d.decision === 'stop-escalate' || d.decision === 'split-required')) return null;
+  const root = store.taskRoot(task.projectId, task.id);
+  const history = readCompletedCorrectiveReplanHistory(store, task);
+  const semantic = (hash: string) => {
+    const saved = history.flatMap(boundary => [boundary.beforePlan, boundary.afterPlan]).find(bytes => sha256Hex(bytes) === hash);
+    return normalizePlanKnowledgeBinding(saved ?? readVerifiedPlanArtifact(root, hash, canonicalPlanHash!), 'cycle').semanticHash;
+  };
+  const currentSemantic = semantic(task.planHash);
+  const audits = readPlanRiskAuditEvents(store, task), reviews = readStepReviewEvents(store, task);
+  const priorBindings = cycle.priorRemediationEvents.map(event => resolveRemediationPlanCycleBinding(root, canonicalPlanHash!, event, reviews, audits));
+  const currentBindings = cycle.remediationEvents.map(event => resolveRemediationPlanCycleBinding(root, canonicalPlanHash!, event, reviews, audits));
+  if (priorBindings.some(b => !b) || currentBindings.some(b => !b)) return null;
+  const boundaries = history.filter(boundary =>
+    correctiveReplanBoundaryMatchesStep(boundary.before, stepId)
+    && boundary.after.planHash && boundary.before.planHash
+    && semantic(boundary.after.planHash) === currentSemantic && semantic(boundary.before.planHash) !== currentSemantic
+    && boundary.after.revision <= task.revision
+    && priorBindings.every(b => b!.sourceTaskRevision < boundary.after.revision)
+    && currentBindings.every(b => b!.sourceTaskRevision > boundary.after.revision));
+  if (boundaries.length !== 1) return null;
+  const boundary = boundaries[0]!;
+  let cursor = task.planHash;
+  const visited = new Set<string>();
+  const planBytes = (hash: string) => history.flatMap(b => [b.beforePlan, b.afterPlan]).find(bytes => sha256Hex(bytes) === hash)
+    ?? readVerifiedPlanArtifact(root, hash, canonicalPlanHash!);
+  while (cursor !== boundary.after.planHash) {
+    if (visited.has(cursor)) return null;
+    visited.add(cursor);
+    const links = task.knowledgeRebinds.filter(link => link.reboundPlanHash === cursor);
+    if (links.length !== 1 || !links[0]!.previousPlanHash) return null;
+    const link = links[0]!;
+    assertKnowledgeBindingOnlyPlanChange(planBytes(link.previousPlanHash!), planBytes(cursor));
+    if (!planBytes(link.previousPlanHash!).includes(`- Knowledge map: revision ${link.fromKnowledgeMapRevision}, hash ${link.fromKnowledgeMapHash}\n`)
+      || !planBytes(cursor).includes(`- Knowledge map: revision ${link.toKnowledgeMapRevision}, hash ${link.toKnowledgeMapHash}\n`)) return null;
+    cursor = link.previousPlanHash!;
+  }
+  if (!task.authorizations.some(a => a.kind === 'execution' && ['approved', 'superseded'].includes(a.decision)
+    && a.planHash === task.planHash && a.briefHash === task.briefHash
+    && a.recordedAt >= boundary.admittedAt)) return null;
+  if (decisions.length === 0 || decisions.some(d => d.recordedAt > boundary.admittedAt
+    || semantic(d.planHash) === currentSemantic)) return null;
+  const last = decisions.at(-1)!;
+  if (last.decision !== 'replan-required' || last.triggeringAttemptCount !== cycle.priorRemediationEvents.length + 1
+    || semantic(last.planHash) !== semantic(boundary.before.planHash!)) return null;
+  return cycle.remediationEvents;
+}
+
+function resolveRemediationPlanCycleBinding(
+  taskRoot: string,
+  currentPlanHash: string,
+  event: RemediationEvent,
+  reviews: readonly import('../contracts.js').StepReviewEvent[],
+  audits: readonly PlanRiskAuditEvent[],
+): RemediationPlanCycleBinding | null {
+  let planHash: string | null = null;
+  let sourceTaskRevision: number | null = null;
+  if (event.failureEvidence.reviewEventHash) {
+    const review = reviews.find((candidate) => candidate.eventHash === event.failureEvidence.reviewEventHash) ?? null;
+    if (!review) return null;
+    planHash = review.planHash;
+    sourceTaskRevision = review.taskRevision;
+  } else if (event.failureEvidence.executionTaskRevision !== undefined) {
+    sourceTaskRevision = event.failureEvidence.executionTaskRevision;
+    planHash = [...audits].reverse().find((audit) => audit.taskRevision <= sourceTaskRevision!)?.planHash ?? null;
+  }
+  if (!planHash || sourceTaskRevision === null
+    || !audits.some((audit) => audit.planHash === planHash && audit.taskRevision <= sourceTaskRevision)) return null;
+  try {
+    return {
+      semanticHash: normalizePlanKnowledgeBinding(
+        readVerifiedPlanArtifact(taskRoot, planHash, currentPlanHash),
+        'remediation ' + event.eventId,
+      ).semanticHash,
+      planHash,
+      sourceTaskRevision,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export function deriveCurrentCauseDecisionForTask(
+  store: FileStateStore,
+  task: TaskState,
+  stepId: string,
+  remediationEvents: readonly RemediationEvent[],
+): 'same-task-fix' | 'root-cause-replan' | null {
+  const decisions = readCorrectiveDecisionEvents(store, task).filter((event) => event.stepId === stepId);
+  const cycle = selectCurrentPlanRemediationCycle(store, task, remediationEvents, decisions);
+  return deriveCurrentCauseDecision(cycle.remediationEvents, cycle.priorRemediationEvents);
+}
+
+export function findCurrentGuardedRemediationPosture(
+  store: FileStateStore,
+  task: TaskState,
+  planRiskAudit: CurrentPlanRiskAudit,
+): GuardedRemediationAttemptGate | null {
+  const matches = planRiskAudit.reviewRequiredStepIds
+    .map((stepId) => readGuardedRemediationPostureForStep(store, task, stepId, planRiskAudit))
+    .filter((value): value is GuardedRemediationAttemptGate => value !== null);
+  if (matches.length === 0) return null;
+  if (matches.length > 1) {
+    throw new WorkflowError(
+      'STATE_CORRUPT',
+      'Multiple guarded failed Steps simultaneously require corrective remediation decisions.',
+      {
+        taskId: task.id,
+        stepIds: matches.map((match) => match.stepId),
+      },
+    );
+  }
+  return matches[0]!;
+}
+
+export function findFailedGuardedStepRequiringCorrectiveDecision(
+  store: FileStateStore,
+  task: TaskState,
+  planRiskAudit: CurrentPlanRiskAudit,
+): GuardedRemediationAttemptGate | null {
+  const posture = findCurrentGuardedRemediationPosture(store, task, planRiskAudit);
+  if (!posture) return null;
+  return posture.posture === 'decision-required'
+    ? posture
+    : null;
+}
+
+function deriveAttemptGateFromHistory(
+  store: FileStateStore,
+  task: TaskState,
+  stepId: string,
+  planRiskAudit: CurrentPlanRiskAudit,
+  remediationEvents: readonly RemediationEvent[],
+  correctiveDecisions: readonly CorrectiveDecisionEvent[],
+  options: {
+    enforceRuntimeGate?: boolean;
+    recoveredDecisionEventId?: string | null;
+    reboundStopOverrideDecisionEventId?: string | null;
+    overriddenStopDecisionEventIds?: ReadonlySet<string>;
+    priorRemediationEvents?: readonly RemediationEvent[];
+    nextAttemptOrdinal?: number;
+  } = {},
+): GuardedRemediationAttemptGate {
+  const attemptCount = remediationEvents.length + (options.priorRemediationEvents?.length ?? 0);
+  const nextAttemptOrdinal = options.nextAttemptOrdinal ?? attemptCount + 1;
+  const guardedCategory = requireGuardedCategory(planRiskAudit, stepId);
+  const rollingCauseDecision = deriveCurrentCauseDecision(remediationEvents, options.priorRemediationEvents ?? []);
+  const currentCorrectiveDecision = findCurrentCorrectiveDecision(
+    task,
+    stepId,
+    nextAttemptOrdinal,
+    correctiveDecisions,
+  );
+  const planIntegrityDecision = currentCorrectiveDecision;
+  if (planIntegrityDecision?.recoveryBasis === 'plan-integrity'
+    && (planIntegrityDecision.planHash === task.planHash || planIntegrityDecision.decision === 'replan-required'
+      || isKnowledgeReboundSupportDecision(store, task, planIntegrityDecision))) {
+    if (planIntegrityDecision.planHash !== task.planHash && planIntegrityDecision.decision === 'replan-required') {
+      return {
+        stepId,
+        guardedCategory,
+        attemptCount,
+        nextAttemptOrdinal,
+        mode: 'corrective',
+        correctiveDecision: planIntegrityDecision,
+        posture: planIntegrityDecision.decision === 'replan-required' ? 'replan-ready' : 'continue-fix',
+      };
+    }
+    if (planIntegrityDecision.decision === 'continue-fix'
+      && (planIntegrityDecision.planIntegrityEvidence?.kind === 'check-support-anchor-outside-allowed-writes'
+        || planIntegrityDecision.planIntegrityEvidence?.kind === 'failed-check-component-owner-outside-allowed-writes')) {
+      return {
+        stepId,
+        guardedCategory,
+        attemptCount,
+        nextAttemptOrdinal,
+        mode: 'ordinary',
+        correctiveDecision: planIntegrityDecision,
+        posture: 'continue-fix',
+      };
+    }
+    if (planIntegrityDecision.decision !== 'replan-required') {
+      throw new WorkflowError('STATE_CORRUPT', 'Plan-integrity decision has an unsupported disposition.', {
+        taskId: task.id,
+        stepId,
+        decisionEventId: planIntegrityDecision.eventId,
+      });
+    }
+    return {
+      stepId,
+      guardedCategory,
+      attemptCount,
+      nextAttemptOrdinal,
+      mode: 'ordinary',
+      correctiveDecision: planIntegrityDecision,
+      posture: 'replan-required',
+    };
+  }
+  // A recorded corrective decision remains authoritative over an ordinary
+  // rolling continuation. A repeated authoritative cause is fresh evidence
+  // that the current Plan itself is no longer viable and still forces replan.
+  if (rollingCauseDecision !== null
+    && !(rollingCauseDecision === 'same-task-fix' && currentCorrectiveDecision)) {
+    if (rollingCauseDecision === 'root-cause-replan' && options.enforceRuntimeGate) {
+      throw new WorkflowError(
+        'TRANSITION_BLOCKED',
+        `Guarded Step ${stepId} has an explicit Plan conflict or repeated authoritative cause and requires replan.`,
+        { taskId: task.id, stepId, attemptCount, requiredAction: 'task plan-set' },
+      );
+    }
+    return {
+      stepId,
+      guardedCategory,
+      attemptCount,
+      nextAttemptOrdinal,
+      mode: 'ordinary',
+      correctiveDecision: null,
+      posture: rollingCauseDecision === 'root-cause-replan' ? 'replan-required' : 'ordinary',
+    };
+  }
+  if (attemptCount < 2) {
+    return {
+      stepId,
+      guardedCategory,
+      attemptCount,
+      nextAttemptOrdinal,
+      mode: 'ordinary',
+      correctiveDecision: null,
+      posture: 'ordinary',
+    };
+  }
+  const correctiveDecision = currentCorrectiveDecision;
+  if (!correctiveDecision) {
+    return {
+      stepId,
+      guardedCategory,
+      attemptCount,
+      nextAttemptOrdinal,
+      mode: 'corrective',
+      correctiveDecision: null,
+      posture: 'continue-fix',
+    };
+  }
+  if (correctiveDecision.planHash !== task.planHash) {
+    if (
+      correctiveDecision.decision === 'continue-fix'
+      && options.recoveredDecisionEventId === correctiveDecision.eventId
+    ) {
+      return {
+        stepId,
+        guardedCategory,
+        attemptCount,
+        nextAttemptOrdinal,
+        mode: 'corrective',
+        correctiveDecision,
+        posture: 'continue-fix',
+      };
+    }
+    if (
+      correctiveDecision.decision === 'stop-escalate'
+      && options.reboundStopOverrideDecisionEventId === correctiveDecision.eventId
+      && options.overriddenStopDecisionEventIds?.has(correctiveDecision.eventId)
+    ) {
+      return {
+        stepId,
+        guardedCategory,
+        attemptCount,
+        nextAttemptOrdinal,
+        mode: 'corrective',
+        correctiveDecision,
+        posture: 'continue-fix',
+      };
+    }
+    if (correctiveDecision.decision === 'replan-required') {
+      return {
+        stepId,
+        guardedCategory,
+        attemptCount,
+        nextAttemptOrdinal,
+        mode: 'corrective',
+        correctiveDecision,
+        posture: 'replan-ready',
+      };
+    }
+    if (options.enforceRuntimeGate) {
+      throw new WorkflowError(
+        'TRANSITION_BLOCKED',
+        `Guarded Step ${stepId} has a corrective decision for a different Plan hash and cannot continue under the current Plan.`,
+        {
+          taskId: task.id,
+          stepId,
+          triggeringAttemptCount: nextAttemptOrdinal,
+          currentPlanHash: task.planHash,
+          decisionPlanHash: correctiveDecision.planHash,
+          decisionEventId: correctiveDecision.eventId,
+        },
+      );
+    }
+    return {
+      stepId,
+      guardedCategory,
+      attemptCount,
+      nextAttemptOrdinal,
+      mode: 'ordinary',
+      correctiveDecision,
+      posture: 'decision-required',
+    };
+  }
+  if (
+    correctiveDecision.decision === 'stop-escalate'
+    && options.overriddenStopDecisionEventIds?.has(correctiveDecision.eventId)
+  ) {
+    return {
+      stepId,
+      guardedCategory,
+      attemptCount,
+      nextAttemptOrdinal,
+      mode: 'corrective',
+      correctiveDecision,
+      posture: 'continue-fix',
+    };
+  }
+  if (correctiveDecision.decision !== 'continue-fix' && options.enforceRuntimeGate) {
+    throw correctiveDecisionBlockedError(task, stepId, attemptCount, correctiveDecision);
+  }
+  return {
+    stepId,
+    guardedCategory,
+    attemptCount,
+    nextAttemptOrdinal,
+    mode: correctiveDecision.decision === 'continue-fix' ? 'corrective' : 'ordinary',
+    correctiveDecision,
+    posture: correctiveDecision.decision === 'continue-fix' ? 'continue-fix' : correctiveDecision.decision,
+  };
+}
+
+// Current execution must respect a proved Plan obstruction immediately. Keep the
+// historical rolling classifier unchanged: older valid histories may have been
+// recorded before this gate existed and must not be reclassified as corrupt.
+export function deriveCurrentCauseDecision(
+  remediationEvents: readonly RemediationEvent[],
+  priorRemediationEvents: readonly RemediationEvent[] = [],
+): 'same-task-fix' | 'root-cause-replan' | null {
+  // A verified replacement clears the active cause, not the global attempt
+  // count or an explicit corrective decision's dirty-work continuation authority.
+  if (remediationEvents.length === 0 && priorRemediationEvents.length > 0
+    && priorRemediationEvents.every((event) => event.causeBindings !== undefined)) return 'same-task-fix';
+  if (remediationEvents.at(-1)?.causeBindings?.some(cause =>
+    cause.authority === 'external-reviewer' && cause.planConflict)) return 'root-cause-replan';
+  return deriveRollingCauseDecision(remediationEvents, priorRemediationEvents);
+}
+
+export function deriveRollingCauseDecision(
+  remediationEvents: readonly RemediationEvent[],
+  priorRemediationEvents: readonly RemediationEvent[] = [],
+): 'same-task-fix' | 'root-cause-replan' | null {
+  if (remediationEvents.length === 0 || remediationEvents.some((event) => event.causeBindings === undefined)) return null;
+  const latest = remediationEvents.at(-1)!;
+  const priorFingerprints = new Set([...priorRemediationEvents, ...remediationEvents.slice(0, -1)]
+    .flatMap((event) => event.causeBindings?.map((cause) => cause.causeFingerprint) ?? []));
+  const authoritativeRepeat = latest.causeBindings!.some((cause) =>
+    priorFingerprints.has(cause.causeFingerprint)
+    && (cause.authority === 'mechanical' || (cause.authority === 'external-reviewer' && cause.planConflict)));
+  return authoritativeRepeat ? 'root-cause-replan' : 'same-task-fix';
+}
+
+function findCurrentCorrectiveDecision(
+  task: TaskState,
+  stepId: string,
+  triggeringAttemptOrdinal: number,
+  events: readonly CorrectiveDecisionEvent[],
+): CorrectiveDecisionEvent | null {
+  const matches = events.filter((event) =>
+    event.taskId === task.id
+    && event.stepId === stepId
+    && event.triggeringAttemptCount === triggeringAttemptOrdinal,
+  );
+  if (matches.length === 0) return null;
+  if (matches.length > 1) {
+    throw new WorkflowError(
+      'STATE_CORRUPT',
+      'Multiple corrective decisions exist for the same guarded remediation binding.',
+      {
+        taskId: task.id,
+        stepId,
+        triggeringAttemptCount: triggeringAttemptOrdinal,
+        eventIds: matches.map((event) => event.eventId),
+      },
+    );
+  }
+  return matches[0]!;
+}
+
+function correctiveDecisionBlockedError(
+  task: TaskState,
+  stepId: string,
+  attemptCount: number,
+  event: CorrectiveDecisionEvent,
+): WorkflowError {
+  if (event.decision === 'replan-required') {
+    return new WorkflowError(
+      'TRANSITION_BLOCKED',
+      `Guarded Step ${stepId} cannot continue because the corrective decision requires a replan.`,
+      {
+        taskId: task.id,
+        stepId,
+        attemptCount,
+        decision: event.decision,
+        decisionEventId: event.eventId,
+        auditor: event.auditor,
+      },
+    );
+  }
+  if (event.decision === 'split-required') {
+    return new WorkflowError(
+      'TRANSITION_BLOCKED',
+      `Guarded Step ${stepId} cannot continue because the corrective decision requires splitting work into a separate Task.`,
+      {
+        taskId: task.id,
+        stepId,
+        attemptCount,
+        decision: event.decision,
+        decisionEventId: event.eventId,
+        auditor: event.auditor,
+      },
+    );
+  }
+  return new WorkflowError(
+    'TRANSITION_BLOCKED',
+    `Guarded Step ${stepId} cannot continue because the corrective decision requires coordinator escalation.`,
+    {
+      taskId: task.id,
+      stepId,
+      attemptCount,
+      decision: event.decision,
+      decisionEventId: event.eventId,
+      auditor: event.auditor,
+    },
+  );
+}
+
+function requireGuardedCategory(
+  planRiskAudit: CurrentPlanRiskAudit,
+  stepId: string,
+): GuardedRiskCategory {
+  const classification = planRiskAudit.audit.stepClassifications.find((candidate) => candidate.stepId === stepId) ?? null;
+  if (!classification || classification.categories.length === 0 || !classification.reviewRequired) {
+    throw new WorkflowError(
+      'STATE_CORRUPT',
+      `Current Plan Risk Audit does not define a guarded category for ${stepId}.`,
+      {
+        taskId: planRiskAudit.audit.taskId,
+        stepId,
+      },
+    );
+  }
+  return classification.categories[0]!;
+}
+
+function validateStoredRemediationEvent(
+  event: RemediationEvent,
+  task: TaskState,
+  file: string,
+  line: number,
+): void {
+  if (event.taskId !== task.id) {
+    throw new WorkflowError('STATE_CORRUPT', 'Remediation event taskId does not match the current Task.', {
+      file,
+      line,
+      taskId: task.id,
+      eventTaskId: event.taskId,
+    });
+  }
+  if (typeof event.stepId !== 'string' || !event.stepId.trim()) {
+    throw new WorkflowError('STATE_CORRUPT', 'Remediation event is missing stepId.', { file, line, taskId: task.id });
+  }
+  if (!REMEDIATION_FAILURE_KINDS.has(event.failureKind)) {
+    throw new WorkflowError('STATE_CORRUPT', 'Remediation event has an unknown failureKind.', {
+      file,
+      line,
+      taskId: task.id,
+      stepId: event.stepId,
+      failureKind: event.failureKind,
+    });
+  }
+  if (!REMEDIATION_MODES.has(event.mode)) {
+    throw new WorkflowError('STATE_CORRUPT', 'Remediation event has an unknown mode.', {
+      file,
+      line,
+      taskId: task.id,
+      stepId: event.stepId,
+      mode: event.mode,
+    });
+  }
+  assertCommitSha(event.failureEvidence.completionCommit, 'Remediation failure evidence completionCommit', file, line);
+  assertHash64(event.failureEvidence.checksHash, `Remediation failure evidence checksHash at ${file}:${line}`);
+  if (event.failureEvidence.reviewEventHash !== null) {
+    assertHash64(event.failureEvidence.reviewEventHash, `Remediation failure evidence reviewEventHash at ${file}:${line}`);
+  }
+  if (event.failureEvidence.reviewerAttestationHash !== null) {
+    assertHash64(
+      event.failureEvidence.reviewerAttestationHash,
+      `Remediation failure evidence reviewerAttestationHash at ${file}:${line}`,
+    );
+  }
+  const hasExecutionRevision = event.failureEvidence.executionTaskRevision !== undefined;
+  const hasDirtyWorktreeHash = event.failureEvidence.dirtyWorktreeHash !== undefined;
+  if (hasExecutionRevision !== hasDirtyWorktreeHash) {
+    throw new WorkflowError('STATE_CORRUPT', 'Remediation execution revision and dirty-worktree hash must be recorded together.', {
+      file,
+      line,
+      taskId: task.id,
+      stepId: event.stepId,
+      eventId: event.eventId,
+    });
+  }
+  if (hasExecutionRevision
+    && (!Number.isInteger(event.failureEvidence.executionTaskRevision)
+      || event.failureEvidence.executionTaskRevision! <= 0)) {
+    throw new WorkflowError('STATE_CORRUPT', 'Remediation execution task revision must be a positive integer.', {
+      file,
+      line,
+      taskId: task.id,
+      stepId: event.stepId,
+      eventId: event.eventId,
+      executionTaskRevision: event.failureEvidence.executionTaskRevision,
+    });
+  }
+  if (hasDirtyWorktreeHash) {
+    assertHash64(
+      event.failureEvidence.dirtyWorktreeHash!,
+      `Remediation dirty-worktree hash at ${file}:${line}`,
+    );
+  }
+  if (!Number.isInteger(event.attemptOrdinal) || event.attemptOrdinal <= 0) {
+    throw new WorkflowError('STATE_CORRUPT', 'Remediation event attemptOrdinal must be a positive integer.', {
+      file,
+      line,
+      taskId: task.id,
+      stepId: event.stepId,
+      attemptOrdinal: event.attemptOrdinal,
+    });
+  }
+  if (event.causeBindings !== undefined) {
+    const fingerprints = new Set<string>();
+    for (const cause of event.causeBindings) {
+      if (!['mechanical', 'external-reviewer'].includes(cause.authority)
+        || !cause.causeId?.trim()
+        || !/^[a-f0-9]{64}$/.test(cause.causeFingerprint)
+        || typeof cause.planConflict !== 'boolean'
+        || (cause.authority === 'mechanical'
+          && (cause.planConflict || cause.causeId !== `mechanical:${cause.causeFingerprint}`))
+        || (cause.authority === 'external-reviewer'
+          && reviewerCauseFingerprint(cause.causeId) !== cause.causeFingerprint)) {
+        throw new WorkflowError('STATE_CORRUPT', 'Remediation cause binding is invalid.', {
+          file, line, eventId: event.eventId,
+        });
+      }
+      if (fingerprints.has(cause.causeFingerprint)) {
+        throw new WorkflowError('STATE_CORRUPT', 'Remediation cause fingerprints must be unique per event.', {
+          file, line, eventId: event.eventId,
+        });
+      }
+      fingerprints.add(cause.causeFingerprint);
+    }
+  }
+  if (event.failureKind === 'checks-failed') {
+    if (event.failureEvidence.reviewEventHash !== null
+      || event.failureEvidence.reviewerAttestationHash !== null
+      || event.causeBindings?.some((cause) => cause.authority !== 'mechanical')) {
+      throw new WorkflowError('STATE_CORRUPT', 'checks-failed remediation events must not reference strict review sidecars.', {
+        file,
+        line,
+        taskId: task.id,
+        stepId: event.stepId,
+        eventId: event.eventId,
+      });
+    }
+    if (event.causeBindings !== undefined && (!hasExecutionRevision || !hasDirtyWorktreeHash)) {
+      throw new WorkflowError('STATE_CORRUPT', 'Native checks-failed remediation events must bind the declared execution and dirty product bytes.', {
+        file,
+        line,
+        taskId: task.id,
+        stepId: event.stepId,
+        eventId: event.eventId,
+      });
+    }
+  } else if (event.failureEvidence.reviewEventHash === null
+    || event.failureEvidence.reviewerAttestationHash === null
+    || event.causeBindings?.some((cause) => cause.authority !== 'external-reviewer')
+    || hasExecutionRevision
+    || hasDirtyWorktreeHash) {
+    throw new WorkflowError('STATE_CORRUPT', 'review-failed and review-unverified remediation events must reference both strict review sidecars.', {
+      file,
+      line,
+      taskId: task.id,
+      stepId: event.stepId,
+      eventId: event.eventId,
+    });
+  }
+}
+
+function validateStoredCorrectiveDecisionEvent(
+  event: CorrectiveDecisionEvent,
+  task: TaskState,
+  file: string,
+  line: number,
+): void {
+  if (event.taskId !== task.id) {
+    throw new WorkflowError('STATE_CORRUPT', 'Corrective decision taskId does not match the current Task.', {
+      file,
+      line,
+      taskId: task.id,
+      eventTaskId: event.taskId,
+    });
+  }
+  if (typeof event.stepId !== 'string' || !event.stepId.trim()) {
+    throw new WorkflowError('STATE_CORRUPT', 'Corrective decision is missing stepId.', { file, line, taskId: task.id });
+  }
+  if (!Number.isInteger(event.triggeringAttemptCount) || event.triggeringAttemptCount < 2) {
+    throw new WorkflowError('STATE_CORRUPT', 'Corrective decision triggeringAttemptCount must be an integer >= 2.', {
+      file,
+      line,
+      taskId: task.id,
+      stepId: event.stepId,
+      triggeringAttemptCount: event.triggeringAttemptCount,
+    });
+  }
+  if (!CORRECTIVE_DECISION_VALUES.has(event.decision)) {
+    throw new WorkflowError('STATE_CORRUPT', 'Corrective decision has an unknown decision value.', {
+      file,
+      line,
+      taskId: task.id,
+      stepId: event.stepId,
+      decision: event.decision,
+    });
+  }
+  if (typeof event.auditor !== 'string' || !event.auditor.trim()) {
+    throw new WorkflowError('STATE_CORRUPT', 'Corrective decision is missing auditor.', {
+      file,
+      line,
+      taskId: task.id,
+      stepId: event.stepId,
+    });
+  }
+  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) {
+    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.', {
+      file, line, taskId: task.id, stepId: event.stepId,
+    });
+  }
+}
+
+function validateStoredStopEscalateOverride(
+  event: StopEscalateOverrideEvent,
+  task: TaskState,
+  file: string,
+  line: number,
+): void {
+  if (!/^SOO-[0-9A-HJKMNP-TV-Z]{26}$/.test(event.eventId)) {
+    throw new WorkflowError('STATE_CORRUPT', 'Stop override eventId is malformed.', { file, line });
+  }
+  if (
+    event.taskId !== task.id
+    || !Number.isInteger(event.taskRevision)
+    || event.taskRevision < 1
+    || event.taskRevision > task.revision
+    || typeof event.stepId !== 'string'
+    || !event.stepId.trim()
+    || event.triggeringAttemptCount !== 4
+    || event.policy !== LEGACY_STOP_OVERRIDE_POLICY
+  ) {
+    throw new WorkflowError('STATE_CORRUPT', 'Stop override does not match its Task or compatibility policy.', {
+      file,
+      line,
+      taskId: task.id,
+      eventTaskId: event.taskId,
+    });
+  }
+  if (
+    !/^CRD-[0-9A-HJKMNP-TV-Z]{26}$/.test(event.stopDecisionEventId)
+    || !/^CRD-[0-9A-HJKMNP-TV-Z]{26}$/.test(event.priorContinueDecisionEventId)
+    || !COMMIT_SHA_PATTERN.test(event.headCommit)
+    || typeof event.actor !== 'string'
+    || !event.actor.trim()
+    || typeof event.reason !== 'string'
+    || !event.reason.trim()
+    || typeof event.packageVersion !== 'string'
+    || !event.packageVersion.trim()
+  ) {
+    throw new WorkflowError('STATE_CORRUPT', 'Stop override identifiers or human evidence are malformed.', {
+      file,
+      line,
+      taskId: task.id,
+    });
+  }
+  const coveredEventIds = normalizeStringList(event.coveredEventIds, 'Stop override coveredEventIds');
+  if (coveredEventIds.length !== 3 || new Set(coveredEventIds).size !== coveredEventIds.length) {
+    throw new WorkflowError('STATE_CORRUPT', 'Stop override must bind exactly three distinct remediation events.', {
+      file,
+      line,
+      taskId: task.id,
+      stepId: event.stepId,
+    });
+  }
+  for (const [label, value] of [
+    ['stopDecisionEventHash', event.stopDecisionEventHash],
+    ['priorContinueDecisionEventHash', event.priorContinueDecisionEventHash],
+    ['planHash', event.planHash],
+    ['confirmationCodeBindingHash', event.confirmationCodeBindingHash],
+  ] as const) {
+    assertHash64(value, `Stop override ${label} at ${file}:${line}`);
+  }
+  const expectedBindingHash = stopEscalateOverrideBindingHash(event);
+  if (event.confirmationCodeBindingHash !== expectedBindingHash) {
+    throw new WorkflowError('STATE_CORRUPT', 'Stop override confirmation binding hash is invalid.', {
+      file,
+      line,
+      taskId: task.id,
+      expectedBindingHash,
+      actualBindingHash: event.confirmationCodeBindingHash,
+    });
+  }
+}
+
+function validateStopEscalateOverrideHistory(
+  task: TaskState,
+  remediations: readonly RemediationEvent[],
+  decisions: readonly CorrectiveDecisionEvent[],
+  overrides: readonly StopEscalateOverrideEvent[],
+): Set<string> {
+  const overriddenDecisionIds = new Set<string>();
+  for (const override of overrides) {
+    if (overriddenDecisionIds.has(override.stopDecisionEventId)) {
+      throw new WorkflowError('STATE_CORRUPT', 'Multiple stop overrides target one corrective decision.', {
+        taskId: task.id,
+        stepId: override.stepId,
+        stopDecisionEventId: override.stopDecisionEventId,
+      });
+    }
+    const stepRemediations = remediations
+      .filter((event) => event.stepId === override.stepId && event.attemptOrdinal <= 3)
+      .sort((left, right) => left.attemptOrdinal - right.attemptOrdinal);
+    const stopDecision = decisions.find((event) => event.eventId === override.stopDecisionEventId) ?? null;
+    const priorContinue = decisions.find((event) => event.eventId === override.priorContinueDecisionEventId) ?? null;
+    if (
+      stepRemediations.length !== 3
+      || stepRemediations[0]?.attemptOrdinal !== 1
+      || stepRemediations[0]?.mode !== 'ordinary'
+      || stepRemediations[1]?.attemptOrdinal !== 2
+      || stepRemediations[1]?.mode !== 'ordinary'
+      || stepRemediations[2]?.attemptOrdinal !== 3
+      || stepRemediations[2]?.mode !== 'corrective'
+      || !stopDecision
+      || stopDecision.eventHash !== override.stopDecisionEventHash
+      || stopDecision.decision !== 'stop-escalate'
+      || stopDecision.triggeringAttemptCount !== 4
+      || stopDecision.planHash !== override.planHash
+      || !priorContinue
+      || priorContinue.eventHash !== override.priorContinueDecisionEventHash
+      || priorContinue.decision !== 'continue-fix'
+      || priorContinue.triggeringAttemptCount !== 3
+      || priorContinue.planHash !== override.planHash
+      || !sameStringArray(override.coveredEventIds, stepRemediations.map((event) => event.eventId))
+      || !sameStringArray(stopDecision.coveredEventIds, override.coveredEventIds)
+      || !sameStringArray(priorContinue.coveredEventIds, override.coveredEventIds.slice(0, 2))
+    ) {
+      throw new WorkflowError('STATE_CORRUPT', 'Stop override does not bind the exact beta.11 attempt-4 stop history.', {
+        taskId: task.id,
+        stepId: override.stepId,
+        overrideEventId: override.eventId,
+      });
+    }
+    overriddenDecisionIds.add(override.stopDecisionEventId);
+  }
+  return overriddenDecisionIds;
+}
+
+function stopEscalateOverrideBindingHash(input: {
+  taskId: string;
+  taskRevision: number;
+  stepId: string;
+  stopDecisionEventId: string;
+  stopDecisionEventHash: string;
+  priorContinueDecisionEventId: string;
+  priorContinueDecisionEventHash: string;
+  triggeringAttemptCount: 4;
+  coveredEventIds: readonly string[];
+  planHash: string;
+  headCommit: string;
+  actor: string;
+  reason: string;
+  packageVersion: string;
+  policy: typeof LEGACY_STOP_OVERRIDE_POLICY;
+}): string {
+  return hashCanonical({
+    domain: 'codex-workflow/stop-escalate-override/v1',
+    taskId: input.taskId,
+    taskRevision: input.taskRevision,
+    stepId: input.stepId,
+    stopDecisionEventId: input.stopDecisionEventId,
+    stopDecisionEventHash: input.stopDecisionEventHash,
+    priorContinueDecisionEventId: input.priorContinueDecisionEventId,
+    priorContinueDecisionEventHash: input.priorContinueDecisionEventHash,
+    triggeringAttemptCount: input.triggeringAttemptCount,
+    coveredEventIds: [...input.coveredEventIds],
+    planHash: input.planHash,
+    headCommit: input.headCommit,
+    actor: input.actor,
+    reason: input.reason,
+    packageVersion: input.packageVersion,
+    policy: input.policy,
+  });
+}
+
+function validatePlanIntegrityDecision(
+  event: CorrectiveDecisionEvent,
+  task: TaskState,
+  file: string,
+  line: number,
+): void {
+  const evidence = event.planIntegrityEvidence;
+  if (
+    event.recoveryBasis !== 'plan-integrity'
+    || !evidence
+    || (evidence.kind !== 'failed-check-component-owner-outside-allowed-writes'
+      && evidence.manifestPath !== 'package.json')
+    || !Number.isInteger(evidence.taskRevision)
+    || evidence.taskRevision < 1
+    || evidence.taskRevision > task.revision
+    || !/^[a-f0-9]{40,64}$/.test(evidence.gitHead)
+  ) {
+    throw new WorkflowError('STATE_CORRUPT', 'Corrective decision is not a valid bounded Plan-integrity recovery.', {
+      file,
+      line,
+      taskId: task.id,
+      stepId: event.stepId,
+    });
+  }
+  if (evidence.kind !== 'failed-check-component-owner-outside-allowed-writes'
+    && evidence.manifestHash !== null) {
+    assertHash64(evidence.manifestHash, `Plan-integrity manifestHash at ${file}:${line}`);
+  }
+  assertHash64(evidence.stepDefinitionHash, `Plan-integrity stepDefinitionHash at ${file}:${line}`);
+  assertHash64(evidence.conflictHash, `Plan-integrity conflictHash at ${file}:${line}`);
+  const changedFiles = normalizeStringList(evidence.changedFiles, 'Plan-integrity changedFiles');
+  let domain: string;
+  if (evidence.kind === 'missing-npm-script-outside-allowed-writes') {
+    if (event.decision !== 'replan-required'
+      || event.triggeringAttemptCount !== 2
+      || typeof evidence.remediationEventId !== 'string'
+      || !evidence.remediationEventId) {
+      throw new WorkflowError('STATE_CORRUPT', 'Legacy Plan-integrity evidence is valid only for the exact second-attempt boundary.', {
+        file, line, taskId: task.id, stepId: event.stepId,
+      });
+    }
+    assertHash64(evidence.remediationEventHash, `Plan-integrity remediationEventHash at ${file}:${line}`);
+    const missingScripts = normalizeStringList(evidence.missingScripts, 'Plan-integrity missingScripts');
+    const checkCommands = normalizeStringList(evidence.checkCommands, 'Plan-integrity checkCommands');
+    if (missingScripts.length === 0 || checkCommands.length === 0) {
+      throw new WorkflowError('STATE_CORRUPT', 'Plan-integrity evidence requires at least one missing script and check command.', {
+        file, line, taskId: task.id, stepId: event.stepId,
+      });
+    }
+    domain = 'codex-workflow/plan-integrity-conflict/v1';
+  } else if (evidence.kind === 'non-executable-npm-check-outside-allowed-writes') {
+    if (event.decision !== 'replan-required') {
+      throw new WorkflowError('STATE_CORRUPT', 'Plan-integrity v2 evidence requires replan-required.', {
+        file, line, taskId: task.id, stepId: event.stepId,
+      });
+    }
+    if (evidence.remediationEvents.length === 0
+      || event.triggeringAttemptCount !== evidence.remediationEvents.length + 1
+      || evidence.remediationEvents.some((binding, index) => {
+        if (!binding.eventId || binding.attemptOrdinal !== index + 1) return true;
+        assertHash64(binding.eventHash, `Plan-integrity remediation event hash at ${file}:${line}`);
+        return false;
+      })
+      || evidence.conflicts.length === 0
+      || evidence.conflicts.some((conflict) => {
+        if (!['MISSING_NPM_SCRIPT', 'REQUIRED_SELECTOR_MISSING'].includes(conflict.reasonCode)
+          || !conflict.script.trim()
+          || !conflict.command.trim()) return true;
+        if (conflict.runnerHash !== null) {
+          assertHash64(conflict.runnerHash, `Plan-integrity runnerHash at ${file}:${line}`);
+        }
+        return conflict.reasonCode === 'MISSING_NPM_SCRIPT'
+          ? conflict.scriptCommand !== null || conflict.runnerPath !== null || conflict.runnerHash !== null
+          : conflict.scriptCommand === null || conflict.runnerPath === null || conflict.runnerHash === null;
+      })) {
+      throw new WorkflowError('STATE_CORRUPT', 'Plan-integrity v2 evidence has invalid remediation or command-conflict bindings.', {
+        file, line, taskId: task.id, stepId: event.stepId,
+      });
+    }
+    domain = 'codex-workflow/plan-integrity-conflict/v2';
+  } else if (evidence.kind === 'check-support-anchor-outside-allowed-writes') {
+    const step = task.steps.find((candidate) => candidate.id === event.stepId) ?? null;
+    const supportPaths = [...new Set(evidence.conflicts.map((conflict) => conflict.supportPath))].sort();
+    const validateCurrentPlanBinding = event.planHash === task.planHash;
+    if (event.decision !== 'continue-fix'
+      || evidence.remediationEvents.length === 0
+      || event.triggeringAttemptCount !== evidence.remediationEvents.at(-1)!.attemptOrdinal + 1
+      || evidence.remediationEvents.some((binding, index) => {
+        if (!binding.eventId || binding.attemptOrdinal !== evidence.remediationEvents[0]!.attemptOrdinal + index) return true;
+        assertHash64(binding.eventHash, `Plan-integrity remediation event hash at ${file}:${line}`);
+        return false;
+      })
+      || evidence.conflicts.length === 0
+      || !sameStringArray(evidence.scopeExtensions, supportPaths)
+      || (validateCurrentPlanBinding && (!step
+        || evidence.scopeExtensions.some((scopePath) => pathAllowed(scopePath, step.allowedWrites)
+          || pathAllowed(scopePath, step.forbiddenScope))
+        || changedFiles.some((changedPath) => !pathAllowed(changedPath, step.allowedWrites))))
+      || evidence.conflicts.some((conflict) => {
+        assertHash64(conflict.runnerHash, `Plan-integrity runnerHash at ${file}:${line}`);
+        assertHash64(conflict.supportHash, `Plan-integrity supportHash at ${file}:${line}`);
+        return conflict.reasonCode !== 'CHECK_SUPPORT_ANCHOR_OUTSIDE_ALLOWED_WRITES'
+          || !conflict.script.trim()
+          || !conflict.command.trim()
+          || !conflict.scriptCommand.trim()
+          || !conflict.runnerPath.trim()
+          || !conflict.supportPath.trim()
+          || !conflict.importSpecifier.startsWith('.')
+          || normalizeStringList(conflict.expectedOutputPaths, 'Plan-integrity expectedOutputPaths').length === 0
+          || normalizeStringList(conflict.anchoredMigrationNames, 'Plan-integrity anchoredMigrationNames').length === 0
+          || !evidence.scopeExtensions.includes(conflict.supportPath)
+          || (validateCurrentPlanBinding && (!step || conflict.expectedOutputPaths.some((output) =>
+            !step.expectedOutputs.some((declared) =>
+              (declared.startsWith('path:') ? declared.slice(5) : declared) === output)
+            || !pathAllowed(output, step.allowedWrites))));
+      })) {
+      throw new WorkflowError('STATE_CORRUPT', 'Plan-integrity v3 evidence has invalid check-support bindings.', {
+        file, line, taskId: task.id, stepId: event.stepId,
+      });
+    }
+    domain = 'codex-workflow/plan-integrity-conflict/v3';
+  } else if (evidence.kind === 'failed-check-component-owner-outside-allowed-writes') {
+    const step = task.steps.find((candidate) => candidate.id === event.stepId) ?? null;
+    const ownerPaths = [...new Set(evidence.conflicts.map((conflict) => conflict.ownerPath))].sort();
+    const validateCurrentPlanBinding = event.planHash === task.planHash;
+    assertHash64(evidence.semanticBoundaryHash, `Plan-integrity semanticBoundaryHash at ${file}:${line}`);
+    assertHash64(evidence.failedCheckCauseFingerprint, `Plan-integrity failedCheckCauseFingerprint at ${file}:${line}`);
+    if (event.decision !== 'continue-fix'
+      || evidence.remediationEvents.length === 0
+      || event.triggeringAttemptCount !== evidence.remediationEvents.at(-1)!.attemptOrdinal + 1
+      || evidence.remediationEvents.some((binding, index) => {
+        if (!binding.eventId || binding.attemptOrdinal !== evidence.remediationEvents[0]!.attemptOrdinal + index) return true;
+        assertHash64(binding.eventHash, `Plan-integrity remediation event hash at ${file}:${line}`);
+        return false;
+      })
+      || evidence.conflicts.length === 0
+      || !sameStringArray(evidence.scopeExtensions, ownerPaths)
+      || (validateCurrentPlanBinding && (!step
+        || evidence.semanticBoundaryHash !== semanticBoundaryHash(task)
+        || evidence.scopeExtensions.some((scopePath) => pathAllowed(scopePath, step.allowedWrites)
+          || pathAllowed(scopePath, step.forbiddenScope))
+        || changedFiles.some((changedPath) => !pathAllowed(changedPath, step.allowedWrites))))
+      || evidence.conflicts.some((conflict) => {
+        assertHash64(conflict.ownerHash, `Plan-integrity component owner hash at ${file}:${line}`);
+        const importChain = normalizeStringList(conflict.importChain, 'Plan-integrity importChain');
+        return conflict.reasonCode !== 'FAILED_CHECK_COMPONENT_OWNER_OUTSIDE_ALLOWED_WRITES'
+          || !conflict.command.trim()
+          || !conflict.runnerPath.trim()
+          || !conflict.ownerPath.trim()
+          || conflict.diagnosticPath !== conflict.ownerPath
+          || !conflict.componentRoot.trim()
+          || !(conflict.ownerPath === conflict.componentRoot
+            || conflict.ownerPath.startsWith(`${conflict.componentRoot}/`))
+          || (conflict.testInvocation
+            ? !validLiteralTestInvocationEvidence(conflict) || importChain.length !== 1
+            : importChain.length < 2 || importChain.at(-1) !== conflict.ownerPath)
+          || importChain[0] !== conflict.runnerPath
+          || !evidence.scopeExtensions.includes(conflict.ownerPath);
+      })) {
+      throw new WorkflowError('STATE_CORRUPT', 'Plan-integrity v4 evidence has invalid component-owner bindings.', {
+        file, line, taskId: task.id, stepId: event.stepId,
+      });
+    }
+    domain = 'codex-workflow/plan-integrity-conflict/v4';
+  } else {
+    throw new WorkflowError('STATE_CORRUPT', 'Plan-integrity evidence kind is unsupported.', {
+      file, line, taskId: task.id, stepId: event.stepId,
+    });
+  }
+  const { conflictHash: _conflictHash, ...evidenceBase } = evidence;
+  const expectedConflictHash = hashCanonical({
+    domain,
+    taskId: task.id,
+    planHash: event.planHash,
+    stepId: event.stepId,
+    evidence: evidenceBase,
+  });
+  if (evidence.conflictHash !== expectedConflictHash) {
+    throw new WorkflowError('STATE_CORRUPT', 'Plan-integrity evidence conflictHash is invalid.', {
+      file,
+      line,
+      taskId: task.id,
+      stepId: event.stepId,
+      expectedConflictHash,
+      actualConflictHash: evidence.conflictHash,
+    });
+  }
+  if (changedFiles.some((value) => value.trim() !== value)) {
+    throw new WorkflowError('STATE_CORRUPT', 'Plan-integrity changedFiles must be normalized.', { file, line });
+  }
+}
+
+/** A validated support decision survives only a hash-verified Knowledge-only Plan chain.
+ * This preserves scope evidence, never execution authorization or a semantic replan. */
+export function isKnowledgeReboundSupportDecision(
+  store: FileStateStore, task: TaskState, event: CorrectiveDecisionEvent,
+): boolean {
+  const evidence = event.planIntegrityEvidence;
+  if (!task.planHash || event.planHash === task.planHash || event.taskId !== task.id
+    || event.recoveryBasis !== 'plan-integrity' || event.decision !== 'continue-fix'
+    || (evidence?.kind !== 'check-support-anchor-outside-allowed-writes'
+      && evidence?.kind !== 'failed-check-component-owner-outside-allowed-writes')) return false;
+  const step = task.steps.find(s => s.id === event.stepId);
+  if (!step || evidence.stepDefinitionHash !== hashCanonical({
+    id: step.id, title: step.title, objective: step.objective, requirements: step.requirements,
+    dependencies: step.dependencies, expectedOutputs: step.expectedOutputs,
+    allowedWrites: step.allowedWrites, forbiddenScope: step.forbiddenScope, checks: step.checks,
+  }) || evidence.scopeExtensions.some(p => pathAllowed(p, step.allowedWrites) || pathAllowed(p, step.forbiddenScope))
+    || (evidence.kind === 'failed-check-component-owner-outside-allowed-writes'
+      && evidence.semanticBoundaryHash !== semanticBoundaryHash(task))) return false;
+  const root = store.taskRoot(task.projectId, task.id);
+  let cursor = task.planHash;
+  const visited = new Set<string>();
+  while (cursor !== event.planHash) {
+    if (visited.has(cursor)) return false;
+    visited.add(cursor);
+    const links = task.knowledgeRebinds.filter(link => link.reboundPlanHash === cursor);
+    if (links.length !== 1 || !links[0]!.previousPlanHash) return false;
+    const link = links[0]!;
+    const before = readVerifiedPlanArtifact(root, link.previousPlanHash!, task.planHash);
+    const after = readVerifiedPlanArtifact(root, cursor, task.planHash);
+    assertKnowledgeBindingOnlyPlanChange(before, after);
+    const from = normalizePlanKnowledgeBinding(before, 'source').binding;
+    const to = normalizePlanKnowledgeBinding(after, 'target').binding;
+    if (from.revision !== link.fromKnowledgeMapRevision || from.hash !== link.fromKnowledgeMapHash
+      || to.revision !== link.toKnowledgeMapRevision || to.hash !== link.toKnowledgeMapHash) return false;
+    cursor = link.previousPlanHash!;
+  }
+  return true;
+}
+
+export function effectiveStepAllowedWrites(
+  store: FileStateStore,
+  task: TaskState,
+  stepId: string,
+): string[] {
+  const step = task.steps.find((candidate) => candidate.id === stepId);
+  if (!step) throw new WorkflowError('NOT_FOUND', `Step not found: ${stepId}`);
+  const extensions = readCorrectiveDecisionEvents(store, task)
+    .filter((event) => event.stepId === stepId
+      && (event.planHash === task.planHash || isKnowledgeReboundSupportDecision(store, task, event))
+      && event.decision === 'continue-fix'
+      && event.recoveryBasis === 'plan-integrity')
+    .flatMap((event) => event.planIntegrityEvidence?.kind === 'check-support-anchor-outside-allowed-writes'
+      || event.planIntegrityEvidence?.kind === 'failed-check-component-owner-outside-allowed-writes'
+      ? event.planIntegrityEvidence.scopeExtensions
+      : []);
+  return [...step.allowedWrites, ...new Set(extensions.filter((value) => !pathAllowed(value, step.allowedWrites)).sort())];
+}
+
+function validateStoredCorrectiveDecisionRecoveryReference(
+  event: CorrectiveDecisionRecoveryEvent,
+  task: TaskState,
+  file: string,
+  line: number,
+): void {
+  if (
+    !/^CDR-[0-9A-HJKMNP-TV-Z]{26}$/.test(event.eventId)
+    || event.taskId !== task.id
+    || event.triggeringAttemptCount !== 3
+  ) {
+    throw new WorkflowError('STATE_CORRUPT', 'Corrective recovery reference does not match the Task/ordinal.', {
+      file,
+      line,
+      taskId: task.id,
+      eventTaskId: event.taskId,
+      triggeringAttemptCount: event.triggeringAttemptCount,
+    });
+  }
+  if (typeof event.stepId !== 'string' || !event.stepId.trim() || typeof event.actor !== 'string' || !event.actor.trim()) {
+    throw new WorkflowError('STATE_CORRUPT', 'Corrective recovery reference is missing Step or actor.', { file, line });
+  }
+  for (const hash of [
+    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,
+  ]) {
+    assertHash64(hash, `Corrective recovery hash at ${file}:${line}`);
+  }
+  if (
+    !Number.isInteger(event.fromKnowledgeMapRevision)
+    || event.fromKnowledgeMapRevision < 1
+    || !Number.isInteger(event.toKnowledgeMapRevision)
+    || event.toKnowledgeMapRevision < 1
+  ) {
+    throw new WorkflowError('STATE_CORRUPT', 'Corrective recovery Knowledge Map revisions are malformed.', { file, line });
+  }
+}
+
+function validateStoredRemediationModeRecovery(
+  event: RemediationModeRecoveryEvent,
+  task: TaskState,
+  file: string,
+  line: number,
+): void {
+  if (!/^RMR-[0-9A-HJKMNP-TV-Z]{26}$/.test(event.eventId)) {
+    throw new WorkflowError('STATE_CORRUPT', 'Remediation mode recovery eventId is malformed.', { file, line });
+  }
+  if (event.taskId !== task.id || typeof event.stepId !== 'string' || !event.stepId.trim()) {
+    throw new WorkflowError('STATE_CORRUPT', 'Remediation mode recovery does not match the current Task.', {
+      file,
+      line,
+      taskId: task.id,
+      eventTaskId: event.taskId,
+    });
+  }
+  if (!Number.isInteger(event.taskRevision) || event.taskRevision < 1 || event.attemptOrdinal !== 3) {
+    throw new WorkflowError('STATE_CORRUPT', 'Remediation mode recovery has an invalid revision or ordinal.', { file, line });
+  }
+  if (
+    event.fromMode !== 'ordinary'
+    || event.toMode !== 'corrective'
+    || event.reason !== 'alpha7.2-recovered-continue-fix-mode-omission'
+  ) {
+    throw new WorkflowError('STATE_CORRUPT', 'Remediation mode recovery has an unsupported correction.', { file, line });
+  }
+  if (
+    !/^RME-[0-9A-HJKMNP-TV-Z]{26}$/.test(event.remediationEventId)
+    || !/^CRD-[0-9A-HJKMNP-TV-Z]{26}$/.test(event.correctiveDecisionEventId)
+    || !/^CDR-[0-9A-HJKMNP-TV-Z]{26}$/.test(event.correctiveDecisionRecoveryEventId)
+    || typeof event.actor !== 'string'
+    || !event.actor.trim()
+  ) {
+    throw new WorkflowError('STATE_CORRUPT', 'Remediation mode recovery identifiers are malformed.', { file, line });
+  }
+  for (const [label, value] of [
+    ['remediationEventHash', event.remediationEventHash],
+    ['correctiveDecisionEventHash', event.correctiveDecisionEventHash],
+    ['correctiveDecisionRecoveryEventHash', event.correctiveDecisionRecoveryEventHash],
+    ['planHash', event.planHash],
+  ] as const) {
+    assertHash64(value, `Remediation mode recovery ${label} at ${file}:${line}`);
+  }
+  if (event.c1ClaimEventHash !== null) assertHash64(event.c1ClaimEventHash, `Remediation mode recovery C1 hash at ${file}:${line}`);
+  if (event.writerLeaseTokenHash !== null) assertHash64(event.writerLeaseTokenHash, `Remediation mode recovery token hash at ${file}:${line}`);
+}
+
+function validateRemediationModeRecoveryBinding(
+  recovery: RemediationModeRecoveryEvent,
+  remediation: RemediationEvent,
+  decision: CorrectiveDecisionEvent,
+  correctiveRecovery: CorrectiveDecisionRecoveryEvent,
+): void {
+  const mismatches = [
+    recovery.taskId !== remediation.taskId ? 'taskId' : null,
+    recovery.stepId !== remediation.stepId ? 'stepId' : null,
+    recovery.remediationEventId !== remediation.eventId ? 'remediationEventId' : null,
+    recovery.remediationEventHash !== remediation.eventHash ? 'remediationEventHash' : null,
+    recovery.correctiveDecisionEventId !== decision.eventId ? 'correctiveDecisionEventId' : null,
+    recovery.correctiveDecisionEventHash !== decision.eventHash ? 'correctiveDecisionEventHash' : null,
+    recovery.correctiveDecisionRecoveryEventId !== correctiveRecovery.eventId ? 'correctiveDecisionRecoveryEventId' : null,
+    recovery.correctiveDecisionRecoveryEventHash !== correctiveRecovery.eventHash ? 'correctiveDecisionRecoveryEventHash' : null,
+    recovery.attemptOrdinal !== remediation.attemptOrdinal ? 'attemptOrdinal' : null,
+    recovery.planHash !== correctiveRecovery.reboundPlanHash ? 'planHash' : null,
+    recovery.actor !== correctiveRecovery.actor ? 'actor' : null,
+  ].filter((value): value is string => value !== null);
+  if (mismatches.length > 0) {
+    throw new WorkflowError('STATE_CORRUPT', 'Remediation mode recovery does not match its append-only evidence.', {
+      recoveryEventId: recovery.eventId,
+      mismatches,
+    });
+  }
+}
+
+function validateRemediationModeRecoveries(
+  store: FileStateStore,
+  task: TaskState,
+  remediations: readonly RemediationEvent[],
+  decisions: readonly CorrectiveDecisionEvent[],
+  recoveries: readonly RemediationModeRecoveryEvent[],
+): Set<string> {
+  const correctiveRecoveries = readRawCorrectiveDecisionRecoveries(store, task);
+  const recoveredEventIds = new Set<string>();
+  for (const recovery of recoveries) {
+    if (recoveredEventIds.has(recovery.remediationEventId)) {
+      throw new WorkflowError('STATE_CORRUPT', 'Duplicate remediation mode recoveries target one event.', {
+        taskId: task.id,
+        remediationEventId: recovery.remediationEventId,
+      });
+    }
+    const remediation = remediations.find((event) => event.eventId === recovery.remediationEventId) ?? null;
+    const decision = decisions.find((event) => event.eventId === recovery.correctiveDecisionEventId) ?? null;
+    const correctiveRecovery = correctiveRecoveries.find(
+      (event) => event.eventId === recovery.correctiveDecisionRecoveryEventId,
+    ) ?? null;
+    if (!remediation || !decision || !correctiveRecovery) {
+      throw new WorkflowError('STATE_CORRUPT', 'Remediation mode recovery references missing evidence.', {
+        taskId: task.id,
+        recoveryEventId: recovery.eventId,
+      });
+    }
+    if (
+      recovery.taskRevision !== task.revision
+      || recovery.planHash !== task.planHash
+      || remediation.mode !== 'ordinary'
+      || remediation.attemptOrdinal !== 3
+      || decision.decision !== 'continue-fix'
+      || decision.triggeringAttemptCount !== 3
+      || correctiveRecovery.correctiveDecisionEventId !== decision.eventId
+    ) {
+      throw new WorkflowError('STATE_CORRUPT', 'Remediation mode recovery references an ineligible lifecycle shape.', {
+        taskId: task.id,
+        recoveryEventId: recovery.eventId,
+      });
+    }
+    validateRemediationModeRecoveryBinding(recovery, remediation, decision, correctiveRecovery);
+    recoveredEventIds.add(remediation.eventId);
+  }
+  return recoveredEventIds;
+}
+
+function validateRemediationAttemptOrdinals(
+  events: readonly RemediationEvent[],
+  task: TaskState,
+): void {
+  const attemptsByStep = new Map<string, number>();
+  for (const event of events) {
+    const expectedAttemptOrdinal = (attemptsByStep.get(event.stepId) ?? 0) + 1;
+    if (event.attemptOrdinal !== expectedAttemptOrdinal) {
+      throw new WorkflowError(
+        'STATE_CORRUPT',
+        'Remediation event attemptOrdinal does not match the sidecar history for this Step.',
+        {
+          taskId: task.id,
+          stepId: event.stepId,
+          eventId: event.eventId,
+          expectedAttemptOrdinal,
+          actualAttemptOrdinal: event.attemptOrdinal,
+        },
+      );
+    }
+    attemptsByStep.set(event.stepId, event.attemptOrdinal);
+  }
+}
+
+function validateRemediationReviewReferences(
+  store: FileStateStore,
+  task: TaskState,
+  events: readonly RemediationEvent[],
+): void {
+  if (events.length === 0) return;
+  const requiresStrictReviewLookups = events.some((event) =>
+    event.failureEvidence.reviewEventHash !== null || event.failureEvidence.reviewerAttestationHash !== null,
+  );
+  if (!requiresStrictReviewLookups) {
+    for (const event of events) {
+      if (event.failureKind !== 'checks-failed') {
+        throw new WorkflowError('STATE_CORRUPT', 'Only checks-failed remediation events may omit strict review references.', {
+          taskId: task.id,
+          stepId: event.stepId,
+          eventId: event.eventId,
+          failureKind: event.failureKind,
+        });
+      }
+    }
+    return;
+  }
+  const reviewEvents = readStepReviewEvents(store, task);
+  const reviewEventsByHash = new Map(reviewEvents.map((event) => [event.eventHash, event]));
+  const reviewerAttestations = readReviewerAttestations(store, task);
+  const reviewerAttestationsByHash = new Map(reviewerAttestations.map((event) => [event.eventHash, event]));
+  const eventKeys = new Set<string>();
+  for (const event of events) {
+    const key = remediationFailureIdentityKey(event.failureKind, event.failureEvidence);
+    if (eventKeys.has(`${event.stepId}\0${key}`)) {
+      throw new WorkflowError('STATE_CORRUPT', 'Duplicate remediation events reference the same failure identity.', {
+        taskId: task.id,
+        stepId: event.stepId,
+        eventId: event.eventId,
+      });
+    }
+    eventKeys.add(`${event.stepId}\0${key}`);
+    if (event.failureEvidence.reviewEventHash === null && event.failureEvidence.reviewerAttestationHash === null) {
+      if (event.failureKind !== 'checks-failed') {
+        throw new WorkflowError('STATE_CORRUPT', 'Only checks-failed remediation events may omit strict review references.', {
+          taskId: task.id,
+          stepId: event.stepId,
+          eventId: event.eventId,
+          failureKind: event.failureKind,
+        });
+      }
+      continue;
+    }
+    if (event.failureEvidence.reviewEventHash === null || event.failureEvidence.reviewerAttestationHash === null) {
+      throw new WorkflowError('STATE_CORRUPT', 'Remediation event must provide both reviewEventHash and reviewerAttestationHash together.', {
+        taskId: task.id,
+        stepId: event.stepId,
+        eventId: event.eventId,
+      });
+    }
+    const reviewEvent = reviewEventsByHash.get(event.failureEvidence.reviewEventHash) ?? null;
+    const attestation = reviewerAttestationsByHash.get(event.failureEvidence.reviewerAttestationHash) ?? null;
+    if (!reviewEvent || !attestation) {
+      throw new WorkflowError('STATE_CORRUPT', 'Remediation event references missing strict review sidecar history.', {
+        taskId: task.id,
+        stepId: event.stepId,
+        eventId: event.eventId,
+        reviewEventHash: event.failureEvidence.reviewEventHash,
+        reviewerAttestationHash: event.failureEvidence.reviewerAttestationHash,
+      });
+    }
+    if (
+      reviewEvent.taskId !== task.id
+      || reviewEvent.stepId !== event.stepId
+      || reviewEvent.completionCommit !== event.failureEvidence.completionCommit
+      || reviewEvent.checksHash !== event.failureEvidence.checksHash
+    ) {
+      throw new WorkflowError('STATE_CORRUPT', 'Remediation event reviewEventHash does not match the exact strict review binding.', {
+        taskId: task.id,
+        stepId: event.stepId,
+        eventId: event.eventId,
+        reviewEventId: reviewEvent.eventId,
+      });
+    }
+    if (
+      attestation.taskId !== task.id
+      || attestation.stepId !== event.stepId
+      || attestation.reviewedCommit !== event.failureEvidence.completionCommit
+      || attestation.reviewEventHash !== reviewEvent.eventHash
+    ) {
+      throw new WorkflowError('STATE_CORRUPT', 'Remediation event reviewerAttestationHash does not match the exact strict review binding.', {
+        taskId: task.id,
+        stepId: event.stepId,
+        eventId: event.eventId,
+        reviewerAttestationEventId: attestation.eventId,
+      });
+    }
+    const expectedDecision = event.failureKind === 'review-failed' ? 'failed' : 'unverified';
+    if (reviewEvent.decision !== expectedDecision) {
+      throw new WorkflowError('STATE_CORRUPT', 'Remediation event failureKind does not match the referenced strict review decision.', {
+        taskId: task.id,
+        stepId: event.stepId,
+        eventId: event.eventId,
+        failureKind: event.failureKind,
+        reviewDecision: reviewEvent.decision,
+      });
+    }
+    const expectedCauses = (reviewEvent.remediationCauses ?? []).map((cause) => ({
+      authority: 'external-reviewer' as const,
+      causeId: cause.causeId,
+      causeFingerprint: cause.causeFingerprint,
+      planConflict: cause.planConflict,
+    }));
+    if (canonicalJsonStringify(event.causeBindings ?? []) !== canonicalJsonStringify(expectedCauses)) {
+      throw new WorkflowError('STATE_CORRUPT', 'Remediation reviewer causes do not match the exact strict review event.', {
+        taskId: task.id,
+        stepId: event.stepId,
+        eventId: event.eventId,
+        reviewEventId: reviewEvent.eventId,
+      });
+    }
+  }
+}
+
+function validateCorrectiveDecisionCoverage(
+  store: FileStateStore,
+  task: TaskState,
+  decisions: readonly CorrectiveDecisionEvent[],
+  remediationEvents: readonly RemediationEvent[],
+): void {
+  const remediationEventsById = new Map(remediationEvents.map((event) => [event.eventId, event]));
+  const decisionBindings = new Set<string>();
+  for (const decision of decisions) {
+    const binding = `${decision.stepId}\0${decision.triggeringAttemptCount}`;
+    if (decisionBindings.has(binding)) {
+      throw new WorkflowError('STATE_CORRUPT', 'Duplicate corrective decisions exist for the same Step and triggering ordinal.', {
+        taskId: task.id,
+        stepId: decision.stepId,
+        triggeringAttemptCount: decision.triggeringAttemptCount,
+      });
+    }
+    decisionBindings.add(binding);
+    const priorEvents = remediationEvents
+      .filter((event) => event.stepId === decision.stepId && event.attemptOrdinal < decision.triggeringAttemptCount)
+      .sort((left, right) => left.attemptOrdinal - right.attemptOrdinal);
+    const coveredEventIds = normalizeStringList(decision.coveredEventIds, 'Corrective decision coveredEventIds');
+    if (decision.triggeringAttemptCount !== priorEvents.length + 1) {
+      throw new WorkflowError('STATE_CORRUPT', 'Corrective decision triggeringAttemptCount must equal the blocked next attempt ordinal.', {
+        taskId: task.id,
+        stepId: decision.stepId,
+        decisionEventId: decision.eventId,
+        triggeringAttemptCount: decision.triggeringAttemptCount,
+        priorAttemptCount: priorEvents.length,
+      });
+    }
+    if (!sameStringArray(coveredEventIds, priorEvents.map((event) => event.eventId))) {
+      throw new WorkflowError('STATE_CORRUPT', 'Corrective decision coveredEventIds must exactly cover prior remediation events for that Step binding.', {
+        taskId: task.id,
+        stepId: decision.stepId,
+        decisionEventId: decision.eventId,
+        coveredEventIds,
+        expectedCoveredEventIds: priorEvents.map((event) => event.eventId),
+      });
+    }
+    for (const eventId of coveredEventIds) {
+      const linked = remediationEventsById.get(eventId);
+      if (!linked || linked.stepId !== decision.stepId) {
+        throw new WorkflowError('STATE_CORRUPT', 'Corrective decision coveredEventIds references an invalid remediation event.', {
+          taskId: task.id,
+          stepId: decision.stepId,
+          decisionEventId: decision.eventId,
+          eventId,
+        });
+      }
+    }
+    if (decision.recoveryBasis === 'plan-integrity') {
+      const evidence = decision.planIntegrityEvidence;
+      const bindings = evidence?.kind === 'missing-npm-script-outside-allowed-writes'
+        ? [{ eventId: evidence.remediationEventId, eventHash: evidence.remediationEventHash, attemptOrdinal: 1 }]
+        : evidence?.remediationEvents ?? [];
+      const support = evidence?.kind === 'check-support-anchor-outside-allowed-writes'
+        || evidence?.kind === 'failed-check-component-owner-outside-allowed-writes';
+      const scoped = support && bindings[0]?.attemptOrdinal !== 1
+        ? selectPlanIntegrityRemediations(store, { ...task, planHash: decision.planHash, revision: evidence.taskRevision }, priorEvents,
+            decisions.filter(d => d.stepId === decision.stepId && d.triggeringAttemptCount < decision.triggeringAttemptCount), task.planHash)
+        : priorEvents;
+      if (!evidence || !scoped
+        || bindings.length !== scoped.length
+        || scoped.some((linked, index) => linked.failureKind !== 'checks-failed'
+          || linked.eventId !== bindings[index]?.eventId
+          || linked.eventHash !== bindings[index]?.eventHash
+          || linked.attemptOrdinal !== bindings[index]?.attemptOrdinal)) {
+        throw new WorkflowError('STATE_CORRUPT', 'Plan-integrity recovery must bind the exact checks-failed remediation history.', {
+          taskId: task.id,
+          stepId: decision.stepId,
+          decisionEventId: decision.eventId,
+        });
+      }
+      if (evidence.kind === 'failed-check-component-owner-outside-allowed-writes'
+        && !priorEvents.some((linked) => linked.causeBindings?.some((cause) =>
+          cause.authority === 'mechanical'
+          && cause.causeFingerprint === evidence.failedCheckCauseFingerprint))) {
+        throw new WorkflowError('STATE_CORRUPT', 'Component-owner recovery must bind a machine-derived failed-check cause.', {
+          taskId: task.id,
+          stepId: decision.stepId,
+          decisionEventId: decision.eventId,
+        });
+      }
+    }
+  }
+}
+
+function validateHistoricalRemediationModes(
+  store: FileStateStore,
+  task: TaskState,
+  stepId: string,
+  remediationEvents: readonly RemediationEvent[],
+  correctiveDecisions: readonly CorrectiveDecisionEvent[],
+  recoveredEventIds: ReadonlySet<string>,
+  overriddenStopDecisionEventIds: ReadonlySet<string>,
+): void {
+  const causeAwareHistory = remediationEvents.length > 0
+    && remediationEvents.every((event) => event.causeBindings !== undefined);
+  if (causeAwareHistory) {
+    const audits = readPlanRiskAuditEvents(store, task);
+    const reviews = readStepReviewEvents(store, task);
+    const taskRoot = store.taskRoot(task.projectId, task.id);
+    const cycleBindings = task.planHash
+      ? remediationEvents.map((event) =>
+          resolveRemediationPlanCycleBinding(taskRoot, task.planHash!, event, reviews, audits))
+      : remediationEvents.map(() => null);
+    if (cycleBindings.every((binding) => binding !== null)) {
+      let cycleStart = 0;
+      for (let index = 0; index < remediationEvents.length; index += 1) {
+        if (index > 0 && cycleBindings[index]!.semanticHash !== cycleBindings[index - 1]!.semanticHash) {
+          cycleStart = index;
+        }
+        const cyclePrefix = remediationEvents.slice(cycleStart, index + 1);
+        const priorCycles = remediationEvents.slice(0, cycleStart);
+        if (deriveRollingCauseDecision(cyclePrefix, priorCycles) === 'root-cause-replan'
+          && index < remediationEvents.length - 1
+          && cycleBindings[index + 1]!.semanticHash === cycleBindings[index]!.semanticHash) {
+          throw new WorkflowError('STATE_CORRUPT', 'Remediation continued after an authoritative cause required semantic replan.', {
+            taskId: task.id,
+            stepId,
+            eventId: remediationEvents[index]!.eventId,
+          });
+        }
+      }
+      return;
+    }
+    for (let index = 0; index < remediationEvents.length; index += 1) {
+      const prefix = remediationEvents.slice(0, index + 1);
+      if (deriveRollingCauseDecision(prefix) === 'root-cause-replan' && index < remediationEvents.length - 1) {
+        throw new WorkflowError('STATE_CORRUPT', 'Remediation continued after an authoritative repeated cause required replan.', {
+          taskId: task.id,
+          stepId,
+          eventId: remediationEvents[index]!.eventId,
+        });
+      }
+    }
+    return;
+  }
+  for (const event of remediationEvents) {
+    if (event.attemptOrdinal <= 2) {
+      if (event.mode !== 'ordinary') {
+        throw new WorkflowError('STATE_CORRUPT', 'The first two remediation attempts must remain ordinary.', {
+          taskId: task.id,
+          stepId,
+          eventId: event.eventId,
+          attemptOrdinal: event.attemptOrdinal,
+          mode: event.mode,
+        });
+      }
+      continue;
+    }
+    if (event.mode === 'ordinary' && !recoveredEventIds.has(event.eventId)) {
+      throw new WorkflowError('STATE_CORRUPT', 'Guarded remediation attempt ordinals above 2 must not remain ordinary.', {
+        taskId: task.id,
+        stepId,
+        eventId: event.eventId,
+        attemptOrdinal: event.attemptOrdinal,
+      });
+    }
+    const priorEvents = remediationEvents
+      .filter((candidate) => candidate.stepId === stepId && candidate.attemptOrdinal < event.attemptOrdinal)
+      .sort((left, right) => left.attemptOrdinal - right.attemptOrdinal);
+    const matching = correctiveDecisions.filter((decision) =>
+      decision.taskId === task.id
+      && decision.stepId === stepId
+      && decision.triggeringAttemptCount === event.attemptOrdinal
+      && (
+        decision.decision === 'continue-fix'
+        || decision.decision === 'replan-required'
+        || (decision.decision === 'stop-escalate' && overriddenStopDecisionEventIds.has(decision.eventId))
+      )
+      && sameStringArray(decision.coveredEventIds, priorEvents.map((candidate) => candidate.eventId)),
+    );
+    if (matching.length > 1) {
+      throw new WorkflowError('STATE_CORRUPT', 'Corrective remediation mode has conflicting decisions for the exact attempt ordinal.', {
+        taskId: task.id,
+        stepId,
+        eventId: event.eventId,
+        attemptOrdinal: event.attemptOrdinal,
+        matchingDecisionIds: matching.map((decision) => decision.eventId),
+      });
+    }
+  }
+}
+
+function validateHistoricalRemediationModesForAllSteps(
+  store: FileStateStore,
+  task: TaskState,
+  remediationEvents: readonly RemediationEvent[],
+  correctiveDecisions: readonly CorrectiveDecisionEvent[],
+  recoveredEventIds: ReadonlySet<string>,
+  overriddenStopDecisionEventIds: ReadonlySet<string>,
+): void {
+  const stepIds = new Set(remediationEvents.map((event) => event.stepId));
+  for (const stepId of stepIds) {
+    const stepEvents = remediationEvents
+      .filter((event) => event.stepId === stepId)
+      .sort((left, right) => left.attemptOrdinal - right.attemptOrdinal);
+    validateHistoricalRemediationModes(
+      store,
+      task,
+      stepId,
+      stepEvents,
+      correctiveDecisions,
+      recoveredEventIds,
+      overriddenStopDecisionEventIds,
+    );
+  }
+}
+
+function validateCorrectiveDecisionAudit(audit: CorrectivePlanAuditInput): void {
+  if (!audit.auditor.trim() || !audit.summary.trim()) {
+    throw new WorkflowError('INVALID_ARGUMENT', 'Corrective decision requires auditor and summary.');
+  }
+  if (!CORRECTIVE_DECISION_VALUES.has(audit.decision)) {
+    throw new WorkflowError('INVALID_ARGUMENT', 'Corrective decision value is not supported.', {
+      decision: audit.decision,
+    });
+  }
+  normalizeStringList(audit.reviewedFindingIds, 'Corrective decision reviewedFindingIds');
+}
+
+function normalizeStringList(values: readonly string[], label: string): string[] {
+  if (!Array.isArray(values)) {
+    throw new WorkflowError('INVALID_ARGUMENT', `${label} must be an array.`);
+  }
+  const normalized = values.map((value) => {
+    if (typeof value !== 'string' || !value.trim()) {
+      throw new WorkflowError('INVALID_ARGUMENT', `${label} must contain non-empty strings.`);
+    }
+    return value.trim();
+  });
+  if (new Set(normalized).size !== normalized.length) {
+    throw new WorkflowError('INVALID_ARGUMENT', `${label} must not contain duplicates.`);
+  }
+  return normalized;
+}
+
+function remediationEventMatchesFailure(
+  event: RemediationEvent,
+  failureKind: RemediationFailureKind,
+  failureEvidence: RemediationFailureEvidence,
+): boolean {
+  if (event.failureKind !== failureKind) return false;
+  const eventExecutionRevision = event.failureEvidence.executionTaskRevision;
+  const candidateExecutionRevision = failureEvidence.executionTaskRevision;
+  if (eventExecutionRevision !== undefined || candidateExecutionRevision !== undefined) {
+    return eventExecutionRevision !== undefined
+      && candidateExecutionRevision !== undefined
+      && eventExecutionRevision === candidateExecutionRevision;
+  }
+  return event.failureEvidence.completionCommit === failureEvidence.completionCommit
+    && event.failureEvidence.checksHash === failureEvidence.checksHash
+    && event.failureEvidence.reviewEventHash === failureEvidence.reviewEventHash
+    && event.failureEvidence.reviewerAttestationHash === failureEvidence.reviewerAttestationHash;
+}
+
+function remediationFailureIdentityKey(
+  failureKind: RemediationFailureKind,
+  failureEvidence: RemediationFailureEvidence,
+): string {
+  if (failureEvidence.executionTaskRevision !== undefined) {
+    return ['execution', failureKind, String(failureEvidence.executionTaskRevision)].join('\0');
+  }
+  return [
+    failureKind,
+    failureEvidence.completionCommit,
+    failureEvidence.checksHash,
+    failureEvidence.reviewEventHash ?? '',
+    failureEvidence.reviewerAttestationHash ?? '',
+  ].join('\0');
+}
+
+function sameStringArray(left: readonly string[], right: readonly string[]): boolean {
+  return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+
+function assertCommitSha(value: string, label: string, file: string, line: number): void {
+  if (!COMMIT_SHA_PATTERN.test(value)) {
+    throw new WorkflowError('STATE_CORRUPT', `${label} must be a full lowercase Git commit SHA.`, {
+      file,
+      line,
+      value,
+    });
+  }
+}