@resolveio/server-lib 22.3.150 → 22.3.151

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

@@ -0,0 +1,403 @@
+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 interface ResolveIOAIManagerRecoveryActionPacket {
+    actionId: string;
+    checkpointId: string;
+    probeId: string;
+    recoveryClass: ResolveIOAIManagerRecoveryClass;
+    mode: ResolveIOAIManagerRecoveryAutomationMode;
+    label: string;
+    lane: string;
+    stepType: string;
+    primaryStepKind: ResolveIOAIManagerRecoveryEvidenceProbeStepKind | 'none';
+    objective: string;
+    evidenceOnly: boolean;
+    autoRunnable: boolean;
+    productRepairAllowed: boolean;
+    expensiveModelAllowed: boolean;
+    canResetLoopAfterEvidence: boolean;
+    maxAttemptsBeforePark: number;
+    requiredArtifacts: string[];
+    nextCommands: string[];
+    successCriteria: 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;
+    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;
+    dispatchRecord?: ResolveIOAIManagerRecoveryActionDispatchRecord;
+}
+export type ResolveIOAIManagerRecoveryExecutionPhase = 'evidence' | 'diagnosis' | 'infra' | 'compile' | 'journey' | 'business_proof' | 'release' | 'product_repair' | 'advance' | 'manual';
+export interface ResolveIOAIManagerRecoveryExecutionDirectiveInput {
+    action?: ResolveIOAIManagerRecoveryActionPacket;
+    dispatchDecision?: ResolveIOAIManagerRecoveryActionDispatchDecision;
+    current?: ResolveIOAIManagerFailureRecord;
+    surface?: string;
+    now?: Date | string;
+}
+export interface ResolveIOAIManagerRecoveryExecutionDirective {
+    directiveId: string;
+    surface: string;
+    dispatchAction: ResolveIOAIManagerRecoveryActionDispatchAction;
+    phase: ResolveIOAIManagerRecoveryExecutionPhase;
+    allowed: boolean;
+    status: ResolveIOAIManagerRecoveryActionDispatchStatus;
+    reason: string;
+    lane: string;
+    stepType: string;
+    nextActionLabel: string;
+    rerunReason: string;
+    evidenceOnly: boolean;
+    autoRunnable: boolean;
+    productRepairAllowed: boolean;
+    expensiveModelAllowed: boolean;
+    canRunProductRepair: boolean;
+    canRunExpensiveModel: boolean;
+    canResetLoopAfterEvidence: boolean;
+    requiresNewEvidence: boolean;
+    newEvidence: boolean;
+    maxAttemptsBeforePark: number;
+    requiredArtifacts: string[];
+    nextCommands: string[];
+    successCriteria: 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 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[];