@resolveio/server-lib 22.3.221 → 22.3.222

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

@@ -0,0 +1,807 @@
+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 ResolveIOAIManagerHotfixRemoteChecksumProof {
+    host?: string;
+    path?: string;
+    checksumBefore?: string;
+    checksumAfter?: string;
+    checksum?: string;
+    status?: string;
+}
+export interface ResolveIOAIManagerHotfixHostStatusProof {
+    host?: string;
+    status?: string;
+    evidence?: string;
+    checkCount?: number;
+    failedCount?: number;
+}
+export interface ResolveIOAIManagerHotfixEvidence {
+    channel: ResolveIOAIManagerHotfixChannel;
+    status?: ResolveIOAIManagerHotfixEvidenceStatus | string;
+    target: ResolveIOAIManagerHotfixEvidenceTarget;
+    targets?: ResolveIOAIManagerHotfixEvidenceTarget[];
+    compiledArtifactPath?: string;
+    builtDistPath?: string;
+    remoteChecksumBefore?: string;
+    remoteChecksumAfter?: string;
+    remoteChecksum?: string;
+    remoteChecksums?: ResolveIOAIManagerHotfixRemoteChecksumProof[];
+    restartEvidence?: string;
+    restartResults?: ResolveIOAIManagerHotfixHostStatusProof[];
+    healthCheckStatus?: string;
+    healthChecks?: ResolveIOAIManagerHotfixHostStatusProof[];
+    selfTestStatus?: string;
+    selfTests?: ResolveIOAIManagerHotfixHostStatusProof[];
+    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;
+    gitCommitStatus: string;
+    gitPushStatus: string;
+    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 {
+    action?: string;
+    reason?: string;
+    evidence?: any;
+    policy?: ResolveIOAIManagerHotfixFirstReleasePolicy;
+    continuation?: Partial<ResolveIOAIManagerHotfixContinuationDecision> | null;
+    existing?: any;
+    source?: string;
+    releaseGatePassed?: boolean;
+    now?: Date | string;
+}
+export interface ResolveIOAIManagerHotfixDurabilityContract {
+    contractId: string;
+    contract_id: string;
+    createdAt: string;
+    created_at: string;
+    updatedAt: string;
+    updated_at: string;
+    source: string;
+    required: boolean;
+    action: string;
+    status: ResolveIOAIManagerHotfixDurabilityStatus;
+    reason: string;
+    canPrepareHotfixPatch: boolean;
+    can_prepare_hotfix_patch: boolean;
+    canHotfixBackend: boolean;
+    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';
+    commit_proof_status: ResolveIOAIManagerHotfixGitProofStatus | 'missing';
+    sourceCommitSha: string;
+    source_commit_sha: string;
+    githubCommitUrl: string;
+    github_commit_url: string;
+    gitCommitStatus: string;
+    git_commit_status: string;
+    gitPushStatus: string;
+    git_push_status: string;
+    missingCommitProofFields: string[];
+    missing_commit_proof_fields: string[];
+    nextSafeAction: string;
+    next_safe_action: string;
+    phaseOrder: string[];
+    phase_order: string[];
+    requiredFields: string[];
+    required_fields: string[];
+    requiredEvidence: string[];
+    required_evidence: string[];
+    successCriteria: string[];
+    success_criteria: string[];
+    forbiddenActions: string[];
+    forbidden_actions: string[];
+    hotfixCommitGuard: Record<string, any>;
+    hotfix_commit_guard: Record<string, any>;
+    githubCommitGuard: ResolveIOAIManagerHotfixGitProof;
+    github_commit_guard: ResolveIOAIManagerHotfixGitProof;
+    validation: ResolveIOAIManagerHotfixEvidenceValidation;
+    continuation?: Partial<ResolveIOAIManagerHotfixContinuationDecision> | null;
+    extraRequest: string;
+    extra_request: string;
+}
+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 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;
+    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 buildResolveIOAIManagerHotfixDurabilityContract(input?: ResolveIOAIManagerHotfixDurabilityContractInput): ResolveIOAIManagerHotfixDurabilityContract;
+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 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;
+export declare function decideResolveIOAIManagerPolicy(input: ResolveIOAIManagerPolicyInput): ResolveIOAIManagerPolicyDecision;
+export declare function buildResolveIOAIManagerRecoveryReplayMatrix(input?: ResolveIOAIManagerRecoveryReplayMatrixInput): ResolveIOAIManagerRecoveryReplayCase[];