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

package/dist/src/alpha6/remediation.js

@@ -1,23 +1,22 @@
-import { closeSync, existsSync, openSync, readFileSync, unlinkSync } from 'node:fs';
+import { existsSync } 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';
 import { createUlid } from '../ulid.js';
-import { PACKAGE_VERSION } from '../version.js';
 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';
+import { readFailedStepPlanningRecovery } from './failed-step-planning-recovery.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';
 const COMMIT_SHA_PATTERN = /^[a-f0-9]{40}$/;
@@ -83,7 +82,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 +138,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 +147,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 +184,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 +205,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),
@@ -253,281 +252,31 @@ function findCorrectiveRecoveryDecisionIdForFailure(store, task, stepId) {
     }
     return recoveries[0]?.correctiveDecisionEventId ?? null;
 }
-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)
+/** A first failed execution plus immutable rebound obstruction is planning evidence, not permission to retry. */
+export function firstFailurePlanningObstructionEvidence(store, task, stepId) {
+    const failures = readRemediationEvents(store, task).filter(event => event.stepId === stepId);
+    if (failures.length !== 1 || task.steps.find(step => step.id === stepId)?.status !== 'failed')
+        return null;
+    const recovery = readFailedStepPlanningRecovery(store, task);
+    if (!recovery || !recovery.current.reviewRequiredStepIds.includes(stepId))
         return null;
-    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, task, stepId, actor, writerToken, options = {}) {
-    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(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 !== 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, 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}`, {
-            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;
-    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;
-        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(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, task, actor, writerToken) {
-    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,
+        kind: 'first-failure-rebound-planning-obstruction', taskRevision: task.revision,
+        sourcePlanHash: task.planHash, baselinePlanHash: recovery.baseline.planHash,
+        baselineAuditEventId: recovery.baseline.eventId, baselineAuditEventHash: recovery.baseline.eventHash,
+        obstructionAuditEventId: recovery.current.audit.eventId, obstructionAuditEventHash: recovery.current.audit.eventHash,
+        priorAuthorizationHash: hashCanonical(recovery.priorAuthorization),
+        remediationEventId: failures[0].eventId, remediationEventHash: failures[0].eventHash,
+        knowledgeRebindCount: task.knowledgeRebinds.length, knowledgeRebindHash: hashCanonical(task.knowledgeRebinds),
     };
 }
-function readWriterLeaseForModeRecovery(store, task) {
-    const file = path.join(store.lockRoot(task.projectId), `${task.id}.json`);
-    if (!existsSync(file))
-        return null;
-    let lease;
-    try {
-        lease = JSON.parse(readFileSync(file, 'utf8'));
-    }
-    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, task, stepId, correctiveAudit, planRiskAudit, planHash, now) {
     validateCorrectiveDecisionAudit(correctiveAudit);
     const remediationEvents = readRemediationEvents(store, task).filter((event) => event.stepId === stepId);
     const triggeringAttemptCount = remediationEvents.length + 1;
-    if (triggeringAttemptCount < 3) {
+    const planningObstructionEvidence = triggeringAttemptCount === 2 && correctiveAudit.decision === 'replan-required'
+        ? firstFailurePlanningObstructionEvidence(store, task, stepId) : null;
+    if (triggeringAttemptCount < 3 && !planningObstructionEvidence) {
         throw new WorkflowError('TRANSITION_BLOCKED', `Corrective decision is not available for ${stepId} before two guarded remediation failures exist.`, {
             taskId: task.id,
             stepId,
@@ -581,6 +330,7 @@ export function appendCorrectiveDecisionEvent(store, task, stepId, correctiveAud
         stepId,
         triggeringAttemptCount,
         decision: correctiveAudit.decision,
+        ...(planningObstructionEvidence ? { recoveryBasis: 'planning-obstruction', planningObstructionEvidence } : {}),
         auditor: correctiveAudit.auditor.trim(),
         coveredFindingIds,
         coveredEventIds,
@@ -589,176 +339,6 @@ export function appendCorrectiveDecisionEvent(store, task, stepId, correctiveAud
         validateEvent: (event, context) => validateStoredCorrectiveDecisionEvent(event, task, context.file, context.line),
     });
 }
-export function prepareStopEscalateOverride(store, task, stepId, expectedRevision, actor, reason, headCommit) {
-    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,
-        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, task, stepId, expectedRevision, actor, reason, headCommit, confirmationCode, now) {
-    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;
-    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(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, task, stepId, auditor, evidence, now) {
     if (!task.planHash) {
         throw new WorkflowError('STATE_CORRUPT', `Task ${task.id} has no Plan hash for Plan-integrity recovery.`);
@@ -766,7 +346,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 +361,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 +372,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 +409,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 +419,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,
@@ -861,12 +444,17 @@ export function readGuardedRemediationPostureForStep(store, task, stepId, planRi
         ? findCurrentCorrectiveDecision(task, stepId, 2, history.correctiveDecisions)
         : null;
     const currentDecision = findCurrentCorrectiveDecision(task, stepId, history.nextAttemptOrdinal, history.correctiveDecisions);
+    if (remediationEvents.length === 1 && currentDecision === null
+        && firstFailurePlanningObstructionEvidence(store, task, stepId)) {
+        return { stepId, guardedCategory: requireGuardedCategory(planRiskAudit, stepId), attemptCount: 1,
+            nextAttemptOrdinal: history.nextAttemptOrdinal, mode: 'corrective', correctiveDecision: null, posture: 'decision-required' };
+    }
     if (remediationEvents.length < 2 && earlyPlanIntegrityDecision?.recoveryBasis !== 'plan-integrity'
         && currentDecision === null
         && deriveCurrentCauseDecision(remediationEvents, history.priorRemediationEvents) !== 'root-cause-replan')
         return null;
     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 +465,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 +486,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 +504,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 +527,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,16 +647,22 @@ 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);
     const rollingCauseDecision = deriveCurrentCauseDecision(remediationEvents, options.priorRemediationEvents ?? []);
     const currentCorrectiveDecision = findCurrentCorrectiveDecision(task, stepId, nextAttemptOrdinal, correctiveDecisions);
+    if (currentCorrectiveDecision?.recoveryBasis === 'planning-obstruction') {
+        return { stepId, guardedCategory, attemptCount, nextAttemptOrdinal, mode: 'ordinary',
+            correctiveDecision: currentCorrectiveDecision,
+            posture: currentCorrectiveDecision.planHash === task.planHash ? 'replan-required' : 'replan-ready' };
+    }
     const planIntegrityDecision = currentCorrectiveDecision;
     if (planIntegrityDecision?.recoveryBasis === 'plan-integrity'
-        && (planIntegrityDecision.planHash === task.planHash || planIntegrityDecision.decision === 'replan-required')) {
-        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,
@@ -1310,6 +969,17 @@ function validateStoredRemediationEvent(event, task, file, line) {
     if (hasDirtyWorktreeHash) {
         assertHash64(event.failureEvidence.dirtyWorktreeHash, `Remediation dirty-worktree hash at ${file}:${line}`);
     }
+    const boundary = event.failureEvidence.unclaimedExecutionBoundary;
+    if (boundary !== undefined) {
+        if (!boundary || typeof boundary !== 'object' || Array.isArray(boundary)
+            || Object.keys(boundary).sort().join(',') !== 'actor,kind,priorHandoffEventHash'
+            || boundary.kind !== 'native-unclaimed-check-failure'
+            || typeof boundary.actor !== 'string' || !boundary.actor.trim() || boundary.actor !== boundary.actor.trim()
+            || !(boundary.priorHandoffEventHash === null || typeof boundary.priorHandoffEventHash === 'string' && /^[a-f0-9]{64}$/.test(boundary.priorHandoffEventHash))
+            || event.failureKind !== 'checks-failed' || !hasExecutionRevision || !hasDirtyWorktreeHash) {
+            throw new WorkflowError('STATE_CORRUPT', 'Invalid native unclaimed execution boundary.', { file, line, eventId: event.eventId });
+        }
+    }
     if (!Number.isInteger(event.attemptOrdinal) || event.attemptOrdinal <= 0) {
         throw new WorkflowError('STATE_CORRUPT', 'Remediation event attemptOrdinal must be a positive integer.', {
             file,
@@ -1419,7 +1089,21 @@ 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.recoveryBasis === 'plan-integrity' || event.planIntegrityEvidence !== undefined) {
+    if (event.recoveryBasis === 'planning-obstruction' || event.planningObstructionEvidence !== undefined) {
+        const evidence = event.planningObstructionEvidence;
+        if (!evidence || event.recoveryBasis !== 'planning-obstruction' || event.planIntegrityEvidence !== undefined
+            || evidence.kind !== 'first-failure-rebound-planning-obstruction' || event.decision !== 'replan-required'
+            || event.triggeringAttemptCount !== 2 || evidence.sourcePlanHash !== event.planHash
+            || !Number.isSafeInteger(evidence.taskRevision) || evidence.taskRevision < 1
+            || !Number.isSafeInteger(evidence.knowledgeRebindCount) || evidence.knowledgeRebindCount < 1
+            || event.coveredEventIds.length !== 1 || event.coveredEventIds[0] !== evidence.remediationEventId) {
+            throw new WorkflowError('STATE_CORRUPT', 'First-failure planning obstruction requires exact bounded proof.', { file, line, taskId: task.id });
+        }
+        for (const key of ['sourcePlanHash', 'baselinePlanHash', 'baselineAuditEventHash', 'obstructionAuditEventHash',
+            'priorAuthorizationHash', 'remediationEventHash', 'knowledgeRebindHash'])
+            assertHash64(evidence[key], `Planning obstruction ${key}`);
+    }
+    else if (event.recoveryBasis === 'plan-integrity' || event.planIntegrityEvidence !== undefined) {
         validatePlanIntegrityDecision(event, task, file, line);
     }
     else if (event.triggeringAttemptCount === 2) {
@@ -1638,9 +1322,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 +1365,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 +1390,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 +1429,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 +1746,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) {
@@ -2066,14 +1792,39 @@ function validateCorrectiveDecisionCoverage(task, decisions, remediationEvents)
                 });
             }
         }
+        if (decision.recoveryBasis === 'planning-obstruction') {
+            const proof = decision.planningObstructionEvidence;
+            const audits = readPlanRiskAuditEvents(store, task);
+            const baseline = audits.find(event => event.eventId === proof.baselineAuditEventId && event.eventHash === proof.baselineAuditEventHash);
+            const obstruction = audits.find(event => event.eventId === proof.obstructionAuditEventId && event.eventHash === proof.obstructionAuditEventHash);
+            const failed = priorEvents[0];
+            if (!baseline || !obstruction || !['approved', 'approved-with-rationale'].includes(baseline.decision)
+                || obstruction.decision !== 'stop-escalate' || audits.indexOf(baseline) >= audits.indexOf(obstruction)
+                || baseline.planHash !== proof.baselinePlanHash || obstruction.planHash !== proof.sourcePlanHash
+                || obstruction.taskRevision !== proof.taskRevision
+                || baseline.briefHash !== obstruction.briefHash || baseline.briefHash !== task.briefHash
+                || !failed || priorEvents.length !== 1 || failed.eventId !== proof.remediationEventId || failed.eventHash !== proof.remediationEventHash
+                || !task.authorizations.some(authorization => authorization.kind === 'execution' && authorization.decision === 'superseded'
+                    && authorization.planHash === baseline.planHash && authorization.briefHash === baseline.briefHash
+                    && hashCanonical(authorization) === proof.priorAuthorizationHash)
+                || task.knowledgeRebinds.length < proof.knowledgeRebindCount
+                || hashCanonical(task.knowledgeRebinds.slice(0, proof.knowledgeRebindCount)) !== proof.knowledgeRebindHash) {
+                throw new WorkflowError('STATE_CORRUPT', 'Planning-obstruction decision does not match immutable audit, authorization, rebind and failure history.', { taskId: task.id, decisionEventId: decision.eventId });
+            }
+        }
         if (decision.recoveryBasis === 'plan-integrity') {
             const evidence = decision.planIntegrityEvidence;
             const bindings = evidence?.kind === 'missing-npm-script-outside-allowed-writes'
                 ? [{ 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)) {