codex-workflow-v2 2.0.0-beta.12 → 2.0.0-beta.12.10

package/dist/src/alpha7/corrective-recovery.js

@@ -7,8 +7,10 @@ import { createUlid } from '../ulid.js';
 import { readTaskC1Posture, readTaskHandoffEvents } from '../alpha6/handoff.js';
 import { readCurrentPlanRiskAudit, readPlanRiskAuditEvents } from '../alpha6/plan-risk.js';
 import { readMilestoneAutonomyEvents } from './autonomy.js';
-import { assertCorrectiveAuditorIndependence, readCorrectiveDecisionEvents, readRemediationEvents, } from '../alpha6/remediation.js';
+import { assertCorrectiveAuditorIndependence, readCorrectiveDecisionEvents, readRemediationEvents, readStopEscalateOverrideEvents, } from '../alpha6/remediation.js';
 import { assertHash64, canonicalJsonStringify, sha256Hex } from '../alpha6/store-sidecars.js';
+import { gitIsAncestor, runGit } from '../repository.js';
+import { PACKAGE_NAME } from '../version.js';
 export const CORRECTIVE_DECISION_RECOVERIES_SIDECAR = 'corrective-decision-recoveries.jsonl';
 const RECOVERY_LOCK = '.corrective-decision-recovery.lock';
 const KNOWLEDGE_LINE = /^- Knowledge map: revision ([1-9]\d*), hash ([a-f0-9]{64})$/gm;
@@ -63,27 +65,9 @@ export function assessCorrectiveDecisionRecovery(store, task, stepId, actor, wri
         throw new WorkflowError('TRANSITION_BLOCKED', 'Corrective decision already binds the current Plan; recovery is unnecessary.');
     }
     assertCorrectiveAuditorIndependence(store, task, stepId, decision.auditor);
-    const taskRoot = store.taskRoot(task.projectId, task.id);
-    const planEvidence = comparePlanArtifacts(taskRoot, decision.planHash, task.planHash);
-    const currentAudit = readCurrentPlanRiskAudit(store, task);
-    if (!currentAudit || !currentAudit.reviewRequiredStepIds.includes(stepId)) {
-        throw new WorkflowError('TRANSITION_BLOCKED', `Step ${stepId} is not guarded by the current Plan Risk Audit.`);
-    }
-    const planRiskAudits = readPlanRiskAuditEvents(store, task);
-    const { sourceAudit, reboundAudit } = requireMechanicalAuditRebound(task, decision, planRiskAudits);
-    const directRebind = requireDirectRebind(task, decision, sourceAudit);
-    assertRebindMatchesPlans(directRebind, planEvidence);
-    if (sourceAudit.knowledgeMapRevision !== directRebind.fromKnowledgeMapRevision
-        || sourceAudit.knowledgeMapHash !== directRebind.fromKnowledgeMapHash
-        || reboundAudit.knowledgeMapRevision !== directRebind.toKnowledgeMapRevision
-        || reboundAudit.knowledgeMapHash !== directRebind.toKnowledgeMapHash) {
-        throw new WorkflowError('STATE_CORRUPT', 'Plan Risk Audit pair does not bind the direct Knowledge rebind endpoints.');
-    }
-    const knowledgeMap = store.readKnowledgeMap(task.projectId);
-    const authorization = requireRefreshAuthorization(task);
-    const { grant, autonomyContract } = requireRefreshAuthority(store, task, knowledgeMap, authorization, directRebind);
+    const rebindEvidence = assessContextOnlyPlanRebindEvidence(store, task, stepId, decision);
+    const { directRebind, semanticPlanHash, sourceAudit, reboundAudit, planRiskAudits, knowledgeMap, authorization, grant, autonomyContract, } = rebindEvidence;
     const c1 = requireC1Evidence(store, task, normalizedActor, writerToken);
-    assertRefreshChronology(knowledgeMap, authorization, directRebind, reboundAudit);
     const knowledgeMapApprovalFingerprint = hashEvidence(knowledgeMap.approval);
     const taskAuthorizationFingerprint = hashEvidence(authorization);
     const delegationGrantFingerprint = hashEvidence(grant);
@@ -92,7 +76,7 @@ export function assessCorrectiveDecisionRecovery(store, task, stepId, actor, wri
         task,
         decisionPlanHash: decision.planHash,
         reboundPlanHash: task.planHash,
-        semanticPlanHash: planEvidence.semanticPlanHash,
+        semanticPlanHash,
         remediationEvents,
         correctiveDecisions,
         planRiskAudits,
@@ -106,7 +90,7 @@ export function assessCorrectiveDecisionRecovery(store, task, stepId, actor, wri
         task,
         decision,
         directRebind,
-        semanticPlanHash: planEvidence.semanticPlanHash,
+        semanticPlanHash,
         sourceAudit,
         reboundAudit,
         knowledgeMapApprovalFingerprint,
@@ -228,6 +212,96 @@ export function assessCorrectiveDecisionRecoveryForNavigation(store, task, stepI
     const actor = posture.state === 'claimed' ? posture.claimant : lease?.owner ?? 'worker';
     return assessCorrectiveDecisionRecovery(store, task, stepId, actor, lease?.token ?? null);
 }
+export function readValidatedStopOverrideContextRebindIfApplicable(store, task, stepId, repositoryRoot) {
+    if (!task.planHash)
+        return null;
+    const remediationEvents = readRemediationEvents(store, task).filter((event) => event.stepId === stepId);
+    const triggeringAttemptCount = remediationEvents.length + 1;
+    const staleStops = readCorrectiveDecisionEvents(store, task).filter((event) => event.stepId === stepId
+        && event.triggeringAttemptCount === triggeringAttemptCount
+        && event.decision === 'stop-escalate'
+        && event.planHash !== task.planHash);
+    if (staleStops.length === 0)
+        return null;
+    if (staleStops.length !== 1) {
+        throw new WorkflowError('STATE_CORRUPT', 'Multiple stale stop decisions match one guarded retry binding.', {
+            taskId: task.id,
+            stepId,
+            triggeringAttemptCount,
+            decisionEventIds: staleStops.map((event) => event.eventId),
+        });
+    }
+    return assessStopOverrideContextRebind(store, task, stepId, staleStops[0], remediationEvents, repositoryRoot);
+}
+function assessStopOverrideContextRebind(store, task, stepId, stopDecision, remediationEvents, repositoryRoot) {
+    const step = task.steps.find((candidate) => candidate.id === stepId) ?? null;
+    if (!step)
+        throw new WorkflowError('NOT_FOUND', `Step not found: ${stepId}`);
+    if (!['planned', 'failed', 'in_progress'].includes(step.status)) {
+        throw new WorkflowError('TRANSITION_BLOCKED', `Attempt-four continuation is unavailable while ${stepId} is ${step.status}.`);
+    }
+    if (remediationEvents.length !== 3
+        || remediationEvents[0]?.attemptOrdinal !== 1
+        || remediationEvents[0]?.mode !== 'ordinary'
+        || remediationEvents[1]?.attemptOrdinal !== 2
+        || remediationEvents[1]?.mode !== 'ordinary'
+        || remediationEvents[2]?.attemptOrdinal !== 3
+        || remediationEvents[2]?.mode !== 'corrective') {
+        throw new WorkflowError('TRANSITION_BLOCKED', 'Context-rebound stop override requires the exact three-attempt beta.11 history.', {
+            taskId: task.id,
+            stepId,
+            attempts: remediationEvents.map((event) => ({ ordinal: event.attemptOrdinal, mode: event.mode })),
+        });
+    }
+    const overrides = readStopEscalateOverrideEvents(store, task).filter((event) => event.stepId === stepId && event.stopDecisionEventId === stopDecision.eventId);
+    if (overrides.length !== 1) {
+        throw new WorkflowError('TRANSITION_BLOCKED', 'Context-rebound attempt four requires one exact applied stop override.', {
+            taskId: task.id,
+            stepId,
+            stopDecisionEventId: stopDecision.eventId,
+            overrideEventIds: overrides.map((event) => event.eventId),
+        });
+    }
+    const override = overrides[0];
+    if (stopDecision.triggeringAttemptCount !== 4
+        || stopDecision.planHash !== override.planHash
+        || task.planHash === override.planHash
+        || override.coveredEventIds.length !== remediationEvents.length
+        || override.coveredEventIds.some((eventId, index) => eventId !== remediationEvents[index].eventId)) {
+        throw new WorkflowError('STATE_CORRUPT', 'Context-rebound stop override no longer binds the exact source Plan/history.', {
+            taskId: task.id,
+            stepId,
+            overrideEventId: override.eventId,
+        });
+    }
+    assertCorrectiveAuditorIndependence(store, task, stepId, stopDecision.auditor);
+    const rebindEvidence = assessAppendOnlyContextPlanRebindEvidence(store, task, stepId, stopDecision);
+    const verifiedHeadRecoveries = requireStopOverrideHeadContinuity(repositoryRoot, task, override, rebindEvidence.authorization);
+    requireEvidenceBoundAuditTaskRevision(task, rebindEvidence.reboundAudit, verifiedHeadRecoveries, step.status === 'in_progress');
+    const stopAt = Date.parse(stopDecision.recordedAt);
+    const overrideAt = Date.parse(override.recordedAt);
+    const firstRebindAt = Date.parse(rebindEvidence.rebindChain[0].recordedAt);
+    const lastRebindAt = Date.parse(rebindEvidence.rebindChain.at(-1).recordedAt);
+    if (![stopAt, overrideAt, firstRebindAt, lastRebindAt].every(Number.isFinite)
+        || overrideAt < stopAt
+        || firstRebindAt < overrideAt
+        || lastRebindAt < firstRebindAt) {
+        throw new WorkflowError('STATE_CORRUPT', 'Stop override and context-rebind chronology is invalid.', {
+            taskId: task.id,
+            stepId,
+            stopDecisionRecordedAt: stopDecision.recordedAt,
+            overrideRecordedAt: override.recordedAt,
+            firstRebindRecordedAt: rebindEvidence.rebindChain[0].recordedAt,
+            lastRebindRecordedAt: rebindEvidence.rebindChain.at(-1).recordedAt,
+        });
+    }
+    return {
+        task,
+        override,
+        stopDecision,
+        semanticPlanHash: rebindEvidence.semanticPlanHash,
+    };
+}
 function recoveryPayload(assessment, actor, now) {
     const { task, decision, directRebind, sourceAudit, reboundAudit } = assessment;
     return {
@@ -261,6 +335,142 @@ function recoveryPayload(assessment, actor, now) {
 function hashEvidence(value) {
     return sha256Hex(canonicalJsonStringify(value));
 }
+function assessContextOnlyPlanRebindEvidence(store, task, stepId, sourceDecision, options = {}) {
+    if (!task.planHash || task.knowledgeMapRevision === null || !task.knowledgeMapHash) {
+        throw new WorkflowError('STATE_CORRUPT', `Task ${task.id} is missing current Plan or Knowledge bindings.`);
+    }
+    if (sourceDecision.planHash === task.planHash) {
+        throw new WorkflowError('TRANSITION_BLOCKED', 'Context-only Plan rebind validation requires distinct source and current Plan hashes.');
+    }
+    const taskRoot = store.taskRoot(task.projectId, task.id);
+    const planEvidence = comparePlanArtifacts(taskRoot, sourceDecision.planHash, task.planHash);
+    const currentAudit = readCurrentPlanRiskAudit(store, task);
+    if (!currentAudit || !currentAudit.reviewRequiredStepIds.includes(stepId)) {
+        throw new WorkflowError('TRANSITION_BLOCKED', `Step ${stepId} is not guarded by the current Plan Risk Audit.`);
+    }
+    const planRiskAudits = readPlanRiskAuditEvents(store, task);
+    const { sourceAudit, reboundAudit } = requireMechanicalAuditRebound(task, sourceDecision, planRiskAudits, options.allowTaskRevisionAdvance ?? false);
+    const directRebind = requireDirectRebind(task, sourceDecision, sourceAudit);
+    assertRebindMatchesPlans(directRebind, planEvidence);
+    if (sourceAudit.knowledgeMapRevision !== directRebind.fromKnowledgeMapRevision
+        || sourceAudit.knowledgeMapHash !== directRebind.fromKnowledgeMapHash
+        || reboundAudit.knowledgeMapRevision !== directRebind.toKnowledgeMapRevision
+        || reboundAudit.knowledgeMapHash !== directRebind.toKnowledgeMapHash) {
+        throw new WorkflowError('STATE_CORRUPT', 'Plan Risk Audit pair does not bind the direct Knowledge rebind endpoints.');
+    }
+    const knowledgeMap = store.readKnowledgeMap(task.projectId);
+    const authorization = requireRefreshAuthorization(task);
+    const { grant, autonomyContract } = requireRefreshAuthority(store, task, knowledgeMap, authorization, directRebind);
+    assertRefreshChronology(knowledgeMap, authorization, directRebind, reboundAudit);
+    return {
+        directRebind,
+        semanticPlanHash: planEvidence.semanticPlanHash,
+        sourceAudit,
+        reboundAudit,
+        planRiskAudits,
+        knowledgeMap,
+        authorization,
+        grant,
+        autonomyContract,
+    };
+}
+function assessAppendOnlyContextPlanRebindEvidence(store, task, stepId, sourceDecision) {
+    if (!task.planHash || task.knowledgeMapRevision === null || !task.knowledgeMapHash) {
+        throw new WorkflowError('STATE_CORRUPT', `Task ${task.id} is missing current Plan or Knowledge bindings.`);
+    }
+    if (sourceDecision.planHash === task.planHash) {
+        throw new WorkflowError('TRANSITION_BLOCKED', 'Append-only Plan rebind validation requires distinct source and current Plan hashes.');
+    }
+    const planRiskAudits = readPlanRiskAuditEvents(store, task);
+    const rebindChain = requireAppendOnlyRebindChain(task, sourceDecision, planRiskAudits);
+    const planEvidence = comparePlanRebindChainArtifacts(store.taskRoot(task.projectId, task.id), sourceDecision.planHash, task.planHash, rebindChain);
+    const { sourceAudit, reboundAudit, auditChain } = requireMechanicalAuditReboundChain(task, sourceDecision, planRiskAudits, rebindChain);
+    if (!reboundAudit.stepClassifications.some((classification) => classification.stepId === stepId && classification.reviewRequired)) {
+        throw new WorkflowError('TRANSITION_BLOCKED', `Step ${stepId} is not guarded by the current Plan Risk Audit.`);
+    }
+    for (let index = 0; index < rebindChain.length; index += 1) {
+        const rebind = rebindChain[index];
+        const fromBinding = planEvidence.bindings.get(rebind.previousPlanHash);
+        const toBinding = planEvidence.bindings.get(rebind.reboundPlanHash);
+        if (!fromBinding || !toBinding) {
+            throw new WorkflowError('STATE_CORRUPT', 'Append-only Knowledge rebind references an unverified Plan artifact.', {
+                previousPlanHash: rebind.previousPlanHash,
+                reboundPlanHash: rebind.reboundPlanHash,
+            });
+        }
+        assertRebindMatchesPlans(rebind, { decisionBinding: fromBinding, reboundBinding: toBinding });
+        const fromAudit = auditChain[index];
+        const toAudit = auditChain[index + 1];
+        if (fromAudit.knowledgeMapRevision !== rebind.fromKnowledgeMapRevision
+            || fromAudit.knowledgeMapHash !== rebind.fromKnowledgeMapHash
+            || toAudit.knowledgeMapRevision !== rebind.toKnowledgeMapRevision
+            || toAudit.knowledgeMapHash !== rebind.toKnowledgeMapHash) {
+            throw new WorkflowError('STATE_CORRUPT', 'Plan Risk Audit chain does not bind every Knowledge rebind endpoint.', {
+                rebindIndex: index,
+            });
+        }
+    }
+    const knowledgeMap = store.readKnowledgeMap(task.projectId);
+    const authorization = requireRefreshAuthorization(task);
+    const finalRebind = rebindChain.at(-1);
+    const { grant, autonomyContract } = requireRefreshAuthority(store, task, knowledgeMap, authorization, finalRebind);
+    assertRefreshChronology(knowledgeMap, authorization, finalRebind, reboundAudit);
+    return {
+        rebindChain,
+        semanticPlanHash: planEvidence.semanticPlanHash,
+        sourceAudit,
+        reboundAudit,
+        planRiskAudits,
+        knowledgeMap,
+        authorization,
+        grant,
+        autonomyContract,
+    };
+}
+function comparePlanRebindChainArtifacts(taskRoot, sourcePlanHash, currentPlanHash, rebindChain) {
+    const planHashes = [sourcePlanHash, ...rebindChain.map((rebind) => rebind.reboundPlanHash)];
+    if (planHashes.at(-1) !== currentPlanHash || new Set(planHashes).size !== planHashes.length) {
+        throw new WorkflowError('STATE_CORRUPT', 'Knowledge rebind chain does not form one acyclic source-to-current Plan sequence.');
+    }
+    const contents = planHashes.map((planHash) => readVerifiedPlanArtifact(taskRoot, planHash, currentPlanHash));
+    const bindings = new Map();
+    let semanticPlanHash = null;
+    for (let index = 0; index < contents.length; index += 1) {
+        const planHash = planHashes[index];
+        bindings.set(planHash, normalizePlanKnowledgeBinding(contents[index], `Plan ${planHash}`).binding);
+        if (index === 0)
+            continue;
+        const adjacentSemanticHash = assertKnowledgeBindingOnlyPlanChange(contents[index - 1], contents[index]);
+        if (semanticPlanHash !== null && semanticPlanHash !== adjacentSemanticHash) {
+            throw new WorkflowError('STATE_CORRUPT', 'Append-only Plan rebind chain does not preserve one semantic Plan identity.');
+        }
+        semanticPlanHash = adjacentSemanticHash;
+    }
+    if (!semanticPlanHash) {
+        throw new WorkflowError('STATE_CORRUPT', 'Append-only Plan rebind chain has no comparable Plan hop.');
+    }
+    return { semanticPlanHash, bindings };
+}
+function readVerifiedPlanArtifact(taskRoot, planHash, currentPlanHash) {
+    assertHash64(planHash, 'Plan hash');
+    const file = planHash === currentPlanHash
+        ? path.join(taskRoot, 'plan.md')
+        : path.join(taskRoot, '.versions', `plan.md.${planHash}`);
+    if (!existsSync(file)) {
+        throw new WorkflowError('STATE_CORRUPT', 'Plan artifact required by the append-only rebind chain is missing.', {
+            planHash,
+            file,
+        });
+    }
+    const content = readFileSync(file, 'utf8');
+    if (sha256Hex(content) !== planHash) {
+        throw new WorkflowError('STATE_CORRUPT', 'Plan artifact content does not match its append-only rebind hash.', {
+            planHash,
+            file,
+        });
+    }
+    return content;
+}
 function comparePlanArtifacts(taskRoot, decisionPlanHash, reboundPlanHash) {
     assertHash64(decisionPlanHash, 'Corrective decision Plan hash');
     assertHash64(reboundPlanHash, 'Current Plan hash');
@@ -298,7 +508,7 @@ function normalizePlanKnowledgeBinding(content, label) {
         binding: { revision: Number(match[1]), hash: match[2] },
     };
 }
-function requireMechanicalAuditRebound(task, decision, events) {
+function requireMechanicalAuditRebound(task, decision, events, allowTaskRevisionAdvance = false) {
     const sources = events.filter((event) => event.planHash === decision.planHash);
     const rebounds = events.filter((event) => event.planHash === task.planHash);
     if (sources.length !== 1 || rebounds.length !== 1) {
@@ -328,10 +538,13 @@ function requireMechanicalAuditRebound(task, decision, events) {
     if (sourceAudit.briefHash !== task.briefHash || reboundAudit.briefHash !== task.briefHash) {
         throw new WorkflowError('STATE_CORRUPT', 'Plan Risk Audit rebound does not preserve the current Brief binding.');
     }
-    if (reboundAudit.taskRevision + 1 !== task.revision) {
-        throw new WorkflowError('STATE_CORRUPT', 'Mechanical rebound audit must be exactly one Task revision before current authorization.', {
+    const authorizedTaskRevision = reboundAudit.taskRevision + 1;
+    if ((!allowTaskRevisionAdvance && authorizedTaskRevision !== task.revision)
+        || (allowTaskRevisionAdvance && authorizedTaskRevision > task.revision)) {
+        throw new WorkflowError('STATE_CORRUPT', 'Mechanical rebound audit does not bind the required Task authorization boundary.', {
             reboundAuditTaskRevision: reboundAudit.taskRevision,
             currentTaskRevision: task.revision,
+            allowTaskRevisionAdvance,
         });
     }
     return { sourceAudit, reboundAudit };
@@ -355,6 +568,173 @@ function requireDirectRebind(task, decision, sourceAudit) {
     }
     return selected;
 }
+function requireAppendOnlyRebindChain(task, decision, planRiskAudits) {
+    for (let index = 0; index < task.knowledgeRebinds.length; index += 1) {
+        const recordedAt = Date.parse(task.knowledgeRebinds[index].recordedAt);
+        if (!Number.isFinite(recordedAt)
+            || (index > 0 && recordedAt <= Date.parse(task.knowledgeRebinds[index - 1].recordedAt))) {
+            throw new WorkflowError('STATE_CORRUPT', 'Task Knowledge rebind timestamps must be finite and strictly increasing.');
+        }
+    }
+    const sourceAudits = planRiskAudits.filter((event) => event.planHash === decision.planHash);
+    if (sourceAudits.length !== 1) {
+        throw new WorkflowError('STATE_CORRUPT', 'Append-only recovery requires one exact source Plan Risk Audit.', {
+            sourceAuditIds: sourceAudits.map((event) => event.eventId),
+        });
+    }
+    const boundary = Math.max(Date.parse(decision.recordedAt), Date.parse(sourceAudits[0].recordedAt));
+    if (!Number.isFinite(boundary)) {
+        throw new WorkflowError('STATE_CORRUPT', 'Stop decision or source Plan Risk Audit timestamp is invalid.');
+    }
+    const chain = task.knowledgeRebinds.filter((record) => Date.parse(record.recordedAt) > boundary);
+    if (chain.length < 1) {
+        throw new WorkflowError('TRANSITION_BLOCKED', 'Stop-override continuation requires at least one Knowledge rebind after its source authority.');
+    }
+    if (task.knowledgeRebinds.at(-1) !== chain.at(-1)) {
+        throw new WorkflowError('STATE_CORRUPT', 'Append-only Knowledge rebind chain does not terminate at the current Task boundary.');
+    }
+    let expectedPlanHash = decision.planHash;
+    for (const record of chain) {
+        if (record.previousPlanHash !== expectedPlanHash || record.reboundPlanHash === record.previousPlanHash) {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Knowledge rebind provenance is not one contiguous source-to-current Plan chain.', {
+                expectedPreviousPlanHash: expectedPlanHash,
+                actualPreviousPlanHash: record.previousPlanHash,
+                reboundPlanHash: record.reboundPlanHash,
+            });
+        }
+        expectedPlanHash = record.reboundPlanHash;
+    }
+    if (expectedPlanHash !== task.planHash) {
+        throw new WorkflowError('TRANSITION_BLOCKED', 'Knowledge rebind provenance does not terminate at the current Task Plan.', {
+            expectedCurrentPlanHash: task.planHash,
+            actualTerminalPlanHash: expectedPlanHash,
+        });
+    }
+    return chain;
+}
+function requireMechanicalAuditReboundChain(task, decision, events, rebindChain) {
+    const planHashes = [decision.planHash, ...rebindChain.map((record) => record.reboundPlanHash)];
+    const auditChain = planHashes.map((planHash) => {
+        const matches = events.filter((event) => event.planHash === planHash);
+        if (matches.length !== 1) {
+            throw new WorkflowError('STATE_CORRUPT', 'Append-only recovery requires one Plan Risk Audit for every Plan in the rebind chain.', {
+                planHash,
+                auditEventIds: matches.map((event) => event.eventId),
+            });
+        }
+        return matches[0];
+    });
+    const sourceIndex = events.indexOf(auditChain[0]);
+    for (let index = 0; index < auditChain.length; index += 1) {
+        if (events[sourceIndex + index] !== auditChain[index]) {
+            throw new WorkflowError('STATE_CORRUPT', 'Plan Risk Audit rebind evidence is not one contiguous append-only chain.');
+        }
+        if (index > 0)
+            assertMechanicalAuditSuccessor(task, auditChain[index - 1], auditChain[index]);
+    }
+    if (sourceIndex < 0 || sourceIndex + auditChain.length !== events.length) {
+        throw new WorkflowError('STATE_CORRUPT', 'Plan Risk Audit rebind chain does not end at the current append-only boundary.');
+    }
+    const reboundAudit = auditChain.at(-1);
+    return { sourceAudit: auditChain[0], reboundAudit, auditChain };
+}
+function assertMechanicalAuditSuccessor(task, sourceAudit, reboundAudit) {
+    const expectedSummary = `${sourceAudit.summary} Rebound automatically after content-only Task context refresh.`;
+    if (reboundAudit.previousEventHash !== sourceAudit.eventHash
+        || reboundAudit.taskId !== sourceAudit.taskId
+        || reboundAudit.briefHash !== sourceAudit.briefHash
+        || reboundAudit.briefHash !== task.briefHash
+        || reboundAudit.planner !== sourceAudit.planner
+        || reboundAudit.auditor !== sourceAudit.auditor
+        || reboundAudit.decision !== sourceAudit.decision
+        || reboundAudit.splitRationale !== sourceAudit.splitRationale
+        || reboundAudit.summary !== expectedSummary
+        || canonicalJsonStringify(reboundAudit.stepClassifications) !== canonicalJsonStringify(sourceAudit.stepClassifications)) {
+        throw new WorkflowError('STATE_CORRUPT', 'Plan Risk Audit successor is not a mechanical content-refresh rebound.');
+    }
+}
+function requireStopOverrideHeadContinuity(repositoryRoot, task, override, authorization) {
+    const authorizedHead = authorization.headCommit;
+    if (!authorizedHead) {
+        throw new WorkflowError('TRANSITION_BLOCKED', 'Current execution authorization does not bind a Git HEAD.');
+    }
+    if (authorizedHead === override.headCommit)
+        return [];
+    if (!gitIsAncestor(repositoryRoot, override.headCommit, authorizedHead)) {
+        throw new WorkflowError('TRANSITION_BLOCKED', 'Current execution HEAD is not an append-only descendant of the stop-override HEAD.', {
+            overrideHeadCommit: override.headCommit,
+            authorizedHeadCommit: authorizedHead,
+        });
+    }
+    const output = runGit(repositoryRoot, ['rev-list', '--reverse', `${override.headCommit}..${authorizedHead}`]);
+    const commits = output ? output.split('\n') : [];
+    if (commits.length < 1) {
+        throw new WorkflowError('STATE_CORRUPT', 'Git reports distinct stop-override and authorization HEADs without an intervening commit.');
+    }
+    let expectedParent = override.headCommit;
+    let previousRecoveryIndex = -1;
+    let previousRecoveryAt = Number.NEGATIVE_INFINITY;
+    const verifiedRecoveries = [];
+    for (const commit of commits) {
+        const matches = (task.dependencyProvenanceRecoveries ?? []).filter((record) => record.commitSha === commit);
+        if (matches.length !== 1) {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Git HEAD advanced through a commit without one exact dependency-provenance recovery.', {
+                commit,
+                recoveryCount: matches.length,
+            });
+        }
+        const recovery = matches[0];
+        const recoveryIndex = (task.dependencyProvenanceRecoveries ?? []).indexOf(recovery);
+        const recoveryAt = Date.parse(recovery.recordedAt);
+        const parents = runGit(repositoryRoot, ['show', '-s', '--format=%P', commit]).split(/\s+/).filter(Boolean);
+        const filesOutput = runGit(repositoryRoot, ['diff-tree', '--no-commit-id', '--name-only', '-r', commit]);
+        const files = filesOutput ? filesOutput.split('\n').sort() : [];
+        if (parents.length !== 1
+            || parents[0] !== expectedParent
+            || recovery.parentCommitSha !== expectedParent
+            || recoveryIndex <= previousRecoveryIndex
+            || !Number.isFinite(recoveryAt)
+            || recoveryAt <= previousRecoveryAt
+            || recovery.packageName !== PACKAGE_NAME
+            || canonicalJsonStringify(recovery.files) !== canonicalJsonStringify(['package-lock.json', 'package.json'])
+            || canonicalJsonStringify(files) !== canonicalJsonStringify(['package-lock.json', 'package.json'])
+            || !task.systemCommits.includes(commit)) {
+            throw new WorkflowError('TRANSITION_BLOCKED', 'Dependency-only Git continuity from stop override to current authorization is invalid.', {
+                commit,
+                expectedParent,
+                recordedParent: recovery.parentCommitSha,
+                parents,
+                files,
+            });
+        }
+        verifiedRecoveries.push(recovery);
+        previousRecoveryIndex = recoveryIndex;
+        previousRecoveryAt = recoveryAt;
+        expectedParent = commit;
+    }
+    if (expectedParent !== authorizedHead) {
+        throw new WorkflowError('STATE_CORRUPT', 'Dependency-provenance Git chain does not terminate at the authorized HEAD.');
+    }
+    return verifiedRecoveries;
+}
+function requireEvidenceBoundAuditTaskRevision(task, reboundAudit, verifiedHeadRecoveries, allowTaskRevisionAdvance) {
+    const auditAt = Date.parse(reboundAudit.recordedAt);
+    if (!Number.isFinite(auditAt)) {
+        throw new WorkflowError('STATE_CORRUPT', 'Current rebound Plan Risk Audit timestamp is invalid.');
+    }
+    const postAuditRecoveries = verifiedHeadRecoveries.filter((recovery) => Date.parse(recovery.recordedAt) > auditAt);
+    const evidenceBoundTaskRevision = reboundAudit.taskRevision + 1 + postAuditRecoveries.length;
+    if ((!allowTaskRevisionAdvance && evidenceBoundTaskRevision !== task.revision)
+        || (allowTaskRevisionAdvance && evidenceBoundTaskRevision > task.revision)) {
+        throw new WorkflowError('STATE_CORRUPT', 'Mechanical rebound audit chain does not bind the evidence-accounted Task authorization boundary.', {
+            reboundAuditTaskRevision: reboundAudit.taskRevision,
+            currentTaskRevision: task.revision,
+            postAuditDependencyRecoveryCommits: postAuditRecoveries.map((recovery) => recovery.commitSha),
+            evidenceBoundTaskRevision,
+            allowTaskRevisionAdvance,
+        });
+    }
+}
 function assertRebindMatchesPlans(rebind, plans) {
     if (rebind.fromKnowledgeMapRevision !== plans.decisionBinding.revision
         || rebind.fromKnowledgeMapHash !== plans.decisionBinding.hash