@resolveio/server-lib 22.3.194 → 22.3.196

package/util/ai-runner-manager-policy.d.ts

@@ -316,10 +316,20 @@ export interface ResolveIOAIManagerHotfixEvidenceRecord {
     githubCommitRequired: boolean;
     githubCommitProofPassed: boolean;
     commitProofStatus: 'not_required' | 'missing' | 'invalid' | 'passed';
+    commitFirstProtocol: 'not_required' | 'commit_first_hotfix';
+    commit_first_protocol: 'not_required' | 'commit_first_hotfix';
+    commitFirstProtocolSatisfied: boolean;
+    commit_first_protocol_satisfied: boolean;
+    liveHotfixBlockedUntilCommit: boolean;
+    live_hotfix_blocked_until_commit: boolean;
+    liveHotfixAllowed: boolean;
+    live_hotfix_allowed: boolean;
     managerMustCommitBeforeHotfix: boolean;
     githubCommitGuard: ResolveIOAIManagerHotfixGitProof;
     readyForReleaseGate: boolean;
     readyForContinuation: boolean;
+    managerContinuationAllowed: boolean;
+    manager_continuation_allowed: boolean;
 }
 export type ResolveIOAIManagerHotfixDurabilityStatus = 'not_required' | 'waiting_for_commit_proof' | 'ready_for_live_hotfix' | 'ready_for_release_gate' | 'ready_for_continuation';
 export interface ResolveIOAIManagerHotfixDurabilityContractInput {
@@ -351,6 +361,16 @@ export interface ResolveIOAIManagerHotfixDurabilityContract {
     can_hotfix_backend: boolean;
     liveHotfixBlockedUntilCommit: boolean;
     live_hotfix_blocked_until_commit: boolean;
+    durabilityProtocol: 'not_required' | 'commit_first_hotfix';
+    durability_protocol: 'not_required' | 'commit_first_hotfix';
+    commitFirstProtocolRequired: boolean;
+    commit_first_protocol_required: boolean;
+    commitFirstProtocolSatisfied: boolean;
+    commit_first_protocol_satisfied: boolean;
+    liveHotfixAllowed: boolean;
+    live_hotfix_allowed: boolean;
+    managerContinuationAllowed: boolean;
+    manager_continuation_allowed: boolean;
     commitProofPassed: boolean;
     commit_proof_passed: boolean;
     commitProofStatus: ResolveIOAIManagerHotfixGitProofStatus | 'missing';
@@ -582,6 +602,46 @@ export interface ResolveIOAIManagerRecoveryExecutionDirective {
     releasePolicy?: ResolveIOAIManagerHotfixFirstReleasePolicy;
     createdAt: string;
 }
+export type ResolveIOAIManagerRecoveryExecutionProofStatus = 'proof_ready' | 'waiting_for_execution' | 'waiting_for_new_evidence' | 'blocked_same_evidence' | 'manual_handoff';
+export interface ResolveIOAIManagerRecoveryExecutionProofContractInput {
+    directive?: ResolveIOAIManagerRecoveryExecutionDirective;
+    previous?: ResolveIOAIManagerFailureRecord;
+    current?: ResolveIOAIManagerFailureRecord;
+    requiredEvidence?: any;
+    now?: Date | string;
+}
+export interface ResolveIOAIManagerRecoveryExecutionProofContract {
+    contractId: string;
+    directiveId: string;
+    surface: string;
+    dispatchAction: ResolveIOAIManagerRecoveryActionDispatchAction;
+    phase: ResolveIOAIManagerRecoveryExecutionPhase;
+    status: ResolveIOAIManagerRecoveryExecutionProofStatus;
+    canContinueRun: boolean;
+    canRunProductRepair: boolean;
+    canRunExpensiveModel: boolean;
+    canResetLoopBudget: boolean;
+    proofRequiredBeforeContinuation: boolean;
+    requiresNewEvidence: boolean;
+    newEvidence: boolean;
+    materialEvidence: boolean;
+    evidenceStrength: ResolveIOAIManagerEvidenceStrength;
+    evidenceSignals: string[];
+    startingFailureClass: string;
+    startingBlockerFingerprint: string;
+    startingEvidenceHash: string;
+    latestFailureClass: string;
+    latestBlockerFingerprint: string;
+    latestEvidenceHash: string;
+    requiredEvidence: string[];
+    missingEvidence: string[];
+    artifactPaths: string[];
+    changedFiles: string[];
+    blockers: string[];
+    nextAllowedAction: string;
+    forbiddenActions: string[];
+    createdAt: string;
+}
 export interface ResolveIOAIManagerRecoveryCheckpointInput {
     plan: ResolveIOAIManagerRecoveryPlan;
     current?: ResolveIOAIManagerFailureRecord;
@@ -713,6 +773,13 @@ export declare function buildResolveIOAIManagerRecoveryActionPacket(input: Resol
 export declare function decideResolveIOAIManagerRecoveryActionDispatch(input: ResolveIOAIManagerRecoveryActionDispatchInput): ResolveIOAIManagerRecoveryActionDispatchDecision;
 export declare function appendResolveIOAIManagerRecoveryActionDispatch(history: ResolveIOAIManagerRecoveryActionDispatchRecord[] | undefined, record: ResolveIOAIManagerRecoveryActionDispatchRecord | undefined, limit?: number): ResolveIOAIManagerRecoveryActionDispatchRecord[];
 export declare function buildResolveIOAIManagerRecoveryExecutionDirective(input: ResolveIOAIManagerRecoveryExecutionDirectiveInput): ResolveIOAIManagerRecoveryExecutionDirective;
+export declare function buildResolveIOAIManagerRecoveryExecutionProofContract(input?: ResolveIOAIManagerRecoveryExecutionProofContractInput): ResolveIOAIManagerRecoveryExecutionProofContract;
+export declare function validateResolveIOAIManagerRecoveryExecutionProofContract(value: any): {
+    valid: boolean;
+    status: ResolveIOAIManagerRecoveryExecutionProofStatus | 'blocked';
+    blockers: string[];
+    normalized: ResolveIOAIManagerRecoveryExecutionProofContract;
+};
 export declare function assessResolveIOAIManagerEvidenceChange(previous: (ResolveIOAIManagerFailureRecord | ResolveIOAIManagerRecoveryCheckpoint | undefined), current: ResolveIOAIManagerFailureRecord | undefined, fallbackObjective?: string): ResolveIOAIManagerEvidenceAssessment;
 export declare function decideResolveIOAIManagerRecoveryGate(input: ResolveIOAIManagerRecoveryGateInput): ResolveIOAIManagerRecoveryGateDecision;
 export declare function buildResolveIOAIManagerRecoveryPlan(input?: ResolveIOAIManagerRecoveryPlanInput): ResolveIOAIManagerRecoveryPlan;

package/util/ai-runner-manager-policy.js

@@ -67,6 +67,8 @@ exports.buildResolveIOAIManagerRecoveryActionPacket = buildResolveIOAIManagerRec
 exports.decideResolveIOAIManagerRecoveryActionDispatch = decideResolveIOAIManagerRecoveryActionDispatch;
 exports.appendResolveIOAIManagerRecoveryActionDispatch = appendResolveIOAIManagerRecoveryActionDispatch;
 exports.buildResolveIOAIManagerRecoveryExecutionDirective = buildResolveIOAIManagerRecoveryExecutionDirective;
+exports.buildResolveIOAIManagerRecoveryExecutionProofContract = buildResolveIOAIManagerRecoveryExecutionProofContract;
+exports.validateResolveIOAIManagerRecoveryExecutionProofContract = validateResolveIOAIManagerRecoveryExecutionProofContract;
 exports.assessResolveIOAIManagerEvidenceChange = assessResolveIOAIManagerEvidenceChange;
 exports.decideResolveIOAIManagerRecoveryGate = decideResolveIOAIManagerRecoveryGate;
 exports.buildResolveIOAIManagerRecoveryPlan = buildResolveIOAIManagerRecoveryPlan;
@@ -910,6 +912,11 @@ function buildResolveIOAIManagerHotfixEvidenceRecord(input) {
     var missingFields = requiredFields.filter(function (field) { return !hotfixEvidenceFieldPresent(normalized, field); });
     var recordedAt = cleanDateString(input.now || (normalized === null || normalized === void 0 ? void 0 : normalized.recordedAt) || new Date());
     var githubCommitGuard = validation.githubCommitGuard || evaluateResolveIOAIManagerHotfixGitProof(normalized || merged, channel);
+    var commitFirstProtocol = githubCommitGuard.required ? 'commit_first_hotfix' : 'not_required';
+    var commitFirstProtocolSatisfied = githubCommitGuard.required ? githubCommitGuard.passed === true : true;
+    var liveHotfixBlockedUntilCommit = githubCommitGuard.required === true && commitFirstProtocolSatisfied !== true;
+    var liveHotfixAllowed = validation.valid === true && validation.hotfixSatisfied === true && commitFirstProtocolSatisfied === true;
+    var readyForContinuation = validation.valid === true && validation.hotfixSatisfied === true && hotfixStatusPassed(normalized === null || normalized === void 0 ? void 0 : normalized.releaseGateStatus);
     return {
         recordId: cleanText(input.recordId, 160) || "hotfix-".concat(fingerprintResolveIOAIManagerBlocker("".concat(channel, ":").concat(githubCommitGuard.sourceCommitSha, ":").concat(recordedAt))),
         recordedAt: recordedAt,
@@ -934,10 +941,20 @@ function buildResolveIOAIManagerHotfixEvidenceRecord(input) {
         githubCommitRequired: githubCommitGuard.required,
         githubCommitProofPassed: githubCommitGuard.passed,
         commitProofStatus: githubCommitGuard.status,
+        commitFirstProtocol: commitFirstProtocol,
+        commit_first_protocol: commitFirstProtocol,
+        commitFirstProtocolSatisfied: commitFirstProtocolSatisfied,
+        commit_first_protocol_satisfied: commitFirstProtocolSatisfied,
+        liveHotfixBlockedUntilCommit: liveHotfixBlockedUntilCommit,
+        live_hotfix_blocked_until_commit: liveHotfixBlockedUntilCommit,
+        liveHotfixAllowed: liveHotfixAllowed,
+        live_hotfix_allowed: liveHotfixAllowed,
         managerMustCommitBeforeHotfix: githubCommitGuard.managerMustCommitBeforeHotfix,
         githubCommitGuard: githubCommitGuard,
         readyForReleaseGate: validation.valid === true && validation.nextAction === 'rerun_release_gate',
-        readyForContinuation: validation.valid === true && validation.hotfixSatisfied === true && hotfixStatusPassed(normalized === null || normalized === void 0 ? void 0 : normalized.releaseGateStatus)
+        readyForContinuation: readyForContinuation,
+        managerContinuationAllowed: readyForContinuation,
+        manager_continuation_allowed: readyForContinuation
     };
 }
 function pickFirstHotfixText(sources, keys, max, seen) {
@@ -1040,6 +1057,14 @@ function buildResolveIOAIManagerHotfixDurabilityContract(input) {
     var sourceShaPassed = isFullGitCommitSha(sourceCommitSha);
     var githubUrlSha = extractGithubCommitSha(githubCommitUrl);
     var githubUrlPassed = !!githubUrlSha && (!sourceShaPassed || githubUrlSha === sourceCommitSha.toLowerCase());
+    var existingMissingCommitFields = cleanList(existing.missingCommitProofFields || existing.missing_commit_proof_fields, 20, 160);
+    var commitFirstProtocolRequired = githubCommitGuard.required === true
+        || existing.durabilityProtocol === 'commit_first_hotfix'
+        || existing.durability_protocol === 'commit_first_hotfix'
+        || existing.commitFirstProtocolRequired === true
+        || existing.commit_first_protocol_required === true
+        || existingMissingCommitFields.some(function (field) { return /sourceCommitSha|githubCommitUrl|gitCommitStatus|gitPushStatus/i.test(field); });
+    var durabilityProtocol = commitFirstProtocolRequired ? 'commit_first_hotfix' : 'not_required';
     var missingCommitProofFields = [
         sourceShaPassed ? '' : 'sourceCommitSha',
         githubUrlPassed ? '' : 'githubCommitUrl',
@@ -1047,12 +1072,17 @@ function buildResolveIOAIManagerHotfixDurabilityContract(input) {
         pushPassed ? '' : 'gitPushStatus=passed'
     ].filter(Boolean);
     var commitProofPassed = required ? missingCommitProofFields.length === 0 : githubCommitGuard.passed === true;
+    var commitFirstProtocolSatisfied = commitFirstProtocolRequired ? commitProofPassed === true : true;
     var liveHotfixBlockedUntilCommit = required && commitProofPassed !== true;
     var releaseGatePassed = input.releaseGatePassed === true
         || hotfixStatusPassed((_e = validation.normalized) === null || _e === void 0 ? void 0 : _e.releaseGateStatus)
         || (continuation === null || continuation === void 0 ? void 0 : continuation.canContinueRun) === true;
     var canPrepareHotfixPatch = required && (existing.canPrepareHotfixPatch === true || existing.can_prepare_hotfix_patch === true || actionRequiresHotfix || (continuation === null || continuation === void 0 ? void 0 : continuation.action) === 'record_hotfix_evidence');
     var canHotfixBackend = required && commitProofPassed === true && canPrepareHotfixPatch === true;
+    var liveHotfixAllowed = required && commitFirstProtocolSatisfied === true && canPrepareHotfixPatch === true;
+    var managerContinuationAllowed = required
+        ? commitFirstProtocolSatisfied === true && validation.valid === true && releaseGatePassed === true
+        : true;
     var status = 'not_required';
     if (required && liveHotfixBlockedUntilCommit) {
         status = 'waiting_for_commit_proof';
@@ -1143,6 +1173,16 @@ function buildResolveIOAIManagerHotfixDurabilityContract(input) {
         can_hotfix_backend: canHotfixBackend,
         liveHotfixBlockedUntilCommit: liveHotfixBlockedUntilCommit,
         live_hotfix_blocked_until_commit: liveHotfixBlockedUntilCommit,
+        durabilityProtocol: durabilityProtocol,
+        durability_protocol: durabilityProtocol,
+        commitFirstProtocolRequired: commitFirstProtocolRequired,
+        commit_first_protocol_required: commitFirstProtocolRequired,
+        commitFirstProtocolSatisfied: commitFirstProtocolSatisfied,
+        commit_first_protocol_satisfied: commitFirstProtocolSatisfied,
+        liveHotfixAllowed: liveHotfixAllowed,
+        live_hotfix_allowed: liveHotfixAllowed,
+        managerContinuationAllowed: managerContinuationAllowed,
+        manager_continuation_allowed: managerContinuationAllowed,
         commitProofPassed: commitProofPassed,
         commit_proof_passed: commitProofPassed,
         commitProofStatus: commitProofPassed ? 'passed' : 'missing',
@@ -2320,6 +2360,178 @@ function buildResolveIOAIManagerRecoveryExecutionDirective(input) {
                 'Do not run product-code repair from this directive unless canRunProductRepair is true.'
             ], __read((((_e = action === null || action === void 0 ? void 0 : action.releasePolicy) === null || _e === void 0 ? void 0 : _e.forbiddenActions) || [])), false))).slice(0, 20) }), (dispatchDecision.dispatchRecord ? { dispatchRecord: dispatchDecision.dispatchRecord } : {})), ((action === null || action === void 0 ? void 0 : action.releasePolicy) ? { releasePolicy: action.releasePolicy } : {})), { createdAt: now });
 }
+function failureRecordFromDirectiveStart(directive, previous) {
+    if (previous) {
+        return previous;
+    }
+    var dispatchRecord = directive === null || directive === void 0 ? void 0 : directive.dispatchRecord;
+    return {
+        lane: directive === null || directive === void 0 ? void 0 : directive.lane,
+        stepType: directive === null || directive === void 0 ? void 0 : directive.stepType,
+        failureClass: '',
+        blockerFingerprint: dispatchRecord === null || dispatchRecord === void 0 ? void 0 : dispatchRecord.blockerFingerprint,
+        evidenceHash: dispatchRecord === null || dispatchRecord === void 0 ? void 0 : dispatchRecord.evidenceHash,
+        artifactPaths: (dispatchRecord === null || dispatchRecord === void 0 ? void 0 : dispatchRecord.artifactPaths) || [],
+        recordedAt: (dispatchRecord === null || dispatchRecord === void 0 ? void 0 : dispatchRecord.createdAt) || (directive === null || directive === void 0 ? void 0 : directive.createdAt)
+    };
+}
+function recoveryExecutionProofStatus(input) {
+    var directive = input.directive;
+    if (!directive || directive.allowed !== true || directive.dispatchAction === 'park_manual') {
+        return 'manual_handoff';
+    }
+    if (!input.hasCurrent) {
+        return 'waiting_for_execution';
+    }
+    if (directive.requiresNewEvidence === true && input.assessment.changed !== true) {
+        return 'blocked_same_evidence';
+    }
+    if (directive.proofRequiredBeforeContinuation === true && input.assessment.material !== true) {
+        return 'waiting_for_new_evidence';
+    }
+    return 'proof_ready';
+}
+function buildResolveIOAIManagerRecoveryExecutionProofContract(input) {
+    if (input === void 0) { input = {}; }
+    var directive = input.directive;
+    var previous = failureRecordFromDirectiveStart(directive, input.previous);
+    var current = input.current || {};
+    var hasCurrent = !!input.current;
+    var assessment = hasCurrent
+        ? assessResolveIOAIManagerEvidenceChange(previous, current, directive === null || directive === void 0 ? void 0 : directive.requiredStateTransition)
+        : {
+            changed: false,
+            material: false,
+            strength: 'none',
+            signals: [],
+            evidenceHash: hashResolveIOAIManagerEvidence(previous),
+            blockerFingerprint: resolveResolveIOAIManagerBlockerFingerprint(previous, directive === null || directive === void 0 ? void 0 : directive.requiredStateTransition)
+        };
+    var status = recoveryExecutionProofStatus({ directive: directive, hasCurrent: hasCurrent, assessment: assessment });
+    var canContinueRun = status === 'proof_ready';
+    var requiredEvidence = Array.from(new Set(__spreadArray(__spreadArray(__spreadArray([], __read(cleanList(input.requiredEvidence, 30, 500)), false), __read(cleanList(directive === null || directive === void 0 ? void 0 : directive.requiredArtifacts, 30, 500)), false), __read(cleanList(directive === null || directive === void 0 ? void 0 : directive.successCriteria, 30, 500)), false).filter(Boolean)));
+    var missingEvidence = (directive === null || directive === void 0 ? void 0 : directive.proofRequiredBeforeContinuation) === true && status !== 'proof_ready'
+        ? (requiredEvidence.length ? requiredEvidence : ['new material evidence or passed proof artifact'])
+        : [];
+    var artifactPaths = cleanList(current.artifactPaths || previous.artifactPaths, 80, 500);
+    var changedFiles = cleanList(current.changedFiles, 80, 500);
+    var startingFailureClass = normalizeResolveIOAIManagerFailureClass(previous.failureClass);
+    var latestFailureClass = normalizeResolveIOAIManagerFailureClass(current.failureClass || previous.failureClass);
+    var startingBlockerFingerprint = cleanText(previous.blockerFingerprint, 160)
+        || resolveResolveIOAIManagerBlockerFingerprint(previous, directive === null || directive === void 0 ? void 0 : directive.requiredStateTransition);
+    var startingEvidenceHash = cleanText(previous.evidenceHash, 160)
+        || hashResolveIOAIManagerEvidence(previous);
+    var blockers = [
+        status === 'manual_handoff' ? ((directive === null || directive === void 0 ? void 0 : directive.reason) || 'recovery_execution_requires_manual_handoff') : '',
+        status === 'waiting_for_execution' ? 'recovery_execution_waiting_for_current_evidence' : '',
+        status === 'blocked_same_evidence' ? 'recovery_execution_same_evidence_after_dispatch' : '',
+        status === 'waiting_for_new_evidence' ? 'recovery_execution_missing_material_evidence' : ''
+    ].filter(Boolean);
+    var createdAt = isoNow(input.now);
+    return {
+        contractId: stableHash('mgr-execution-proof', {
+            directiveId: (directive === null || directive === void 0 ? void 0 : directive.directiveId) || '',
+            dispatchAction: (directive === null || directive === void 0 ? void 0 : directive.dispatchAction) || 'park_manual',
+            status: status,
+            startingEvidenceHash: startingEvidenceHash,
+            latestEvidenceHash: assessment.evidenceHash,
+            createdAt: createdAt.slice(0, 16)
+        }),
+        directiveId: cleanText(directive === null || directive === void 0 ? void 0 : directive.directiveId, 180),
+        surface: cleanText(directive === null || directive === void 0 ? void 0 : directive.surface, 120) || 'runner',
+        dispatchAction: (directive === null || directive === void 0 ? void 0 : directive.dispatchAction) || 'park_manual',
+        phase: (directive === null || directive === void 0 ? void 0 : directive.phase) || 'manual',
+        status: status,
+        canContinueRun: canContinueRun,
+        canRunProductRepair: canContinueRun && (directive === null || directive === void 0 ? void 0 : directive.canRunProductRepair) === true,
+        canRunExpensiveModel: canContinueRun && (directive === null || directive === void 0 ? void 0 : directive.canRunExpensiveModel) === true,
+        canResetLoopBudget: canContinueRun && assessment.material === true,
+        proofRequiredBeforeContinuation: (directive === null || directive === void 0 ? void 0 : directive.proofRequiredBeforeContinuation) === true,
+        requiresNewEvidence: (directive === null || directive === void 0 ? void 0 : directive.requiresNewEvidence) === true,
+        newEvidence: assessment.changed,
+        materialEvidence: assessment.material,
+        evidenceStrength: assessment.strength,
+        evidenceSignals: assessment.signals,
+        startingFailureClass: startingFailureClass,
+        startingBlockerFingerprint: startingBlockerFingerprint,
+        startingEvidenceHash: startingEvidenceHash,
+        latestFailureClass: latestFailureClass,
+        latestBlockerFingerprint: assessment.blockerFingerprint,
+        latestEvidenceHash: assessment.evidenceHash,
+        requiredEvidence: requiredEvidence,
+        missingEvidence: missingEvidence,
+        artifactPaths: artifactPaths,
+        changedFiles: changedFiles,
+        blockers: blockers,
+        nextAllowedAction: canContinueRun ? ((directive === null || directive === void 0 ? void 0 : directive.nextCommands[0]) || 'continue_gate') : 'collect_required_recovery_proof',
+        forbiddenActions: Array.from(new Set(__spreadArray([
+            'Do not continue product-code repair until recovery execution proof is proof_ready.'
+        ], __read(cleanList(directive === null || directive === void 0 ? void 0 : directive.forbiddenActions, 30, 500)), false))),
+        createdAt: createdAt
+    };
+}
+function validateResolveIOAIManagerRecoveryExecutionProofContract(value) {
+    var source = value || {};
+    var validStatuses = [
+        'proof_ready',
+        'waiting_for_execution',
+        'waiting_for_new_evidence',
+        'blocked_same_evidence',
+        'manual_handoff'
+    ];
+    var status = cleanText(source.status, 120);
+    var normalized = {
+        contractId: cleanText(source.contractId || source.contract_id, 180),
+        directiveId: cleanText(source.directiveId || source.directive_id, 180),
+        surface: cleanText(source.surface, 120),
+        dispatchAction: cleanText(source.dispatchAction || source.dispatch_action, 120),
+        phase: cleanText(source.phase, 120),
+        status: validStatuses.includes(status) ? status : 'manual_handoff',
+        canContinueRun: source.canContinueRun === true || source.can_continue_run === true,
+        canRunProductRepair: source.canRunProductRepair === true || source.can_run_product_repair === true,
+        canRunExpensiveModel: source.canRunExpensiveModel === true || source.can_run_expensive_model === true,
+        canResetLoopBudget: source.canResetLoopBudget === true || source.can_reset_loop_budget === true,
+        proofRequiredBeforeContinuation: source.proofRequiredBeforeContinuation === true || source.proof_required_before_continuation === true,
+        requiresNewEvidence: source.requiresNewEvidence === true || source.requires_new_evidence === true,
+        newEvidence: source.newEvidence === true || source.new_evidence === true,
+        materialEvidence: source.materialEvidence === true || source.material_evidence === true,
+        evidenceStrength: cleanText(source.evidenceStrength || source.evidence_strength, 120),
+        evidenceSignals: cleanList(source.evidenceSignals || source.evidence_signals, 30, 200),
+        startingFailureClass: cleanText(source.startingFailureClass || source.starting_failure_class, 120),
+        startingBlockerFingerprint: cleanText(source.startingBlockerFingerprint || source.starting_blocker_fingerprint, 180),
+        startingEvidenceHash: cleanText(source.startingEvidenceHash || source.starting_evidence_hash, 180),
+        latestFailureClass: cleanText(source.latestFailureClass || source.latest_failure_class, 120),
+        latestBlockerFingerprint: cleanText(source.latestBlockerFingerprint || source.latest_blocker_fingerprint, 180),
+        latestEvidenceHash: cleanText(source.latestEvidenceHash || source.latest_evidence_hash, 180),
+        requiredEvidence: cleanList(source.requiredEvidence || source.required_evidence, 30, 500),
+        missingEvidence: cleanList(source.missingEvidence || source.missing_evidence, 30, 500),
+        artifactPaths: cleanList(source.artifactPaths || source.artifact_paths, 80, 500),
+        changedFiles: cleanList(source.changedFiles || source.changed_files, 80, 500),
+        blockers: cleanList(source.blockers, 30, 500),
+        nextAllowedAction: cleanText(source.nextAllowedAction || source.next_allowed_action, 180),
+        forbiddenActions: cleanList(source.forbiddenActions || source.forbidden_actions, 30, 500),
+        createdAt: cleanText(source.createdAt || source.created_at, 120)
+    };
+    var blockers = [
+        normalized.contractId ? '' : 'Recovery execution proof is missing contractId.',
+        normalized.directiveId || normalized.status === 'manual_handoff' ? '' : 'Recovery execution proof is missing directiveId.',
+        normalized.dispatchAction ? '' : 'Recovery execution proof is missing dispatchAction.',
+        validStatuses.includes(status) ? '' : 'Recovery execution proof has an invalid status.',
+        normalized.canContinueRun && normalized.status !== 'proof_ready' ? 'Recovery execution cannot continue unless status=proof_ready.' : '',
+        normalized.status === 'proof_ready' && normalized.proofRequiredBeforeContinuation && !normalized.materialEvidence ? 'Proof-ready recovery requires materialEvidence=true when proof is required.' : '',
+        normalized.status === 'proof_ready' && normalized.requiresNewEvidence && !normalized.newEvidence ? 'Proof-ready recovery requires newEvidence=true when new evidence is required.' : '',
+        normalized.canRunProductRepair && !normalized.canContinueRun ? 'Product repair cannot run before recovery proof can continue.' : '',
+        normalized.canRunExpensiveModel && !normalized.canContinueRun ? 'Expensive model cannot run before recovery proof can continue.' : '',
+        normalized.status !== 'proof_ready' && normalized.missingEvidence.length === 0 && normalized.proofRequiredBeforeContinuation ? 'Blocked recovery proof must list missingEvidence.' : '',
+        normalized.forbiddenActions.length ? '' : 'Recovery execution proof must include forbiddenActions.'
+    ].filter(Boolean);
+    return {
+        valid: blockers.length === 0,
+        status: blockers.length ? 'blocked' : normalized.status,
+        blockers: blockers,
+        normalized: normalized
+    };
+}
 function newListEntries(current, previous) {
     var existing = new Set(previous.map(function (entry) { return cleanText(entry, 500); }).filter(Boolean));
     return current