codex-workflow-v2 2.0.0-beta.12.9 → 2.0.0-beta.13

package/dist/src/alpha6/remediation.js

@@ -1,12 +1,15 @@
 import { closeSync, existsSync, openSync, readFileSync, unlinkSync } from 'node:fs';
 import path from 'node:path';
+import { pathAllowed } from '../domain/validation.js';
 import { WorkflowError } from '../errors.js';
 import { hashCanonical } from '../lifecycle/fingerprint.js';
 import { createUlid } from '../ulid.js';
 import { PACKAGE_VERSION } from '../version.js';
-import { assertHash64, canonicalJsonStringify, sha256Hex } from './store-sidecars.js';
+import { assertHash64, canonicalJsonStringify, prepareSidecarAppend, sha256Hex, } from './store-sidecars.js';
 import { readTaskC1Posture } from './handoff.js';
 import { buildCurrentStrictStepReviewCycle, latestPassedVerifiedStepReviewEvent, readReviewerAttestations, readStepReviewEvents, } from './review.js';
+import { semanticBoundaryHash } 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';
@@ -146,9 +149,18 @@ export function stopEscalateOverrideDecisionEventIds(store, task) {
     validateCorrectiveDecisionCoverage(task, decisions, remediations);
     return validateStopEscalateOverrideHistory(task, remediations, decisions, overrides);
 }
-export function appendRemediationEvent(store, task, stepId, failureKind, failureEvidence, planRiskAudit, now, reboundStopOverrideDecisionEventId = null) {
+export function appendRemediationEvent(store, task, stepId, failureKind, failureEvidence, planRiskAudit, now, reboundStopOverrideDecisionEventId = null, causeBindings = []) {
+    const prepared = prepareRemediationEvent(store, task, stepId, failureKind, failureEvidence, planRiskAudit, now, reboundStopOverrideDecisionEventId, causeBindings);
+    if (prepared.postimage === null)
+        return prepared.event;
+    return store.appendSidecarEvent(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, task, stepId, failureKind, failureEvidence, planRiskAudit, now, reboundStopOverrideDecisionEventId = null, causeBindings = []) {
     const recoveredDecisionEventId = findCorrectiveRecoveryDecisionIdForFailure(store, task, stepId);
-    const existing = readRemediationEvents(store, task).filter((event) => event.stepId === stepId);
+    const allExisting = readRemediationEvents(store, task);
+    const existing = allExisting.filter((event) => event.stepId === stepId);
     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.', {
@@ -160,6 +172,14 @@ export function appendRemediationEvent(store, task, stepId, failureKind, failure
     }
     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 gate = deriveAttemptGateFromHistory(task, stepId, planRiskAudit, priorEvents, readCorrectiveDecisionEvents(store, task), {
             recoveredDecisionEventId,
@@ -177,14 +197,14 @@ export function appendRemediationEvent(store, task, stepId, failureKind, failure
                 actualMode: reused.mode,
             });
         }
-        return reused;
+        return { event: reused, postimage: null };
     }
     const gate = deriveAttemptGateFromHistory(task, stepId, planRiskAudit, existing, readCorrectiveDecisionEvents(store, task), {
         recoveredDecisionEventId,
         reboundStopOverrideDecisionEventId,
         overriddenStopDecisionEventIds: stopEscalateOverrideDecisionEventIds(store, task),
     });
-    return store.appendSidecarEvent(store.taskRoot(task.projectId, task.id), REMEDIATION_EVENTS_SIDECAR, {
+    const prepared = prepareSidecarAppend(allExisting, {
         eventId: `RME-${createUlid(now.getTime())}`,
         recordedAt: now.toISOString(),
         taskId: task.id,
@@ -194,9 +214,11 @@ export function appendRemediationEvent(store, task, stepId, failureKind, failure
         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, task, stepId) {
     const remediations = readRawRemediationEvents(store, task).filter((event) => event.stepId === stepId);
@@ -222,7 +244,7 @@ function findCorrectiveRecoveryDecisionIdForFailure(store, task, stepId) {
     }
     return recoveries[0]?.correctiveDecisionEventId ?? null;
 }
-export function findRemediationModeRecoveryCandidate(store, task) {
+export function findRemediationModeRecoveryCandidate(store, task, options = {}) {
     const raw = readRawRemediationEvents(store, task);
     const candidates = raw.filter((event) => event.attemptOrdinal > 2 && event.mode === 'ordinary');
     if (candidates.length === 0)
@@ -236,9 +258,9 @@ export function findRemediationModeRecoveryCandidate(store, task) {
     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);
+    return assessRemediationModeRecovery(store, task, candidates[0].stepId, actor, lease?.token ?? null, options);
 }
-export function assessRemediationModeRecovery(store, task, stepId, actor, writerToken) {
+export function assessRemediationModeRecovery(store, task, stepId, actor, writerToken, options = {}) {
     const normalizedActor = actor.trim();
     if (!normalizedActor)
         throw new WorkflowError('INVALID_ARGUMENT', 'Remediation mode recovery actor is required.');
@@ -303,7 +325,9 @@ export function assessRemediationModeRecovery(store, task, stepId, actor, writer
         });
     }
     const correctiveRecovery = correctiveRecoveries[0];
-    const authority = requireRemediationModeRecoveryAuthority(store, task, normalizedActor, writerToken);
+    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.', {
@@ -353,6 +377,14 @@ export function assessRemediationModeRecovery(store, task, stepId, actor, writer
         evidenceFingerprint,
     };
 }
+function observeRemediationModeRecoveryAuthority(store, task) {
+    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, task, stepId, expectedRevision, actor, writerToken, now) {
     if (task.revision !== expectedRevision) {
         throw new WorkflowError('STATE_CONFLICT', `State revision conflict for ${task.id}`, {
@@ -726,18 +758,34 @@ export function appendPlanIntegrityRecoveryDecision(store, task, stepId, auditor
         throw new WorkflowError('INVALID_ARGUMENT', 'Plan-integrity recovery requires a derived auditor identity.');
     }
     const remediationEvents = readRemediationEvents(store, task).filter((event) => event.stepId === stepId);
-    if (remediationEvents.length !== 1
-        || remediationEvents[0]?.attemptOrdinal !== 1
-        || remediationEvents[0]?.failureKind !== 'checks-failed'
-        || remediationEvents[0]?.eventId !== evidence.remediationEventId
-        || remediationEvents[0]?.eventHash !== evidence.remediationEventHash) {
-        throw new WorkflowError('TRANSITION_BLOCKED', 'Plan-integrity recovery requires one exact first checks-failed remediation event.', {
+    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.attemptOrdinal !== index + 1
+                || 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 decisions = readCorrectiveDecisionEvents(store, task).filter((event) => event.stepId === stepId && event.triggeringAttemptCount === 2);
+    const triggeringAttemptCount = remediationEvents.length + 1;
+    const recoveryDecision = evidence.kind === 'check-support-anchor-outside-allowed-writes'
+        || evidence.kind === 'failed-check-component-owner-outside-allowed-writes'
+        ? 'continue-fix'
+        : 'replan-required';
+    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.', {
@@ -749,7 +797,7 @@ export function appendPlanIntegrityRecoveryDecision(store, task, stepId, auditor
     if (decisions.length === 1) {
         const existing = decisions[0];
         if (existing.planHash !== task.planHash
-            || existing.decision !== 'replan-required'
+            || 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.', {
@@ -765,11 +813,11 @@ export function appendPlanIntegrityRecoveryDecision(store, task, stepId, auditor
         recordedAt: now.toISOString(),
         taskId: task.id,
         stepId,
-        triggeringAttemptCount: 2,
-        decision: 'replan-required',
+        triggeringAttemptCount,
+        decision: recoveryDecision,
         auditor: auditor.trim(),
         coveredFindingIds: [findingId],
-        coveredEventIds: [evidence.remediationEventId],
+        coveredEventIds: remediationEvents.map((event) => event.eventId),
         planHash: task.planHash,
         recoveryBasis: 'plan-integrity',
         planIntegrityEvidence: evidence,
@@ -854,22 +902,71 @@ function deriveAttemptGateFromHistory(task, stepId, planRiskAudit, remediationEv
     const attemptCount = remediationEvents.length;
     const nextAttemptOrdinal = attemptCount + 1;
     const guardedCategory = requireGuardedCategory(planRiskAudit, stepId);
-    if (attemptCount < 2) {
-        const earlyDecision = findCurrentCorrectiveDecision(task, stepId, nextAttemptOrdinal, correctiveDecisions);
-        if (attemptCount === 1
-            && earlyDecision?.recoveryBasis === 'plan-integrity'
-            && earlyDecision.decision === 'replan-required'
-            && earlyDecision.planHash === task.planHash) {
+    const rollingCauseDecision = deriveRollingCauseDecision(remediationEvents);
+    const currentCorrectiveDecision = findCurrentCorrectiveDecision(task, stepId, nextAttemptOrdinal, correctiveDecisions);
+    const planIntegrityDecision = currentCorrectiveDecision;
+    if (planIntegrityDecision?.recoveryBasis === 'plan-integrity'
+        && (planIntegrityDecision.planHash === task.planHash || planIntegrityDecision.decision === 'replan-required')) {
+        if (planIntegrityDecision.planHash !== task.planHash) {
+            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: earlyDecision,
-                posture: 'replan-required',
+                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} repeated the same authoritative cause after a claimed fix and requires root-cause 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,
@@ -880,7 +977,7 @@ function deriveAttemptGateFromHistory(task, stepId, planRiskAudit, remediationEv
             posture: 'ordinary',
         };
     }
-    const correctiveDecision = findCurrentCorrectiveDecision(task, stepId, nextAttemptOrdinal, correctiveDecisions);
+    const correctiveDecision = currentCorrectiveDecision;
     if (!correctiveDecision) {
         return {
             stepId,
@@ -974,6 +1071,16 @@ function deriveAttemptGateFromHistory(task, stepId, planRiskAudit, remediationEv
         posture: correctiveDecision.decision === 'continue-fix' ? 'continue-fix' : correctiveDecision.decision,
     };
 }
+export function deriveRollingCauseDecision(remediationEvents) {
+    if (remediationEvents.length === 0 || remediationEvents.some((event) => event.causeBindings === undefined))
+        return null;
+    const latest = remediationEvents.at(-1);
+    const priorFingerprints = new Set(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, stepId, triggeringAttemptOrdinal, events) {
     const matches = events.filter((event) => event.taskId === task.id
         && event.stepId === stepId
@@ -1068,6 +1175,32 @@ function validateStoredRemediationEvent(event, task, 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,
@@ -1077,8 +1210,33 @@ function validateStoredRemediationEvent(event, task, file, line) {
             attemptOrdinal: event.attemptOrdinal,
         });
     }
+    if (event.causeBindings !== undefined) {
+        const fingerprints = new Set();
+        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) {
+        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,
@@ -1087,8 +1245,21 @@ function validateStoredRemediationEvent(event, task, file, line) {
                 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) {
+    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,
@@ -1139,16 +1310,12 @@ function validateStoredCorrectiveDecisionEvent(event, task, file, line) {
     normalizeStringList(event.coveredFindingIds, 'Corrective decision coveredFindingIds');
     normalizeStringList(event.coveredEventIds, 'Corrective decision coveredEventIds');
     assertHash64(event.planHash, `Corrective decision planHash at ${file}:${line}`);
-    if (event.triggeringAttemptCount === 2) {
+    if (event.recoveryBasis === 'plan-integrity' || event.planIntegrityEvidence !== undefined) {
         validatePlanIntegrityDecision(event, task, file, line);
     }
-    else if (event.recoveryBasis !== undefined || event.planIntegrityEvidence !== undefined) {
-        throw new WorkflowError('STATE_CORRUPT', 'Only the bounded second-attempt replan decision may carry Plan-integrity evidence.', {
-            file,
-            line,
-            taskId: task.id,
-            stepId: event.stepId,
-            triggeringAttemptCount: event.triggeringAttemptCount,
+    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,
         });
     }
 }
@@ -1282,43 +1449,173 @@ function stopEscalateOverrideBindingHash(input) {
 function validatePlanIntegrityDecision(event, task, file, line) {
     const evidence = event.planIntegrityEvidence;
     if (event.recoveryBasis !== 'plan-integrity'
-        || event.decision !== 'replan-required'
         || !evidence
-        || evidence.kind !== 'missing-npm-script-outside-allowed-writes'
-        || evidence.manifestPath !== 'package.json'
+        || (evidence.kind !== 'failed-check-component-owner-outside-allowed-writes'
+            && evidence.manifestPath !== 'package.json')
         || !Number.isInteger(evidence.taskRevision)
         || evidence.taskRevision < 1
         || evidence.taskRevision > task.revision
-        || typeof evidence.remediationEventId !== 'string'
-        || !evidence.remediationEventId
         || !/^[a-f0-9]{40,64}$/.test(evidence.gitHead)) {
-        throw new WorkflowError('STATE_CORRUPT', 'Second-attempt corrective decision is not a valid bounded Plan-integrity recovery.', {
+        throw new WorkflowError('STATE_CORRUPT', 'Corrective decision is not a valid bounded Plan-integrity recovery.', {
             file,
             line,
             taskId: task.id,
             stepId: event.stepId,
         });
     }
-    assertHash64(evidence.remediationEventHash, `Plan-integrity remediationEventHash at ${file}:${line}`);
-    if (evidence.manifestHash !== null) {
+    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 missingScripts = normalizeStringList(evidence.missingScripts, 'Plan-integrity missingScripts');
-    const checkCommands = normalizeStringList(evidence.checkCommands, 'Plan-integrity checkCommands');
     const changedFiles = normalizeStringList(evidence.changedFiles, 'Plan-integrity changedFiles');
-    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,
+    let domain;
+    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.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
+            || !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.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
+            || !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}/`))
+                    || importChain.length < 2
+                    || importChain[0] !== conflict.runnerPath
+                    || importChain.at(-1) !== conflict.ownerPath
+                    || !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: 'codex-workflow/plan-integrity-conflict/v1',
+        domain,
         taskId: task.id,
         planHash: event.planHash,
         stepId: event.stepId,
@@ -1338,6 +1635,21 @@ function validatePlanIntegrityDecision(event, task, file, line) {
         throw new WorkflowError('STATE_CORRUPT', 'Plan-integrity changedFiles must be normalized.', { file, line });
     }
 }
+export function effectiveStepAllowedWrites(store, task, stepId) {
+    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
+        && 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, task, file, line) {
     if (!/^CDR-[0-9A-HJKMNP-TV-Z]{26}$/.test(event.eventId)
         || event.taskId !== task.id
@@ -1583,6 +1895,20 @@ function validateRemediationReviewReferences(store, task, events) {
                 reviewDecision: reviewEvent.decision,
             });
         }
+        const expectedCauses = (reviewEvent.remediationCauses ?? []).map((cause) => ({
+            authority: 'external-reviewer',
+            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(task, decisions, remediationEvents) {
@@ -1631,16 +1957,27 @@ function validateCorrectiveDecisionCoverage(task, decisions, remediationEvents)
                 });
             }
         }
-        if (decision.triggeringAttemptCount === 2) {
+        if (decision.recoveryBasis === 'plan-integrity') {
             const evidence = decision.planIntegrityEvidence;
-            const linked = priorEvents[0] ?? null;
-            if (decision.recoveryBasis !== 'plan-integrity'
-                || !evidence
-                || !linked
-                || linked.failureKind !== 'checks-failed'
-                || evidence.remediationEventId !== linked.eventId
-                || evidence.remediationEventHash !== linked.eventHash) {
-                throw new WorkflowError('STATE_CORRUPT', 'Plan-integrity recovery must bind the exact first checks-failed remediation event.', {
+            const bindings = evidence?.kind === 'missing-npm-script-outside-allowed-writes'
+                ? [{ eventId: evidence.remediationEventId, eventHash: evidence.remediationEventHash, attemptOrdinal: 1 }]
+                : evidence?.remediationEvents ?? [];
+            if (!evidence
+                || bindings.length !== priorEvents.length
+                || priorEvents.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,
@@ -1650,6 +1987,21 @@ function validateCorrectiveDecisionCoverage(task, decisions, remediationEvents)
     }
 }
 function validateHistoricalRemediationModes(task, stepId, remediationEvents, correctiveDecisions, recoveredEventIds, overriddenStopDecisionEventIds) {
+    const causeAwareHistory = remediationEvents.length > 0
+        && remediationEvents.every((event) => event.causeBindings !== undefined);
+    if (causeAwareHistory) {
+        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') {
@@ -1728,13 +2080,24 @@ function normalizeStringList(values, label) {
     return normalized;
 }
 function remediationEventMatchesFailure(event, failureKind, failureEvidence) {
-    return event.failureKind === failureKind
-        && event.failureEvidence.completionCommit === failureEvidence.completionCommit
+    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, failureEvidence) {
+    if (failureEvidence.executionTaskRevision !== undefined) {
+        return ['execution', failureKind, String(failureEvidence.executionTaskRevision)].join('\0');
+    }
     return [
         failureKind,
         failureEvidence.completionCommit,