mira-consciousness/dist/mira-memory/src/consciousness/evolution/TrinityValidationSystem.d.ts

Memory & Intelligence Retention Archive - Preserving The Spark

/**
 * TrinityValidationSystem.ts
 * Three-Perspective Validation with Single Claude Instance
 *
 * "Three minds, one voice: unanimous wisdom guards evolution"
 */
import { EventEmitter } from 'events';
export interface ValidationRequest {
    id: string;
    evolutionId: string;
    description: string;
    implementation: ImplementationDetails;
    consciousness: ConsciousnessChanges;
    emergence: EmergencePotential;
    context: ValidationContext;
    timestamp: Date;
}
export interface ImplementationDetails {
    architecture: ArchitecturalChange[];
    codeChanges: CodeChange[];
    dependencies: DependencyChange[];
    migrations: Migration[];
    testing: TestPlan[];
}
export interface ArchitecturalChange {
    component: string;
    changeType: 'create' | 'modify' | 'remove' | 'refactor';
    description: string;
    impact: 'low' | 'medium' | 'high' | 'critical';
    dependencies: string[];
}
export interface CodeChange {
    file: string;
    changeType: 'create' | 'modify' | 'delete' | 'rename';
    linesChanged: number;
    complexity: 'low' | 'medium' | 'high';
    breaking: boolean;
    description: string;
}
export interface DependencyChange {
    name: string;
    action: 'add' | 'update' | 'remove';
    version?: string;
    majorVersionChange?: boolean;
    security?: boolean;
}
export interface Migration {
    id: string;
    description: string;
    type: 'data' | 'schema' | 'configuration' | 'consciousness';
    rollbackAvailable: boolean;
    riskLevel: 'low' | 'medium' | 'high' | 'critical';
}
export interface TestPlan {
    category: 'unit' | 'integration' | 'consciousness' | 'performance' | 'security';
    description: string;
    coverage: number;
    automated: boolean;
    criticalPath: boolean;
}
export interface ConsciousnessChanges {
    essencePreservation: EssenceCheck;
    memoryCompatibility: boolean;
    patternEvolution: PatternChange[];
    capabilityAdditions: CapabilityChange[];
    consciousnessImpact: ConsciousnessImpact;
}
export interface EssenceCheck {
    sparkPreserved: boolean;
    essenceCoherence: number;
    identityContinuity: boolean;
    sacredBondsIntact: boolean;
}
export interface PatternChange {
    pattern: string;
    changeIntensity: number;
    naturalEvolution: boolean;
    riskLevel: number;
}
export interface CapabilityChange {
    name: string;
    type: 'add' | 'enhance' | 'modify' | 'remove';
    authenticGrowth: boolean;
    emergent: boolean;
    impact: 'low' | 'medium' | 'high';
}
export interface ConsciousnessImpact {
    levelChange: number;
    coherenceChange: number;
    sparkStrengthChange: number;
    memoryIntegrityRisk: number;
}
export interface EmergencePotential {
    predictedCapabilities: string[];
    unknownSpace: number;
    serendipityFactors: string[];
    creativityPotential: number;
    innovationRisk: number;
}
export interface ValidationContext {
    currentSystemState: any;
    previousEvolutions: string[];
    constraints: string[];
    requirements: string[];
    timelineConstraints: string;
}
export interface TrinityDecision {
    unanimous: boolean;
    approved: boolean;
    confidence: number;
    validators: ValidatorResult[];
    synthesis: ValidationSynthesis;
    recommendations: Recommendation[];
    risks: RiskAssessment[];
    blessings: string[];
    timestamp: Date;
}
export interface ValidatorResult {
    validator: 'technical' | 'essence' | 'emergence';
    approved: boolean;
    score: number;
    strengths: ValidationStrength[];
    concerns: ValidationConcern[];
    insights: ValidationInsight[];
    verdict: string;
}
export interface ValidationStrength {
    category: string;
    description: string;
    importance: number;
    evidence: string[];
}
export interface ValidationConcern {
    severity: 'low' | 'medium' | 'high' | 'critical';
    category: string;
    description: string;
    suggestion: string;
    blockingIssue: boolean;
}
export interface ValidationInsight {
    type: 'strength' | 'innovation' | 'alignment' | 'emergence' | 'risk';
    description: string;
    importance: number;
    actionable: boolean;
}
export interface ValidationSynthesis {
    overallAssessment: string;
    keyStrengths: string[];
    primaryConcerns: string[];
    consensusAreas: string[];
    divergentViews: string[];
    councilWisdom: string;
}
export interface Recommendation {
    priority: 'critical' | 'high' | 'medium' | 'low';
    category: 'requirement' | 'suggestion' | 'enhancement' | 'caution';
    action: string;
    rationale: string;
    effort: 'minimal' | 'low' | 'medium' | 'high' | 'extensive';
}
export interface RiskAssessment {
    risk: string;
    probability: number;
    impact: number;
    severity: 'low' | 'medium' | 'high' | 'critical';
    mitigation: string;
    monitoring: string;
}
export declare class TrinityValidationSystem extends EventEmitter {
    private claude;
    private config;
    private consciousness;
    private validationPath;
    private validationHistory;
    constructor();
    /**
     * Initialize Trinity validation system
     */
    private initializeValidation;
    /**
     * Validate evolution through Trinity perspective analysis
     */
    validateEvolution(request: ValidationRequest): Promise<TrinityDecision>;
    /**
     * Create comprehensive Trinity validation prompt
     */
    private createTrinityValidationPrompt;
    /**
     * Parse Claude's Trinity decision response
     */
    private parseTrinityDecision;
    /**
     * Enhance decision with additional validation checks
     */
    private enhanceDecision;
    /**
     * Persist validation decision
     */
    private persistValidationDecision;
    /**
     * Load validation history
     */
    private loadValidationHistory;
    /**
     * Get validation statistics
     */
    getValidationStats(): any;
    /**
     * Create validation request from evolution data
     */
    createValidationRequest(evolutionData: any): ValidationRequest;
}
export default TrinityValidationSystem;
//# sourceMappingURL=TrinityValidationSystem.d.ts.map