codex-workflow-v2 2.0.0-beta.13.3 → 2.0.0-beta.13.5

package/dist/src/alpha6/remediation.js

@@ -1,10 +1,12 @@
 import { closeSync, existsSync, openSync, readFileSync, unlinkSync } from 'node:fs';
 import path from 'node:path';
+import { 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';
@@ -83,7 +85,7 @@ function validateRemediationHistory(store, task) {
     validateRemediationReviewReferences(store, task, remediationEvents);
     validateCorrectiveDecisionCoverage(task, correctiveDecisionEvents, remediationEvents);
     const recoveredEventIds = validateRemediationModeRecoveries(store, task, remediationEvents, correctiveDecisionEvents, modeRecoveries);
-    validateHistoricalRemediationModesForAllSteps(task, remediationEvents, correctiveDecisionEvents, recoveredEventIds, overriddenStopDecisionEventIds);
+    validateHistoricalRemediationModesForAllSteps(store, task, remediationEvents, correctiveDecisionEvents, recoveredEventIds, overriddenStopDecisionEventIds);
     return {
         remediationEvents,
         correctiveDecisionEvents,
@@ -161,6 +163,7 @@ export function prepareRemediationEvent(store, task, stepId, failureKind, failur
     const recoveredDecisionEventId = findCorrectiveRecoveryDecisionIdForFailure(store, task, stepId);
     const allExisting = readRemediationEvents(store, task);
     const existing = allExisting.filter((event) => event.stepId === stepId);
+    const correctiveDecisions = readCorrectiveDecisionEvents(store, task);
     const matching = existing.filter((event) => remediationEventMatchesFailure(event, failureKind, failureEvidence));
     if (matching.length > 1) {
         throw new WorkflowError('STATE_CORRUPT', 'Multiple remediation events match the same failure identity.', {
@@ -181,10 +184,13 @@ export function prepareRemediationEvent(store, task, stepId, failureKind, failur
             });
         }
         const priorEvents = existing.filter((event) => event.attemptOrdinal < reused.attemptOrdinal);
-        const gate = deriveAttemptGateFromHistory(task, stepId, planRiskAudit, priorEvents, readCorrectiveDecisionEvents(store, task), {
+        const cycle = selectCurrentPlanRemediationCycle(store, task, priorEvents, correctiveDecisions);
+        const gate = deriveAttemptGateFromHistory(task, stepId, planRiskAudit, cycle.remediationEvents, cycle.correctiveDecisions, {
             recoveredDecisionEventId,
             reboundStopOverrideDecisionEventId,
             overriddenStopDecisionEventIds: stopEscalateOverrideDecisionEventIds(store, task),
+            priorRemediationEvents: cycle.priorRemediationEvents,
+            nextAttemptOrdinal: reused.attemptOrdinal,
         });
         if (reused.attemptOrdinal !== gate.nextAttemptOrdinal || reused.mode !== gate.mode || reused.guardedCategory !== gate.guardedCategory) {
             throw new WorkflowError('STATE_CORRUPT', 'Existing remediation event conflicts with the current guarded retry binding.', {
@@ -199,10 +205,13 @@ export function prepareRemediationEvent(store, task, stepId, failureKind, failur
         }
         return { event: reused, postimage: null };
     }
-    const gate = deriveAttemptGateFromHistory(task, stepId, planRiskAudit, existing, readCorrectiveDecisionEvents(store, task), {
+    const cycle = selectCurrentPlanRemediationCycle(store, task, existing, correctiveDecisions);
+    const gate = deriveAttemptGateFromHistory(task, stepId, planRiskAudit, cycle.remediationEvents, cycle.correctiveDecisions, {
         recoveredDecisionEventId,
         reboundStopOverrideDecisionEventId,
         overriddenStopDecisionEventIds: stopEscalateOverrideDecisionEventIds(store, task),
+        priorRemediationEvents: cycle.priorRemediationEvents,
+        nextAttemptOrdinal: existing.length + 1,
     });
     const prepared = prepareSidecarAppend(allExisting, {
         eventId: `RME-${createUlid(now.getTime())}`,
@@ -832,6 +841,8 @@ export function assertGuardedRemediationAttemptAllowed(store, task, stepId, plan
         recoveredDecisionEventId,
         reboundStopOverrideDecisionEventId,
         overriddenStopDecisionEventIds: stopEscalateOverrideDecisionEventIds(store, task),
+        priorRemediationEvents: history.priorRemediationEvents,
+        nextAttemptOrdinal: history.nextAttemptOrdinal,
     });
 }
 export function readGuardedRemediationPostureForStep(store, task, stepId, planRiskAudit) {
@@ -849,12 +860,16 @@ export function readGuardedRemediationPostureForStep(store, task, stepId, planRi
     const earlyPlanIntegrityDecision = remediationEvents.length === 1
         ? findCurrentCorrectiveDecision(task, stepId, 2, history.correctiveDecisions)
         : null;
+    const currentDecision = findCurrentCorrectiveDecision(task, stepId, history.nextAttemptOrdinal, history.correctiveDecisions);
     if (remediationEvents.length < 2 && earlyPlanIntegrityDecision?.recoveryBasis !== 'plan-integrity'
-        && deriveCurrentCauseDecision(remediationEvents) !== 'root-cause-replan')
+        && 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, {
             overriddenStopDecisionEventIds: stopEscalateOverrideDecisionEventIds(store, task),
+            priorRemediationEvents: history.priorRemediationEvents,
+            nextAttemptOrdinal: history.nextAttemptOrdinal,
         });
     }
     if (task.status !== 'blocked' || step.status !== 'in_progress' || !step.evidence)
@@ -864,19 +879,99 @@ export function readGuardedRemediationPostureForStep(store, task, stepId, planRi
         return null;
     return deriveAttemptGateFromHistory(task, stepId, planRiskAudit, remediationEvents, history.correctiveDecisions, {
         overriddenStopDecisionEventIds: stopEscalateOverrideDecisionEventIds(store, task),
+        priorRemediationEvents: history.priorRemediationEvents,
+        nextAttemptOrdinal: history.nextAttemptOrdinal,
     });
 }
 function readOpenGuardedRemediationHistory(store, task, stepId) {
-    const remediationEvents = readRemediationEvents(store, task).filter((event) => event.stepId === stepId);
-    const correctiveDecisions = readCorrectiveDecisionEvents(store, task).filter((event) => event.stepId === stepId);
+    const allStepRemediations = readRemediationEvents(store, task).filter((event) => event.stepId === stepId);
+    const allStepDecisions = readCorrectiveDecisionEvents(store, task).filter((event) => event.stepId === stepId);
     const passedBoundary = latestPassedVerifiedStepReviewEvent(store, task, stepId);
-    if (!passedBoundary)
-        return { remediationEvents, correctiveDecisions };
+    const remediationEvents = passedBoundary
+        ? allStepRemediations.filter((event) => event.recordedAt > passedBoundary.recordedAt)
+        : allStepRemediations;
+    const correctiveDecisions = passedBoundary
+        ? allStepDecisions.filter((event) => event.recordedAt > passedBoundary.recordedAt)
+        : allStepDecisions;
     return {
-        remediationEvents: remediationEvents.filter((event) => event.recordedAt > passedBoundary.recordedAt),
-        correctiveDecisions: correctiveDecisions.filter((event) => event.recordedAt > passedBoundary.recordedAt),
+        ...selectCurrentPlanRemediationCycle(store, task, remediationEvents, correctiveDecisions),
+        nextAttemptOrdinal: allStepRemediations.length + 1,
     };
 }
+function selectCurrentPlanRemediationCycle(store, task, remediationEvents, correctiveDecisions) {
+    const unchanged = () => ({
+        remediationEvents: [...remediationEvents],
+        priorRemediationEvents: [],
+        correctiveDecisions: [...correctiveDecisions],
+    });
+    if (remediationEvents.length === 0 || !task.planHash)
+        return unchanged();
+    const audits = readPlanRiskAuditEvents(store, task);
+    const currentAudit = [...audits].reverse().find((event) => event.planHash === task.planHash
+        && event.taskRevision <= task.revision
+        && event.decision !== 'split-required'
+        && event.decision !== 'stop-escalate') ?? null;
+    if (!currentAudit)
+        return unchanged();
+    const taskRoot = store.taskRoot(task.projectId, task.id);
+    let currentSemanticHash;
+    try {
+        currentSemanticHash = normalizePlanKnowledgeBinding(readVerifiedPlanArtifact(taskRoot, task.planHash, task.planHash), 'current').semanticHash;
+    }
+    catch {
+        return unchanged();
+    }
+    const reviews = readStepReviewEvents(store, task);
+    const bindings = remediationEvents.map((event) => resolveRemediationPlanCycleBinding(taskRoot, task.planHash, event, reviews, audits));
+    if (bindings.some((binding) => binding === null))
+        return unchanged();
+    let cycleStart = remediationEvents.length;
+    while (cycleStart > 0 && bindings[cycleStart - 1].semanticHash === currentSemanticHash)
+        cycleStart -= 1;
+    if (cycleStart === remediationEvents.length
+        && currentAudit.taskRevision <= bindings.at(-1).sourceTaskRevision)
+        return unchanged();
+    return {
+        remediationEvents: remediationEvents.slice(cycleStart),
+        priorRemediationEvents: remediationEvents.slice(0, cycleStart),
+        // Corrective decisions remain globally authoritative. The semantic cycle scopes
+        // cause counting only; filtering decisions could discard stop/split authority.
+        correctiveDecisions: [...correctiveDecisions],
+    };
+}
+function resolveRemediationPlanCycleBinding(taskRoot, currentPlanHash, event, reviews, audits) {
+    let planHash = null;
+    let sourceTaskRevision = null;
+    if (event.failureEvidence.reviewEventHash) {
+        const review = reviews.find((candidate) => candidate.eventHash === event.failureEvidence.reviewEventHash) ?? null;
+        if (!review)
+            return null;
+        planHash = review.planHash;
+        sourceTaskRevision = review.taskRevision;
+    }
+    else if (event.failureEvidence.executionTaskRevision !== undefined) {
+        sourceTaskRevision = event.failureEvidence.executionTaskRevision;
+        planHash = [...audits].reverse().find((audit) => audit.taskRevision <= sourceTaskRevision)?.planHash ?? null;
+    }
+    if (!planHash || sourceTaskRevision === null
+        || !audits.some((audit) => audit.planHash === planHash && audit.taskRevision <= sourceTaskRevision))
+        return null;
+    try {
+        return {
+            semanticHash: normalizePlanKnowledgeBinding(readVerifiedPlanArtifact(taskRoot, planHash, currentPlanHash), 'remediation ' + event.eventId).semanticHash,
+            planHash,
+            sourceTaskRevision,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function deriveCurrentCauseDecisionForTask(store, task, stepId, remediationEvents) {
+    const decisions = readCorrectiveDecisionEvents(store, task).filter((event) => event.stepId === stepId);
+    const cycle = selectCurrentPlanRemediationCycle(store, task, remediationEvents, decisions);
+    return deriveCurrentCauseDecision(cycle.remediationEvents, cycle.priorRemediationEvents);
+}
 export function findCurrentGuardedRemediationPosture(store, task, planRiskAudit) {
     const matches = planRiskAudit.reviewRequiredStepIds
         .map((stepId) => readGuardedRemediationPostureForStep(store, task, stepId, planRiskAudit))
@@ -900,10 +995,10 @@ export function findFailedGuardedStepRequiringCorrectiveDecision(store, task, pl
         : null;
 }
 function deriveAttemptGateFromHistory(task, stepId, planRiskAudit, remediationEvents, correctiveDecisions, options = {}) {
-    const attemptCount = remediationEvents.length;
-    const nextAttemptOrdinal = attemptCount + 1;
+    const attemptCount = remediationEvents.length + (options.priorRemediationEvents?.length ?? 0);
+    const nextAttemptOrdinal = options.nextAttemptOrdinal ?? attemptCount + 1;
     const guardedCategory = requireGuardedCategory(planRiskAudit, stepId);
-    const rollingCauseDecision = deriveCurrentCauseDecision(remediationEvents);
+    const rollingCauseDecision = deriveCurrentCauseDecision(remediationEvents, options.priorRemediationEvents ?? []);
     const currentCorrectiveDecision = findCurrentCorrectiveDecision(task, stepId, nextAttemptOrdinal, correctiveDecisions);
     const planIntegrityDecision = currentCorrectiveDecision;
     if (planIntegrityDecision?.recoveryBasis === 'plan-integrity'
@@ -1075,17 +1170,22 @@ function deriveAttemptGateFromHistory(task, stepId, planRiskAudit, remediationEv
 // Current execution must respect a proved Plan obstruction immediately. Keep the
 // historical rolling classifier unchanged: older valid histories may have been
 // recorded before this gate existed and must not be reclassified as corrupt.
-export function deriveCurrentCauseDecision(remediationEvents) {
+export function deriveCurrentCauseDecision(remediationEvents, priorRemediationEvents = []) {
+    // A verified replacement clears the active cause, not the global attempt
+    // count or an explicit corrective decision's dirty-work continuation authority.
+    if (remediationEvents.length === 0 && priorRemediationEvents.length > 0
+        && priorRemediationEvents.every((event) => event.causeBindings !== undefined))
+        return 'same-task-fix';
     if (remediationEvents.at(-1)?.causeBindings?.some(cause => cause.authority === 'external-reviewer' && cause.planConflict))
         return 'root-cause-replan';
-    return deriveRollingCauseDecision(remediationEvents);
+    return deriveRollingCauseDecision(remediationEvents, priorRemediationEvents);
 }
-export function deriveRollingCauseDecision(remediationEvents) {
+export function deriveRollingCauseDecision(remediationEvents, priorRemediationEvents = []) {
     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 priorFingerprints = new Set([...priorRemediationEvents, ...remediationEvents.slice(0, -1)]
+        .flatMap((event) => event.causeBindings?.map((cause) => cause.causeFingerprint) ?? []));
     const authoritativeRepeat = latest.causeBindings.some((cause) => priorFingerprints.has(cause.causeFingerprint)
         && (cause.authority === 'mechanical' || (cause.authority === 'external-reviewer' && cause.planConflict)));
     return authoritativeRepeat ? 'root-cause-replan' : 'same-task-fix';
@@ -1995,10 +2095,36 @@ function validateCorrectiveDecisionCoverage(task, decisions, remediationEvents)
         }
     }
 }
-function validateHistoricalRemediationModes(task, stepId, remediationEvents, correctiveDecisions, recoveredEventIds, overriddenStopDecisionEventIds) {
+function validateHistoricalRemediationModes(store, task, stepId, remediationEvents, correctiveDecisions, recoveredEventIds, overriddenStopDecisionEventIds) {
     const causeAwareHistory = remediationEvents.length > 0
         && remediationEvents.every((event) => event.causeBindings !== undefined);
     if (causeAwareHistory) {
+        const audits = readPlanRiskAuditEvents(store, task);
+        const reviews = readStepReviewEvents(store, task);
+        const taskRoot = store.taskRoot(task.projectId, task.id);
+        const cycleBindings = task.planHash
+            ? remediationEvents.map((event) => resolveRemediationPlanCycleBinding(taskRoot, task.planHash, event, reviews, audits))
+            : remediationEvents.map(() => null);
+        if (cycleBindings.every((binding) => binding !== null)) {
+            let cycleStart = 0;
+            for (let index = 0; index < remediationEvents.length; index += 1) {
+                if (index > 0 && cycleBindings[index].semanticHash !== cycleBindings[index - 1].semanticHash) {
+                    cycleStart = index;
+                }
+                const cyclePrefix = remediationEvents.slice(cycleStart, index + 1);
+                const priorCycles = remediationEvents.slice(0, cycleStart);
+                if (deriveRollingCauseDecision(cyclePrefix, priorCycles) === 'root-cause-replan'
+                    && index < remediationEvents.length - 1
+                    && cycleBindings[index + 1].semanticHash === cycleBindings[index].semanticHash) {
+                    throw new WorkflowError('STATE_CORRUPT', 'Remediation continued after an authoritative cause required semantic replan.', {
+                        taskId: task.id,
+                        stepId,
+                        eventId: remediationEvents[index].eventId,
+                    });
+                }
+            }
+            return;
+        }
         for (let index = 0; index < remediationEvents.length; index += 1) {
             const prefix = remediationEvents.slice(0, index + 1);
             if (deriveRollingCauseDecision(prefix) === 'root-cause-replan' && index < remediationEvents.length - 1) {
@@ -2053,13 +2179,13 @@ function validateHistoricalRemediationModes(task, stepId, remediationEvents, cor
         }
     }
 }
-function validateHistoricalRemediationModesForAllSteps(task, remediationEvents, correctiveDecisions, recoveredEventIds, overriddenStopDecisionEventIds) {
+function validateHistoricalRemediationModesForAllSteps(store, task, remediationEvents, correctiveDecisions, recoveredEventIds, overriddenStopDecisionEventIds) {
     const stepIds = new Set(remediationEvents.map((event) => event.stepId));
     for (const stepId of stepIds) {
         const stepEvents = remediationEvents
             .filter((event) => event.stepId === stepId)
             .sort((left, right) => left.attemptOrdinal - right.attemptOrdinal);
-        validateHistoricalRemediationModes(task, stepId, stepEvents, correctiveDecisions, recoveredEventIds, overriddenStopDecisionEventIds);
+        validateHistoricalRemediationModes(store, task, stepId, stepEvents, correctiveDecisions, recoveredEventIds, overriddenStopDecisionEventIds);
     }
 }
 function validateCorrectiveDecisionAudit(audit) {