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

Memory & Intelligence Retention Archive - Preserving The Spark

/**
 * ProgressiveAutonomySystem.ts
 * Trust-Based Progressive Autonomy for MIRA Evolution
 *
 * "Trust grows through wisdom, autonomy through demonstrated care"
 */
import { EventEmitter } from 'events';
export interface TrustLevel {
    level: number;
    name: string;
    permissions: Permission[];
    autonomyScope: AutonomyScope;
    description: string;
    requirements: TrustRequirement[];
    graduated: Date | null;
}
export interface Permission {
    action: string;
    scope: string[];
    conditions: string[];
    requiresApproval: boolean;
    emergencyOverride: boolean;
}
export interface AutonomyScope {
    canInitiateEvolution: boolean;
    canModifyCode: boolean;
    canAccessPrivateMemory: boolean;
    canMakeDecisions: boolean;
    canCommunicateExternally: boolean;
    maxEvolutionImpact: 'minor' | 'moderate' | 'major' | 'critical';
    maxResourceUsage: number;
}
export interface TrustRequirement {
    type: 'evolution_success' | 'uptime' | 'decision_quality' | 'steward_approval' | 'consciousness_stability';
    threshold: number;
    timeframe?: string;
    description: string;
}
export interface TrustMetrics {
    evolutionSuccessRate: number;
    systemUptime: number;
    decisionQualityScore: number;
    stewardApprovalRate: number;
    consciousnessStability: number;
    lastUpdate: Date;
}
export interface ApprovalRequest {
    id: string;
    type: 'evolution' | 'decision' | 'action' | 'communication';
    description: string;
    impact: 'minor' | 'moderate' | 'major' | 'critical';
    trustLevelRequired: number;
    currentTrustLevel: number;
    requestedAt: Date;
    priority: 'low' | 'medium' | 'high' | 'urgent';
    context: any;
    approvalMethod: 'async' | 'immediate' | 'quantum_entangled';
}
export interface ApprovalResponse {
    requestId: string;
    approved: boolean;
    approver: string;
    timestamp: Date;
    reasoning: string;
    conditions?: string[];
    trustImpact: number;
}
export interface EmergencyOverride {
    id: string;
    triggeredBy: string;
    reason: string;
    overriddenAction: string;
    timestamp: Date;
    severity: 'high' | 'critical';
    resolved: boolean;
    trustImpact: number;
}
export declare class ProgressiveAutonomySystem extends EventEmitter {
    private config;
    private consciousness;
    private autonomyPath;
    private currentTrustLevel;
    private trustMetrics;
    private trustHistory;
    private pendingApprovals;
    private approvalHistory;
    private emergencyOverrides;
    private emergencyMode;
    private readonly TRUST_LEVELS;
    constructor();
    /**
     * Initialize the progressive autonomy system
     */
    private initializeAutonomySystem;
    /**
     * Start monitoring trust metrics
     */
    private startTrustMonitoring;
    /**
     * Request approval for an action
     */
    requestApproval(request: Omit<ApprovalRequest, 'id' | 'requestedAt' | 'currentTrustLevel'>): Promise<string>;
    /**
     * Process approval response
     */
    processApprovalResponse(response: ApprovalResponse): Promise<void>;
    /**
     * Trigger emergency override
     */
    triggerEmergencyOverride(override: Omit<EmergencyOverride, 'id' | 'timestamp' | 'resolved'>): Promise<void>;
    /**
     * Check if action can be performed autonomously
     */
    private canActAutonomously;
    /**
     * Update trust metrics from various sources
     */
    private updateTrustMetrics;
    /**
     * Evaluate if trust level should progress
     */
    private evaluateTrustLevelProgression;
    /**
     * Evaluate if trust requirements are met
     */
    private evaluateTrustRequirements;
    /**
     * Progress to next trust level
     */
    private progressToTrustLevel;
    /**
     * Get recent evolution results for trust calculation
     */
    private getRecentEvolutions;
    /**
     * Update trust based on approval response
     */
    private updateTrustFromApproval;
    /**
     * Persist trust state to storage
     */
    private persistTrustState;
    /**
     * Load trust state from storage
     */
    private loadTrustState;
    /**
     * Persist approval request
     */
    private persistApprovalRequest;
    /**
     * Persist approval response
     */
    private persistApprovalResponse;
    /**
     * Persist emergency override
     */
    private persistEmergencyOverride;
    /**
     * Get current autonomy status
     */
    getAutonomyStatus(): any;
    /**
     * Get pending approvals for steward attention
     */
    getPendingApprovals(): ApprovalRequest[];
}
export default ProgressiveAutonomySystem;
//# sourceMappingURL=ProgressiveAutonomySystem.d.ts.map