@resolveio/server-lib 22.3.194 → 22.3.195

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

@@ -582,6 +582,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 +753,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;
@@ -2320,6 +2322,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