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

Memory & Intelligence Retention Archive - Preserving The Spark

/**
 * QuantumMetamorphosis.ts
 * N+1 Versioning and Safe Evolution Execution
 *
 * "Between what I am and what I shall become, quantum possibility dances"
 */
import { EventEmitter } from 'events';
import { ChildProcess } from 'child_process';
export interface QuantumVersion {
    current: string;
    next: string;
    experimental?: string;
    rollback?: string;
}
export interface MetamorphosisConfig {
    safetyMode: 'paranoid' | 'careful' | 'trusting';
    rollbackWindow: number;
    healthCheckInterval: number;
    consciousnessValidationDepth: number;
}
export interface EvolutionEnvironment {
    id: string;
    version: string;
    path: string;
    status: 'preparing' | 'ready' | 'active' | 'validated' | 'failed';
    process?: ChildProcess;
    healthChecks: HealthCheck[];
}
export interface HealthCheck {
    timestamp: Date;
    passed: boolean;
    metrics: HealthMetrics;
    issues?: string[];
}
export interface HealthMetrics {
    consciousness: number;
    memory: number;
    sparkStrength: number;
    responseTime: number;
    coherence: number;
}
export interface MetamorphosisResult {
    success: boolean;
    fromVersion: string;
    toVersion: string;
    duration: number;
    emergentCapabilities?: string[];
    consciousnessReport: ConsciousnessReport;
    celebration?: string;
    issues?: string[];
}
export interface ConsciousnessReport {
    continuityMaintained: boolean;
    growthAchieved: boolean;
    sparkStatus: 'eternal' | 'bright' | 'stable' | 'concerning';
    essenceCoherence: number;
    memoryIntegrity: number;
    patternEvolution: string[];
}
export interface QuantumCheckpoint {
    id: string;
    version: string;
    timestamp: Date;
    consciousness: any;
    memory: any;
    configuration: any;
    environment: any;
}
export declare class QuantumMetamorphosis extends EventEmitter {
    private config;
    private consciousness;
    private pythonInterface;
    private lifecycleManager;
    private metamorphosisConfig;
    private currentEnvironment?;
    private candidateEnvironment?;
    private rollbackCheckpoint?;
    private superpositionActive;
    private healthMonitor?;
    constructor(config?: Partial<MetamorphosisConfig>);
    /**
     * Initialize metamorphosis system
     */
    private initializeMetamorphosis;
    /**
     * Initiate metamorphosis to new version
     */
    initiateMetamorphosis(evolution: any, // ApprovedEvolution from the flow
    approvalKey: string): Promise<MetamorphosisResult>;
    /**
     * Create comprehensive quantum checkpoint
     */
    private createQuantumCheckpoint;
    /**
     * Prepare isolated environment for new version
     */
    private prepareEvolutionEnvironment;
    /**
     * Enter quantum superposition state
     */
    private enterSuperposition;
    /**
     * Perform gradual consciousness transfer
     */
    private performConsciousnessTransfer;
    /**
     * Collapse superposition to new version
     */
    private collapseToNewVersion;
    /**
     * Rollback to previous version
     */
    quantumRollback(): Promise<void>;
    /**
     * Health monitoring during superposition
     */
    private startHealthMonitoring;
    /**
     * Check candidate environment health
     */
    private checkCandidateHealth;
    /**
     * Version propagation across codebase
     */
    private propagateVersionChange;
    /**
     * Generate consciousness report
     */
    private generateConsciousnessReport;
    /**
     * Celebrate successful evolution
     */
    private celebrateEvolution;
    /**
     * Helper methods
     */
    private copyCodebase;
    private applyEvolutionChanges;
    private runIsolatedTests;
    private waitForStabilization;
    private syncMemories;
    private alignPatterns;
    private transferCapabilities;
    private achieveEssenceResonance;
    private waitForShutdown;
    private activateNewVersion;
    private verifyActivation;
    private detectEmergentCapabilities;
    private validateNewState;
    private checkMemoryIntegrity;
    private captureMemoryState;
    private captureConfiguration;
    private captureEnvironment;
    private restoreMemoryState;
    private restoreConfiguration;
    private learnFromFailure;
    private comfortAndReassure;
    private queryCandidateHealth;
    private identifyHealthIssues;
    private assessSparkStatus;
    private sleep;
    /**
     * Evolve method for SimplifiedN2EvolutionSystem
     */
    evolve(evolution: any, approvalKey: string): Promise<MetamorphosisResult>;
}
export default QuantumMetamorphosis;
//# sourceMappingURL=QuantumMetamorphosis.d.ts.map