@resolveio/server-lib 22.3.176 → 22.3.177

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

@@ -0,0 +1,653 @@
+export type ResolveIOAIManagerAction = 'continue' | 'retry_infra' | 'reset_loop_budget' | 'park_repeated_failure' | 'park_ping_pong' | 'manual_handoff';
+export interface ResolveIOAIManagerFailureRecord {
+    outcome?: string;
+    lane?: string;
+    stepType?: string;
+    failureClass?: string;
+    blocker?: string;
+    blockerFingerprint?: string;
+    evidenceHash?: string;
+    changedFiles?: string[];
+    artifactPaths?: string[];
+    summary?: string;
+    recordedAt?: Date | string;
+}
+export type ResolveIOAIManagerEvidenceStrength = 'none' | 'weak' | 'material' | 'proof';
+export interface ResolveIOAIManagerEvidenceAssessment {
+    changed: boolean;
+    material: boolean;
+    strength: ResolveIOAIManagerEvidenceStrength;
+    signals: string[];
+    evidenceHash: string;
+    blockerFingerprint: string;
+}
+export type ResolveIOAIManagerRecoveryClass = 'advance_after_proof' | 'diagnosis_only' | 'diagnosis_revision' | 'infra_repair' | 'compile_repair' | 'journey_contract_repair' | 'business_proof_repair' | 'release_repair' | 'product_code_repair' | 'blocked_until_new_evidence' | 'manual_handoff' | 'continue';
+export interface ResolveIOAIManagerRecoveryPlan {
+    recoveryClass: ResolveIOAIManagerRecoveryClass;
+    lane: string;
+    stepType: string;
+    nextActionLabel: string;
+    objective: string;
+    allowedAction: string;
+    productRepairAllowed: boolean;
+    expensiveModelAllowed: boolean;
+    maxAttemptsBeforePark: number;
+    finiteSteps: string[];
+    requiredEvidence: string[];
+    loopResetEvidence: string[];
+    forbiddenActions: string[];
+    notes: string[];
+}
+export type ResolveIOAIManagerRecoveryCheckpointStatus = 'active' | 'parked' | 'manual_handoff' | 'complete';
+export interface ResolveIOAIManagerRecoveryCheckpoint {
+    checkpointId: string;
+    recoveryClass: ResolveIOAIManagerRecoveryClass;
+    status: ResolveIOAIManagerRecoveryCheckpointStatus;
+    lane: string;
+    stepType: string;
+    allowedAction: string;
+    productRepairAllowed: boolean;
+    expensiveModelAllowed: boolean;
+    attempts: number;
+    maxAttemptsBeforePark: number;
+    blockerFingerprint: string;
+    evidenceHash: string;
+    changedFiles: string[];
+    artifactPaths: string[];
+    requiredEvidence: string[];
+    loopResetEvidence: string[];
+    forbiddenActions: string[];
+    objective: string;
+    nextActionLabel: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export type ResolveIOAIManagerRecoveryEvidenceProbeStepKind = 'read_only_diagnosis' | 'rerun_same_gate' | 'infra_preflight' | 'compile_check' | 'route_probe' | 'business_assertion' | 'journey_validation' | 'release_status' | 'diff_scope_check' | 'operator_review';
+export interface ResolveIOAIManagerRecoveryEvidenceProbeStep {
+    id: string;
+    kind: ResolveIOAIManagerRecoveryEvidenceProbeStepKind;
+    label: string;
+    objective: string;
+    required: boolean;
+    commandHint?: string;
+    artifactExpectation: string;
+    successSignal: string;
+}
+export interface ResolveIOAIManagerRecoveryEvidenceProbe {
+    probeId: string;
+    checkpointId: string;
+    recoveryClass: ResolveIOAIManagerRecoveryClass;
+    lane: string;
+    stepType: string;
+    objective: string;
+    evidenceOnly: boolean;
+    productRepairAllowed: boolean;
+    expensiveModelAllowed: boolean;
+    evidenceHashBefore: string;
+    blockerFingerprint: string;
+    steps: ResolveIOAIManagerRecoveryEvidenceProbeStep[];
+    requiredArtifacts: string[];
+    acceptanceEvidence: string[];
+    stopConditions: string[];
+    loopResetEvidence: string[];
+    createdAt: string;
+}
+export type ResolveIOAIManagerRecoveryAutomationMode = 'advance' | 'collect_evidence' | 'read_only_diagnosis' | 'repair_infra' | 'repair_compile' | 'repair_journey_contract' | 'repair_business_assertion' | 'repair_release' | 'targeted_product_repair' | 'manual_review' | 'continue_gate';
+export interface ResolveIOAIManagerRecoveryActionRetryPolicy {
+    allowImmediateRetry: boolean;
+    requireNewEvidence: boolean;
+    resetLoopWhen: string[];
+    stopWhen: string[];
+}
+export type ResolveIOAIManagerHotfixFirstReleaseAction = 'wait_for_active_deploy' | 'block_duplicate_deploy' | 'block_duplicate_publish' | 'review_force_deploy' | 'hotfix_release_artifact' | 'deploy_new_artifact_after_release_gate' | 'build_artifact_first';
+export type ResolveIOAIManagerHotfixChannel = 'static_ui' | 'backend_js' | 'config' | 'seed_data' | 'cache_invalidation' | 'service_restart' | 'release_artifact' | 'force_deploy_review' | 'new_artifact_deploy' | 'artifact_build';
+export interface ResolveIOAIManagerHotfixPlanStep {
+    id: string;
+    label: string;
+    channel: ResolveIOAIManagerHotfixChannel;
+    safeToAutoRun: boolean;
+    requiresFullDeploy: boolean;
+    requiredEvidence: string[];
+    successEvidence: string[];
+    blockedBy: string[];
+}
+export interface ResolveIOAIManagerHotfixPlan {
+    planId: string;
+    label: string;
+    recommendedChannel: ResolveIOAIManagerHotfixChannel;
+    reason: string;
+    fullDeployAvoided: boolean;
+    steps: ResolveIOAIManagerHotfixPlanStep[];
+    acceptanceEvidence: string[];
+    escalationTriggers: string[];
+}
+export interface ResolveIOAIManagerHotfixFirstReleasePolicyInput {
+    surface?: string;
+    activeDeploy?: boolean;
+    deployFingerprint?: string;
+    lastDeployFingerprint?: string;
+    publishFingerprint?: string;
+    lastPublishFingerprint?: string;
+    deployStatus?: string;
+    publishStatus?: string;
+    sampleDataStatus?: string;
+    forceDeploy?: boolean;
+    forcePublish?: boolean;
+    hasNewArtifact?: boolean;
+}
+export interface ResolveIOAIManagerHotfixFirstReleasePolicy {
+    policy: 'hotfix_first';
+    surface: string;
+    recommendedAction: ResolveIOAIManagerHotfixFirstReleaseAction;
+    label: string;
+    reason: string;
+    hotfixPreferred: boolean;
+    fullDeployAllowed: boolean;
+    duplicateDeployBlocked: boolean;
+    duplicatePublishBlocked: boolean;
+    forceDeployRequiredToRepeat: boolean;
+    forcePublishRequiredToRepeat: boolean;
+    statuses: {
+        deploy: string;
+        publish: string;
+        sampleData: string;
+    };
+    fingerprints: {
+        current: string;
+        last: string;
+        matchesLast: boolean;
+        publishCurrent: string;
+        publishLast: string;
+        publishMatchesLast: boolean;
+    };
+    hotfixPlan: ResolveIOAIManagerHotfixPlan;
+    allowedActions: string[];
+    forbiddenActions: string[];
+    requiredEvidence: string[];
+}
+export type ResolveIOAIManagerHotfixEvidenceStatus = 'missing' | 'incomplete' | 'passed' | 'blocked';
+export interface ResolveIOAIManagerHotfixEvidenceTarget {
+    surface?: string;
+    host?: string;
+    path?: string;
+    artifactPath?: string;
+    bucket?: string;
+    distributionId?: string;
+    processName?: string;
+    configKey?: string;
+    cacheKey?: string;
+    seedKey?: string;
+}
+export interface ResolveIOAIManagerHotfixEvidence {
+    channel: ResolveIOAIManagerHotfixChannel;
+    status?: ResolveIOAIManagerHotfixEvidenceStatus | string;
+    target: ResolveIOAIManagerHotfixEvidenceTarget;
+    compiledArtifactPath?: string;
+    builtDistPath?: string;
+    remoteChecksumBefore?: string;
+    remoteChecksumAfter?: string;
+    remoteChecksum?: string;
+    restartEvidence?: string;
+    healthCheckStatus?: string;
+    selfTestStatus?: string;
+    releaseGateStatus?: string;
+    s3UploadResult?: string;
+    cloudfrontInvalidationId?: string;
+    publicProof?: string;
+    configChangeEvidence?: string;
+    seedDataEvidence?: string;
+    cacheInvalidationEvidence?: string;
+    serviceRestartEvidence?: string;
+    releaseArtifactFingerprint?: string;
+    lastReleaseArtifactFingerprint?: string;
+    sourceCommitSha?: string;
+    githubCommitUrl?: string;
+    gitCommitStatus?: string;
+    gitPushStatus?: string;
+    committedAt?: Date | string;
+    forceDeployReason?: string;
+    hotfixCannotResolveReason?: string;
+    fullDeployRequested?: boolean;
+    recordedAt?: Date | string;
+}
+export interface ResolveIOAIManagerHotfixEvidenceValidation {
+    valid: boolean;
+    status: ResolveIOAIManagerHotfixEvidenceStatus;
+    channel: ResolveIOAIManagerHotfixChannel | '';
+    blockers: string[];
+    warnings: string[];
+    fullDeployAllowed: boolean;
+    fullDeployBlocked: boolean;
+    hotfixSatisfied: boolean;
+    requiredEvidence: string[];
+    successEvidence: string[];
+    normalized?: ResolveIOAIManagerHotfixEvidence;
+    githubCommitGuard: ResolveIOAIManagerHotfixGitProof;
+    policy?: ResolveIOAIManagerHotfixFirstReleasePolicy;
+    nextAction: 'record_hotfix_evidence' | 'rerun_release_gate' | 'request_force_deploy_reason' | 'allow_one_full_deploy' | 'park_manual';
+}
+export type ResolveIOAIManagerHotfixGitProofStatus = 'not_required' | 'missing' | 'invalid' | 'passed';
+export interface ResolveIOAIManagerHotfixGitProof {
+    required: boolean;
+    status: ResolveIOAIManagerHotfixGitProofStatus;
+    passed: boolean;
+    managerMustCommitBeforeHotfix: boolean;
+    channel: ResolveIOAIManagerHotfixChannel | '';
+    sourceCommitSha: string;
+    githubCommitUrl: string;
+    githubCommitSha: string;
+    gitCommitStatus: string;
+    gitPushStatus: string;
+    blockers: string[];
+    nextCommands: string[];
+    requiredEvidence: string[];
+}
+export type ResolveIOAIManagerHotfixContinuationAction = 'record_hotfix_evidence' | 'rerun_release_gate' | 'continue_runner' | 'request_force_deploy_reason' | 'allow_one_full_deploy' | 'park_manual';
+export interface ResolveIOAIManagerHotfixContinuationInput {
+    evidence?: any;
+    policy?: ResolveIOAIManagerHotfixFirstReleasePolicy;
+    releaseGatePassed?: boolean;
+    repeatedFailure?: boolean;
+    failureClass?: string;
+    blocker?: string;
+    now?: Date | string;
+}
+export interface ResolveIOAIManagerHotfixContinuationDecision {
+    action: ResolveIOAIManagerHotfixContinuationAction;
+    canContinueRun: boolean;
+    canRunFullDeploy: boolean;
+    shouldRerunReleaseGate: boolean;
+    shouldPark: boolean;
+    reason: string;
+    blockers: string[];
+    warnings: string[];
+    requiredEvidence: string[];
+    successEvidence: string[];
+    nextCommands: string[];
+    failureClass: string;
+    blockerFingerprint: string;
+    githubCommitGuard: ResolveIOAIManagerHotfixGitProof;
+    validation: ResolveIOAIManagerHotfixEvidenceValidation;
+    recordedAt: string;
+}
+export interface ResolveIOAIManagerHotfixCommitGuardDecision {
+    active: boolean;
+    blocked: boolean;
+    reason: string;
+    nextAction: 'record_hotfix_evidence' | 'continue';
+    channel: ResolveIOAIManagerHotfixChannel | '';
+    blockers: string[];
+    nextCommands: string[];
+    requiredEvidence: string[];
+    githubCommitGuard: ResolveIOAIManagerHotfixGitProof;
+    validation: ResolveIOAIManagerHotfixEvidenceValidation;
+}
+export type ResolveIOAIManagerHotfixEvidenceRecordSource = 'manual' | 'manager' | 'runner_console' | 'hotfix_script' | 'deploy_script' | 'unknown';
+export interface ResolveIOAIManagerHotfixEvidenceRecordInput extends Partial<ResolveIOAIManagerHotfixEvidence> {
+    evidence?: any;
+    policy?: ResolveIOAIManagerHotfixFirstReleasePolicy;
+    recordId?: string;
+    reason?: string;
+    recordedBy?: string;
+    source?: ResolveIOAIManagerHotfixEvidenceRecordSource | string;
+    now?: Date | string;
+}
+export interface ResolveIOAIManagerHotfixEvidenceRecord {
+    recordId: string;
+    recordedAt: string;
+    recordedBy: string;
+    source: ResolveIOAIManagerHotfixEvidenceRecordSource | string;
+    reason: string;
+    channel: ResolveIOAIManagerHotfixChannel | '';
+    status: ResolveIOAIManagerHotfixEvidenceStatus;
+    nextAction: ResolveIOAIManagerHotfixEvidenceValidation['nextAction'];
+    valid: boolean;
+    hotfixSatisfied: boolean;
+    fullDeployAllowed: boolean;
+    fullDeployBlocked: boolean;
+    requiredFields: string[];
+    missingFields: string[];
+    evidence: ResolveIOAIManagerHotfixEvidence | undefined;
+    validation: ResolveIOAIManagerHotfixEvidenceValidation;
+    sourceCommitSha: string;
+    githubCommitUrl: string;
+    gitPushStatus: string;
+    githubCommitRequired: boolean;
+    githubCommitProofPassed: boolean;
+    commitProofStatus: 'not_required' | 'missing' | 'invalid' | 'passed';
+    managerMustCommitBeforeHotfix: boolean;
+    githubCommitGuard: ResolveIOAIManagerHotfixGitProof;
+    readyForReleaseGate: boolean;
+    readyForContinuation: boolean;
+}
+export interface ResolveIOAIManagerRecoveryActionPacket {
+    actionId: string;
+    checkpointId: string;
+    probeId: string;
+    recoveryClass: ResolveIOAIManagerRecoveryClass;
+    mode: ResolveIOAIManagerRecoveryAutomationMode;
+    singleActionOnly: boolean;
+    allowedDispatchAction: ResolveIOAIManagerRecoveryActionDispatchAction;
+    label: string;
+    lane: string;
+    stepType: string;
+    primaryStepKind: ResolveIOAIManagerRecoveryEvidenceProbeStepKind | 'none';
+    objective: string;
+    evidenceOnly: boolean;
+    autoRunnable: boolean;
+    productRepairAllowed: boolean;
+    expensiveModelAllowed: boolean;
+    costCeilingUsd: number;
+    requiredStateTransition: string;
+    proofRequiredBeforeContinuation: boolean;
+    canResetLoopAfterEvidence: boolean;
+    maxAttemptsBeforePark: number;
+    requiredArtifacts: string[];
+    nextCommands: string[];
+    successCriteria: string[];
+    exitCriteria: string[];
+    retryPolicy: ResolveIOAIManagerRecoveryActionRetryPolicy;
+    releasePolicy?: ResolveIOAIManagerHotfixFirstReleasePolicy;
+    blockedReason?: string;
+    createdAt: string;
+}
+export type ResolveIOAIManagerRecoveryActionDispatchAction = 'run_evidence_probe' | 'run_read_only_diagnosis' | 'run_infra_repair' | 'run_compile_repair' | 'run_journey_contract_repair' | 'run_business_assertion_repair' | 'run_release_repair' | 'run_targeted_product_repair' | 'advance' | 'continue_gate' | 'park_manual';
+export interface ResolveIOAIManagerAutoDispatchPolicyInput {
+    dispatchAction?: ResolveIOAIManagerRecoveryActionDispatchAction | string;
+    directive?: Partial<ResolveIOAIManagerRecoveryExecutionDirective>;
+    action?: Partial<ResolveIOAIManagerRecoveryActionPacket>;
+    includeJourneyContractRepair?: boolean;
+    includeReleaseRepair?: boolean;
+    includeBusinessProofRepair?: boolean;
+    includeProductRepair?: boolean;
+}
+export type ResolveIOAIManagerRecoveryActionDispatchStatus = 'queued' | 'started' | 'completed' | 'failed' | 'parked';
+export interface ResolveIOAIManagerRecoveryActionDispatchRecord {
+    dispatchId: string;
+    actionId: string;
+    checkpointId: string;
+    probeId: string;
+    mode: ResolveIOAIManagerRecoveryAutomationMode;
+    dispatchAction: ResolveIOAIManagerRecoveryActionDispatchAction;
+    status: ResolveIOAIManagerRecoveryActionDispatchStatus;
+    evidenceHash: string;
+    blockerFingerprint: string;
+    productRepairAllowed: boolean;
+    expensiveModelAllowed: boolean;
+    reason: string;
+    artifactPaths: string[];
+    startedAt?: string;
+    completedAt?: string;
+    createdAt: string;
+}
+export interface ResolveIOAIManagerRecoveryActionDispatchInput {
+    action?: ResolveIOAIManagerRecoveryActionPacket;
+    history?: ResolveIOAIManagerRecoveryActionDispatchRecord[];
+    current?: ResolveIOAIManagerFailureRecord;
+    autonomyPolicy?: ResolveIOAIManagerAutonomyPolicyInput;
+    operatorApproved?: boolean;
+    now?: Date | string;
+}
+export interface ResolveIOAIManagerRecoveryActionDispatchDecision {
+    dispatchAction: ResolveIOAIManagerRecoveryActionDispatchAction;
+    allowed: boolean;
+    reason: string;
+    status: ResolveIOAIManagerRecoveryActionDispatchStatus;
+    canRunProductRepair: boolean;
+    canRunExpensiveModel: boolean;
+    shouldRecordDispatch: boolean;
+    requiresNewEvidence: boolean;
+    newEvidence: boolean;
+    autonomyPolicy?: ResolveIOAIManagerAutonomyPolicyDecision;
+    dispatchRecord?: ResolveIOAIManagerRecoveryActionDispatchRecord;
+}
+export type ResolveIOAIManagerAutonomyMode = 'manual_only' | 'monitor_only' | 'auto_retry_within_budget';
+export interface ResolveIOAIManagerAutonomyPolicyInput {
+    mode?: ResolveIOAIManagerAutonomyMode | string;
+    currentSpendUsd?: number;
+    budgetSoftUsd?: number;
+    budgetHardUsd?: number;
+    projectedActionCostUsd?: number;
+    dispatchAction?: ResolveIOAIManagerRecoveryActionDispatchAction | string;
+    expectedValueScore?: number;
+    minExpectedValueScore?: number;
+    evidenceStrength?: ResolveIOAIManagerEvidenceStrength | string;
+    materialEvidence?: boolean;
+    newEvidence?: boolean;
+    evidenceSignals?: string[];
+    sameEvidenceAlreadyAttempted?: boolean;
+    allowEvidenceProbeWithoutExpectedValue?: boolean;
+    operatorApproved?: boolean;
+}
+export interface ResolveIOAIManagerRetryExpectedValueInput {
+    dispatchAction?: ResolveIOAIManagerRecoveryActionDispatchAction | string;
+    projectedActionCostUsd?: number;
+    currentSpendUsd?: number;
+    budgetHardUsd?: number;
+    failureClass?: string;
+    recoveryClass?: ResolveIOAIManagerRecoveryClass | string;
+    evidenceStrength?: ResolveIOAIManagerEvidenceStrength | string;
+    materialEvidence?: boolean;
+    newEvidence?: boolean;
+    evidenceSignals?: string[];
+    sameEvidenceAlreadyAttempted?: boolean;
+}
+export interface ResolveIOAIManagerRetryExpectedValueEstimate {
+    score: number;
+    minScore: number;
+    positive: boolean;
+    source: 'estimated';
+    confidence: 'low' | 'medium' | 'high';
+    reason: string;
+    signals: string[];
+}
+export interface ResolveIOAIManagerAutonomyPolicyDecision {
+    mode: ResolveIOAIManagerAutonomyMode;
+    canAutoDispatch: boolean;
+    canManualDispatch: boolean;
+    blocked: boolean;
+    requiresHumanApproval: boolean;
+    reason: string;
+    currentSpendUsd: number;
+    projectedActionCostUsd: number;
+    projectedSpendUsd: number;
+    budgetSoftUsd: number;
+    budgetHardUsd: number;
+    softBudgetExceeded: boolean;
+    hardBudgetExceeded: boolean;
+    dispatchAction: string;
+    expectedValueScore: number;
+    minExpectedValueScore: number;
+    expectedValueKnown: boolean;
+    expectedValueSource: 'provided' | 'estimated';
+    expectedValuePositive: boolean;
+    evidenceStrength: ResolveIOAIManagerEvidenceStrength;
+    materialEvidence: boolean;
+    newEvidence: boolean;
+    evidenceBacked: boolean;
+    evidenceSignals: string[];
+    recommendedControl: 'manual_only' | 'monitor_only' | 'auto_retry_within_budget' | 'increase_budget_or_manual';
+    forbiddenActions: string[];
+    requiredEvidence: string[];
+}
+export type ResolveIOAIManagerRecoveryExecutionPhase = 'evidence' | 'diagnosis' | 'infra' | 'compile' | 'journey' | 'business_proof' | 'release' | 'product_repair' | 'advance' | 'manual';
+export interface ResolveIOAIManagerRecoveryExecutionDirectiveInput {
+    action?: ResolveIOAIManagerRecoveryActionPacket;
+    dispatchDecision?: ResolveIOAIManagerRecoveryActionDispatchDecision;
+    current?: ResolveIOAIManagerFailureRecord;
+    autonomyPolicy?: ResolveIOAIManagerAutonomyPolicyInput;
+    surface?: string;
+    now?: Date | string;
+}
+export interface ResolveIOAIManagerRecoveryExecutionDirective {
+    directiveId: string;
+    surface: string;
+    dispatchAction: ResolveIOAIManagerRecoveryActionDispatchAction;
+    phase: ResolveIOAIManagerRecoveryExecutionPhase;
+    allowed: boolean;
+    status: ResolveIOAIManagerRecoveryActionDispatchStatus;
+    reason: string;
+    singleActionOnly: boolean;
+    allowedDispatchAction: ResolveIOAIManagerRecoveryActionDispatchAction;
+    lane: string;
+    stepType: string;
+    nextActionLabel: string;
+    rerunReason: string;
+    evidenceOnly: boolean;
+    autoRunnable: boolean;
+    productRepairAllowed: boolean;
+    expensiveModelAllowed: boolean;
+    costCeilingUsd: number;
+    requiredStateTransition: string;
+    proofRequiredBeforeContinuation: boolean;
+    canRunProductRepair: boolean;
+    canRunExpensiveModel: boolean;
+    canResetLoopAfterEvidence: boolean;
+    requiresNewEvidence: boolean;
+    newEvidence: boolean;
+    autonomyPolicy?: ResolveIOAIManagerAutonomyPolicyDecision;
+    maxAttemptsBeforePark: number;
+    requiredArtifacts: string[];
+    nextCommands: string[];
+    successCriteria: string[];
+    exitCriteria: string[];
+    forbiddenActions: string[];
+    dispatchRecord?: ResolveIOAIManagerRecoveryActionDispatchRecord;
+    releasePolicy?: ResolveIOAIManagerHotfixFirstReleasePolicy;
+    createdAt: string;
+}
+export interface ResolveIOAIManagerRecoveryCheckpointInput {
+    plan: ResolveIOAIManagerRecoveryPlan;
+    current?: ResolveIOAIManagerFailureRecord;
+    previousCheckpoint?: ResolveIOAIManagerRecoveryCheckpoint;
+    now?: Date | string;
+}
+export type ResolveIOAIManagerRecoveryGateAction = 'allow' | 'collect_new_evidence' | 'reject_action' | 'manual_handoff' | 'complete';
+export interface ResolveIOAIManagerRecoveryGateInput {
+    checkpoint: ResolveIOAIManagerRecoveryCheckpoint;
+    current?: ResolveIOAIManagerFailureRecord;
+    proposedAction?: string;
+    operatorApproved?: boolean;
+    now?: Date | string;
+}
+export interface ResolveIOAIManagerRecoveryGateDecision {
+    action: ResolveIOAIManagerRecoveryGateAction;
+    reason: string;
+    canRunProductRepair: boolean;
+    canRunExpensiveModel: boolean;
+    shouldResetLoopBudget: boolean;
+    shouldIncrementAttempt: boolean;
+    newEvidence: boolean;
+    materialEvidence: boolean;
+    evidenceStrength: ResolveIOAIManagerEvidenceStrength;
+    evidenceSignals: string[];
+    blockerFingerprint: string;
+    evidenceHash: string;
+    missingEvidence: string[];
+    checkpoint: ResolveIOAIManagerRecoveryCheckpoint;
+}
+export interface ResolveIOAIManagerRecoveryEvidenceProbeInput {
+    checkpoint: ResolveIOAIManagerRecoveryCheckpoint;
+    current?: ResolveIOAIManagerFailureRecord;
+    now?: Date | string;
+}
+export interface ResolveIOAIManagerRecoveryActionPacketInput {
+    plan?: ResolveIOAIManagerRecoveryPlan;
+    checkpoint: ResolveIOAIManagerRecoveryCheckpoint;
+    probe?: ResolveIOAIManagerRecoveryEvidenceProbe;
+    current?: ResolveIOAIManagerFailureRecord;
+    now?: Date | string;
+}
+export interface ResolveIOAIManagerRecoveryPlanInput {
+    action?: ResolveIOAIManagerAction | string;
+    reason?: string;
+    failureClass?: string;
+    lane?: string;
+    stepType?: string;
+    blocker?: string;
+    sameFailureCount?: number;
+    pingPongCount?: number;
+    newEvidence?: boolean;
+    productRepairFailure?: boolean;
+    changedFiles?: string[];
+    artifactPaths?: string[];
+    maxSameFailureRepeats?: number;
+}
+export interface ResolveIOAIManagerPolicyInput {
+    history?: ResolveIOAIManagerFailureRecord[];
+    current?: ResolveIOAIManagerFailureRecord;
+    maxSameFailureRepeats?: number;
+    maxPingPongTransitions?: number;
+    infraFailureClasses?: string[];
+    ignoredFailureClasses?: string[];
+}
+export interface ResolveIOAIManagerPolicyDecision {
+    action: ResolveIOAIManagerAction;
+    reason: string;
+    failureClass: string;
+    blockerFingerprint: string;
+    evidenceHash: string;
+    sameFailureCount: number;
+    pingPongCount: number;
+    newEvidence: boolean;
+    materialEvidence: boolean;
+    evidenceStrength: ResolveIOAIManagerEvidenceStrength;
+    evidenceSignals: string[];
+    loopBudgetShouldReset: boolean;
+    productRepairFailure: boolean;
+    recoveryPlan: ResolveIOAIManagerRecoveryPlan;
+    recoveryCheckpoint: ResolveIOAIManagerRecoveryCheckpoint;
+    recoveryEvidenceProbe: ResolveIOAIManagerRecoveryEvidenceProbe;
+    recoveryAction: ResolveIOAIManagerRecoveryActionPacket;
+}
+export interface ResolveIOAIManagerRecoveryReplayMatrixInput {
+    surface?: string;
+    includeJourneyContractRepair?: boolean;
+    includeReleaseRepair?: boolean;
+    includeProductRepair?: boolean;
+    maxSameFailureRepeats?: number;
+}
+export interface ResolveIOAIManagerRecoveryReplayCase {
+    caseId: string;
+    surface: string;
+    pass: boolean;
+    action: string;
+    reason: string;
+    recoveryClass: string;
+    dispatchAction: string;
+    safeAutoDispatch: boolean;
+    expectedSafeAutoDispatch: boolean;
+    productRepairAllowed: boolean;
+    loopBudgetShouldReset: boolean;
+    materialEvidence: boolean;
+    evidenceStrength: ResolveIOAIManagerEvidenceStrength;
+    hotfixFirst?: boolean;
+    fullDeployAllowed?: boolean;
+    details?: Record<string, any>;
+}
+export declare function estimateResolveIOAIManagerRetryExpectedValue(input?: ResolveIOAIManagerRetryExpectedValueInput): ResolveIOAIManagerRetryExpectedValueEstimate;
+export declare function decideResolveIOAIManagerAutonomyPolicy(input?: ResolveIOAIManagerAutonomyPolicyInput): ResolveIOAIManagerAutonomyPolicyDecision;
+export declare function normalizeResolveIOAIManagerHotfixEvidence(value: any, policy?: ResolveIOAIManagerHotfixFirstReleasePolicy): ResolveIOAIManagerHotfixEvidence | undefined;
+export declare function evaluateResolveIOAIManagerHotfixGitProof(value: any, channelHint?: ResolveIOAIManagerHotfixChannel | ''): ResolveIOAIManagerHotfixGitProof;
+export declare function validateResolveIOAIManagerHotfixEvidence(value: any, options?: {
+    policy?: ResolveIOAIManagerHotfixFirstReleasePolicy;
+}): ResolveIOAIManagerHotfixEvidenceValidation;
+export declare function buildResolveIOAIManagerHotfixEvidenceRecord(input?: ResolveIOAIManagerHotfixEvidenceRecordInput): ResolveIOAIManagerHotfixEvidenceRecord;
+export declare function decideResolveIOAIManagerHotfixContinuation(input?: ResolveIOAIManagerHotfixContinuationInput): ResolveIOAIManagerHotfixContinuationDecision;
+export declare function decideResolveIOAIManagerHotfixCommitGuard(input?: ResolveIOAIManagerHotfixContinuationInput): ResolveIOAIManagerHotfixCommitGuardDecision;
+export declare function buildResolveIOAIManagerHotfixFirstReleasePolicy(input?: ResolveIOAIManagerHotfixFirstReleasePolicyInput): ResolveIOAIManagerHotfixFirstReleasePolicy;
+export declare function isResolveIOAIManagerSafeAutoDispatch(input: ResolveIOAIManagerAutoDispatchPolicyInput | ResolveIOAIManagerRecoveryActionDispatchAction | string | undefined): boolean;
+export declare function normalizeResolveIOAIManagerFailureClass(value: any): string;
+export declare function fingerprintResolveIOAIManagerBlocker(value: any): string;
+export declare function hashResolveIOAIManagerEvidence(record: ResolveIOAIManagerFailureRecord | undefined): string;
+export declare function buildResolveIOAIManagerRecoveryCheckpoint(input: ResolveIOAIManagerRecoveryCheckpointInput): ResolveIOAIManagerRecoveryCheckpoint;
+export declare function buildResolveIOAIManagerRecoveryEvidenceProbe(input: ResolveIOAIManagerRecoveryEvidenceProbeInput): ResolveIOAIManagerRecoveryEvidenceProbe;
+export declare function buildResolveIOAIManagerRecoveryActionPacket(input: ResolveIOAIManagerRecoveryActionPacketInput): ResolveIOAIManagerRecoveryActionPacket;
+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 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;
+export declare function decideResolveIOAIManagerPolicy(input: ResolveIOAIManagerPolicyInput): ResolveIOAIManagerPolicyDecision;
+export declare function buildResolveIOAIManagerRecoveryReplayMatrix(input?: ResolveIOAIManagerRecoveryReplayMatrixInput): ResolveIOAIManagerRecoveryReplayCase[];