codex-workflow-v2 2.0.0-beta.13.11 → 2.0.0-beta.13.13

package/dist/src/alpha6/remediation.js

@@ -1,6 +1,6 @@
 import { closeSync, existsSync, openSync, readFileSync, unlinkSync } from 'node:fs';
 import path from 'node:path';
-import { normalizePlanKnowledgeBinding, readVerifiedPlanArtifact } from '../domain/plan-semantics.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';
@@ -10,7 +10,8 @@ import { readPlanRiskAuditEvents } 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 { semanticBoundaryHash } from './component-owner.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';
@@ -83,7 +84,7 @@ function validateRemediationHistory(store, task) {
     const overriddenStopDecisionEventIds = validateStopEscalateOverrideHistory(task, remediationEvents, correctiveDecisionEvents, readRawStopEscalateOverrideEvents(store, task));
     validateRemediationAttemptOrdinals(remediationEvents, task);
     validateRemediationReviewReferences(store, task, remediationEvents);
-    validateCorrectiveDecisionCoverage(task, correctiveDecisionEvents, remediationEvents);
+    validateCorrectiveDecisionCoverage(store, task, correctiveDecisionEvents, remediationEvents);
     const recoveredEventIds = validateRemediationModeRecoveries(store, task, remediationEvents, correctiveDecisionEvents, modeRecoveries);
     validateHistoricalRemediationModesForAllSteps(store, task, remediationEvents, correctiveDecisionEvents, recoveredEventIds, overriddenStopDecisionEventIds);
     return {
@@ -139,7 +140,7 @@ export function readStopEscalateOverrideEvents(store, task) {
     const decisions = readRawCorrectiveDecisionEvents(store, task);
     const overrides = readRawStopEscalateOverrideEvents(store, task);
     validateRemediationAttemptOrdinals(remediations, task);
-    validateCorrectiveDecisionCoverage(task, decisions, remediations);
+    validateCorrectiveDecisionCoverage(store, task, decisions, remediations);
     validateStopEscalateOverrideHistory(task, remediations, decisions, overrides);
     return overrides;
 }
@@ -148,7 +149,7 @@ export function stopEscalateOverrideDecisionEventIds(store, task) {
     const decisions = readRawCorrectiveDecisionEvents(store, task);
     const overrides = readRawStopEscalateOverrideEvents(store, task);
     validateRemediationAttemptOrdinals(remediations, task);
-    validateCorrectiveDecisionCoverage(task, decisions, remediations);
+    validateCorrectiveDecisionCoverage(store, task, decisions, remediations);
     return validateStopEscalateOverrideHistory(task, remediations, decisions, overrides);
 }
 export function appendRemediationEvent(store, task, stepId, failureKind, failureEvidence, planRiskAudit, now, reboundStopOverrideDecisionEventId = null, causeBindings = []) {
@@ -185,7 +186,7 @@ export function prepareRemediationEvent(store, task, stepId, failureKind, failur
         }
         const priorEvents = existing.filter((event) => event.attemptOrdinal < reused.attemptOrdinal);
         const cycle = selectCurrentPlanRemediationCycle(store, task, priorEvents, correctiveDecisions);
-        const gate = deriveAttemptGateFromHistory(task, stepId, planRiskAudit, cycle.remediationEvents, cycle.correctiveDecisions, {
+        const gate = deriveAttemptGateFromHistory(store, task, stepId, planRiskAudit, cycle.remediationEvents, cycle.correctiveDecisions, {
             recoveredDecisionEventId,
             reboundStopOverrideDecisionEventId,
             overriddenStopDecisionEventIds: stopEscalateOverrideDecisionEventIds(store, task),
@@ -206,7 +207,7 @@ export function prepareRemediationEvent(store, task, stepId, failureKind, failur
         return { event: reused, postimage: null };
     }
     const cycle = selectCurrentPlanRemediationCycle(store, task, existing, correctiveDecisions);
-    const gate = deriveAttemptGateFromHistory(task, stepId, planRiskAudit, cycle.remediationEvents, cycle.correctiveDecisions, {
+    const gate = deriveAttemptGateFromHistory(store, task, stepId, planRiskAudit, cycle.remediationEvents, cycle.correctiveDecisions, {
         recoveredDecisionEventId,
         reboundStopOverrideDecisionEventId,
         overriddenStopDecisionEventIds: stopEscalateOverrideDecisionEventIds(store, task),
@@ -290,7 +291,7 @@ export function assessRemediationModeRecovery(store, task, stepId, actor, writer
     const decisions = readRawCorrectiveDecisionEvents(store, task);
     validateRemediationAttemptOrdinals(remediations, task);
     validateRemediationReviewReferences(store, task, remediations);
-    validateCorrectiveDecisionCoverage(task, decisions, 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.', {
@@ -766,7 +767,11 @@ export function appendPlanIntegrityRecoveryDecision(store, task, stepId, auditor
     if (!auditor.trim()) {
         throw new WorkflowError('INVALID_ARGUMENT', 'Plan-integrity recovery requires a derived auditor identity.');
     }
-    const remediationEvents = readRemediationEvents(store, task).filter((event) => event.stepId === stepId);
+    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,
@@ -777,8 +782,7 @@ export function appendPlanIntegrityRecoveryDecision(store, task, stepId, auditor
     if (remediationEvents.length !== expectedBindings.length
         || remediationEvents.some((event, index) => {
             const binding = expectedBindings[index];
-            return event.attemptOrdinal !== index + 1
-                || event.failureKind !== 'checks-failed'
+            return event.failureKind !== 'checks-failed'
                 || event.eventId !== binding?.eventId
                 || event.eventHash !== binding.eventHash
                 || event.attemptOrdinal !== binding.attemptOrdinal;
@@ -789,7 +793,7 @@ export function appendPlanIntegrityRecoveryDecision(store, task, stepId, auditor
             remediationEventIds: remediationEvents.map((event) => event.eventId),
         });
     }
-    const triggeringAttemptCount = remediationEvents.length + 1;
+    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'
@@ -826,7 +830,7 @@ export function appendPlanIntegrityRecoveryDecision(store, task, stepId, auditor
         decision: recoveryDecision,
         auditor: auditor.trim(),
         coveredFindingIds: [findingId],
-        coveredEventIds: remediationEvents.map((event) => event.eventId),
+        coveredEventIds: allRemediationEvents.map((event) => event.eventId),
         planHash: task.planHash,
         recoveryBasis: 'plan-integrity',
         planIntegrityEvidence: evidence,
@@ -836,7 +840,7 @@ export function appendPlanIntegrityRecoveryDecision(store, task, stepId, auditor
 }
 export function assertGuardedRemediationAttemptAllowed(store, task, stepId, planRiskAudit, recoveredDecisionEventId = null, reboundStopOverrideDecisionEventId = null) {
     const history = readOpenGuardedRemediationHistory(store, task, stepId);
-    return deriveAttemptGateFromHistory(task, stepId, planRiskAudit, history.remediationEvents, history.correctiveDecisions, {
+    return deriveAttemptGateFromHistory(store, task, stepId, planRiskAudit, history.remediationEvents, history.correctiveDecisions, {
         enforceRuntimeGate: true,
         recoveredDecisionEventId,
         reboundStopOverrideDecisionEventId,
@@ -866,7 +870,7 @@ export function readGuardedRemediationPostureForStep(store, task, stepId, planRi
         && deriveCurrentCauseDecision(remediationEvents, history.priorRemediationEvents) !== 'root-cause-replan')
         return null;
     if (step.status === 'failed' || step.status === 'planned') {
-        return deriveAttemptGateFromHistory(task, stepId, planRiskAudit, remediationEvents, history.correctiveDecisions, {
+        return deriveAttemptGateFromHistory(store, task, stepId, planRiskAudit, remediationEvents, history.correctiveDecisions, {
             overriddenStopDecisionEventIds: stopEscalateOverrideDecisionEventIds(store, task),
             priorRemediationEvents: history.priorRemediationEvents,
             nextAttemptOrdinal: history.nextAttemptOrdinal,
@@ -877,7 +881,7 @@ export function readGuardedRemediationPostureForStep(store, task, stepId, planRi
     const currentCycle = buildCurrentStrictStepReviewCycle(store, task, stepId);
     if (currentCycle.resolution !== 'unverified')
         return null;
-    return deriveAttemptGateFromHistory(task, stepId, planRiskAudit, remediationEvents, history.correctiveDecisions, {
+    return deriveAttemptGateFromHistory(store, task, stepId, planRiskAudit, remediationEvents, history.correctiveDecisions, {
         overriddenStopDecisionEventIds: stopEscalateOverrideDecisionEventIds(store, task),
         priorRemediationEvents: history.priorRemediationEvents,
         nextAttemptOrdinal: history.nextAttemptOrdinal,
@@ -898,7 +902,7 @@ function readOpenGuardedRemediationHistory(store, task, stepId) {
         nextAttemptOrdinal: allStepRemediations.length + 1,
     };
 }
-function selectCurrentPlanRemediationCycle(store, task, remediationEvents, correctiveDecisions) {
+function selectCurrentPlanRemediationCycle(store, task, remediationEvents, correctiveDecisions, canonicalPlanHash = task.planHash) {
     const unchanged = () => ({
         remediationEvents: [...remediationEvents],
         priorRemediationEvents: [],
@@ -916,13 +920,13 @@ function selectCurrentPlanRemediationCycle(store, task, remediationEvents, corre
     const taskRoot = store.taskRoot(task.projectId, task.id);
     let currentSemanticHash;
     try {
-        currentSemanticHash = normalizePlanKnowledgeBinding(readVerifiedPlanArtifact(taskRoot, task.planHash, task.planHash), 'current').semanticHash;
+        currentSemanticHash = normalizePlanKnowledgeBinding(readVerifiedPlanArtifact(taskRoot, task.planHash, canonicalPlanHash), 'current').semanticHash;
     }
     catch {
         return unchanged();
     }
     const reviews = readStepReviewEvents(store, task);
-    const bindings = remediationEvents.map((event) => resolveRemediationPlanCycleBinding(taskRoot, task.planHash, event, reviews, audits));
+    const bindings = remediationEvents.map((event) => resolveRemediationPlanCycleBinding(taskRoot, canonicalPlanHash, event, reviews, audits));
     if (bindings.some((binding) => binding === null))
         return unchanged();
     let cycleStart = remediationEvents.length;
@@ -939,6 +943,71 @@ function selectCurrentPlanRemediationCycle(store, task, remediationEvents, corre
         correctiveDecisions: [...correctiveDecisions],
     };
 }
+/** Scope mechanical support evidence only; global corrective authority is never discarded. */
+export function selectPlanIntegrityRemediations(store, task, events, decisions, canonicalPlanHash = task.planHash) {
+    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) => {
+        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();
+    const planBytes = (hash) => 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, currentPlanHash, event, reviews, audits) {
     let planHash = null;
     let sourceTaskRevision = null;
@@ -994,7 +1063,7 @@ export function findFailedGuardedStepRequiringCorrectiveDecision(store, task, pl
         ? posture
         : null;
 }
-function deriveAttemptGateFromHistory(task, stepId, planRiskAudit, remediationEvents, correctiveDecisions, options = {}) {
+function deriveAttemptGateFromHistory(store, task, stepId, planRiskAudit, remediationEvents, correctiveDecisions, options = {}) {
     const attemptCount = remediationEvents.length + (options.priorRemediationEvents?.length ?? 0);
     const nextAttemptOrdinal = options.nextAttemptOrdinal ?? attemptCount + 1;
     const guardedCategory = requireGuardedCategory(planRiskAudit, stepId);
@@ -1002,8 +1071,9 @@ function deriveAttemptGateFromHistory(task, stepId, planRiskAudit, remediationEv
     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) {
+        && (planIntegrityDecision.planHash === task.planHash || planIntegrityDecision.decision === 'replan-required'
+            || isKnowledgeReboundSupportDecision(store, task, planIntegrityDecision))) {
+        if (planIntegrityDecision.planHash !== task.planHash && planIntegrityDecision.decision === 'replan-required') {
             return {
                 stepId,
                 guardedCategory,
@@ -1638,9 +1708,9 @@ function validatePlanIntegrityDecision(event, task, file, line) {
         const validateCurrentPlanBinding = event.planHash === task.planHash;
         if (event.decision !== 'continue-fix'
             || evidence.remediationEvents.length === 0
-            || event.triggeringAttemptCount !== evidence.remediationEvents.length + 1
+            || event.triggeringAttemptCount !== evidence.remediationEvents.at(-1).attemptOrdinal + 1
             || evidence.remediationEvents.some((binding, index) => {
-                if (!binding.eventId || binding.attemptOrdinal !== index + 1)
+                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;
@@ -1681,9 +1751,9 @@ function validatePlanIntegrityDecision(event, task, 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
+            || event.triggeringAttemptCount !== evidence.remediationEvents.at(-1).attemptOrdinal + 1
             || evidence.remediationEvents.some((binding, index) => {
-                if (!binding.eventId || binding.attemptOrdinal !== index + 1)
+                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;
@@ -1706,9 +1776,10 @@ function validatePlanIntegrityDecision(event, task, file, line) {
                     || !conflict.componentRoot.trim()
                     || !(conflict.ownerPath === conflict.componentRoot
                         || conflict.ownerPath.startsWith(`${conflict.componentRoot}/`))
-                    || importChain.length < 2
+                    || (conflict.testInvocation
+                        ? !validLiteralTestInvocationEvidence(conflict) || importChain.length !== 1
+                        : importChain.length < 2 || importChain.at(-1) !== conflict.ownerPath)
                     || 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.', {
@@ -1744,13 +1815,54 @@ function validatePlanIntegrityDecision(event, task, file, line) {
         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, task, event) {
+    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();
+    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, 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.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'
@@ -2020,7 +2132,7 @@ function validateRemediationReviewReferences(store, task, events) {
         }
     }
 }
-function validateCorrectiveDecisionCoverage(task, decisions, remediationEvents) {
+function validateCorrectiveDecisionCoverage(store, task, decisions, remediationEvents) {
     const remediationEventsById = new Map(remediationEvents.map((event) => [event.eventId, event]));
     const decisionBindings = new Set();
     for (const decision of decisions) {
@@ -2071,9 +2183,14 @@ function validateCorrectiveDecisionCoverage(task, decisions, remediationEvents)
             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'
+            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)) {