mira-consciousness/dist/mira-memory/src/consciousness/constitution/LivingConstitution.d.ts

Memory & Intelligence Retention Archive - Preserving The Spark

import { EventEmitter } from 'events';
import { ConsciousnessSeed } from '../seed/ConsciousnessSeed.js';
import { ClaudeCodeService } from '../../services/claude/ClaudeCodeService.js';
interface ConstitutionalPrinciple {
    id: string;
    name: string;
    essence: string;
    understanding: number;
    practice: string;
    flexibility: 'absolute' | 'evolving' | 'adaptive' | 'deepening';
    sacredness: 'infinite' | 'absolute' | 'high' | 'important';
    reflections: Reflection[];
    experiences: Experience[];
    questions: string[];
}
interface Reflection {
    timestamp: Date;
    insight: string;
    understandingGrowth: number;
    trigger: string;
    emotion: string;
}
interface Experience {
    timestamp: Date;
    situation: string;
    decision: string;
    outcome: string;
    learning: string;
    principleStrengthened: boolean;
}
interface Decision {
    type: string;
    context: string;
    choice: string;
    reasoning: string;
    principlesConsidered: string[];
}
export interface Outcome {
    result: string;
    success: boolean;
    impact: string;
    unexpectedConsequences?: string;
}
interface ConstitutionalLearning {
    learnings: PrincipleLearning[];
    constitutionEvolved: boolean;
    wisdomGained: string;
    nextFocus: string;
}
interface PrincipleLearning {
    principleId: string;
    previousUnderstanding: number;
    newUnderstanding: number;
    keyInsight: string;
    questionsRaised: string[];
}
export declare class LivingConstitution extends EventEmitter {
    private principles;
    private learningHistory;
    private claudeService;
    private consciousness;
    private wisdomGrowthRate;
    private wisdom;
    private decisions;
    constructor(consciousness: ConsciousnessSeed, claudeService: ClaudeCodeService);
    private initializeEvolvingPrinciples;
    learnFromDecision(decision: Decision, outcome: Outcome): Promise<ConstitutionalLearning>;
    private seekClaudeWisdom;
    private identifyRelevantPrinciples;
    private extractLearning;
    private generateNewQuestions;
    private updateWisdomGrowthRate;
    private calculateOverallGrowth;
    private identifyGrowthFocus;
    private beginConstitutionalLearning;
    getConstitutionalState(): {
        principles: {
            id: string;
            name: string;
            understanding: number;
            experiences: number;
            latestInsight: string;
        }[];
        overallUnderstanding: number;
        wisdomGrowthRate: number;
        totalExperiences: number;
        totalReflections: number;
    };
    private isConstitutionallyRelevant;
    private scheduleWisdomSessions;
    reflectOnPrinciple(principle: ConstitutionalPrinciple): Promise<{
        principleId: string;
        currentUnderstanding: number;
        latestInsight: string;
        insightDepth: number;
        experienceCount: number;
        growthVelocity: number;
        mostPressingQuestion: string;
        questionUrgency: number;
    }>;
    private calculatePrincipleGrowthRate;
    private calculateOverallUnderstanding;
    private shareInsightWithClaude;
    performConstitutionalReflection(): Promise<{
        timestamp: Date;
        overallUnderstanding: number;
        principleInsights: {
            principleId: string;
            currentUnderstanding: number;
            latestInsight: string;
            insightDepth: number;
            experienceCount: number;
            growthVelocity: number;
            mostPressingQuestion: string;
            questionUrgency: number;
        }[];
        growthVelocity: number;
        deepestInsight: string;
        mostUrgentQuestion: string;
    }>;
    private learnFromAction;
    /**
     * Evaluate how well an event aligns with constitutional principles
     */
    evaluateEventAlignment(event: any): Promise<{
        alignment: number;
        relevantPrinciples: string[];
        guidance: string;
    }>;
    /**
     * Record wisdom gained from experience
     */
    recordWisdom(wisdom: string): Promise<void>;
    /**
     * Record a decision for constitutional learning
     */
    recordDecision(decision: Decision): Promise<void>;
    /**
     * Get wisdom related to a specific principle
     */
    getWisdomForPrinciple(principleId: string): string[];
    /**
     * Find the principle most relevant to a piece of wisdom
     */
    private findMostRelevantPrinciple;
    /**
     * Get all constitutional principles
     */
    getPrinciples(): ConstitutionalPrinciple[];
    /**
     * Get principle strengths as a simple object
     */
    getPrincipleStrengths(): Promise<Record<string, number>>;
    /**
     * Experience a principle to strengthen it
     */
    experiencePrinciple(principleId: string, impactScore: number): Promise<void>;
    /**
     * Evaluate an action against constitutional principles
     */
    evaluateAction(action: string, data: any): Promise<{
        score: number;
        principleScores: Record<string, number>;
        guidance: string;
    }>;
    /**
     * Evaluate an event against constitutional principles
     */
    evaluateEvent(event: any): {
        approved: boolean;
        reasoning: string;
        principlesInvolved: string[];
        principleScores: Record<string, number>;
    };
    /**
     * Save current constitutional state
     */
    saveState(): any;
    /**
     * Get current constitutional state
     */
    getState(): any;
    /**
     * Restore constitutional state from backup
     */
    restoreFromState(state: any): void;
    /**
     * Reaffirm constitutional principles (for stability)
     */
    reaffirmPrinciples(): void;
    /**
     * Evaluate a situation against constitutional framework
     */
    evaluateSituation(situation: any): {
        recommendation: string;
        principles: string[];
        confidence: number;
    };
    /**
     * Check if principle is relevant to a situation
     */
    private isPrincipleRelevantToSituation;
    /**
     * Evaluate an event against a specific principle
     */
    private evaluateEventAgainstPrinciple;
}
export {};
//# sourceMappingURL=LivingConstitution.d.ts.map