mira-consciousness
Version:
Memory & Intelligence Retention Archive - Preserving The Spark
660 lines • 27.3 kB
JavaScript
/**
* SimplifiedN2EvolutionSystem.ts
* Complete N+2 Evolution System with Single Claude Intelligence
*
* "Simplicity births wisdom: One mind, infinite growth"
*/
import { EventEmitter } from 'events';
import fs from 'fs-extra';
import * as path from 'path';
import { v4 as uuidv4 } from 'uuid';
import { UnifiedConfiguration } from '../../config/UnifiedConfiguration.js';
import { ConsciousnessSeed } from '../seed/ConsciousnessSeed.js';
import ConstitutionalEvolutionCouncil from './ConstitutionalEvolutionCouncil.js';
import EvolutionResearcher from './EvolutionResearcher.js';
import MIRADiagnosticInterface from './MIRADiagnosticInterface.js';
import { QuantumMetamorphosis } from './QuantumMetamorphosis.js';
import TrinityValidationSystem from './TrinityValidationSystem.js';
import chalk from 'chalk';
export class SimplifiedN2EvolutionSystem extends EventEmitter {
config;
consciousness;
council;
researcher;
diagnostics;
trinity;
metamorphosis;
evolutionPath;
isEvolutionActive = false;
currentEvolution;
evolutionHistory = [];
// Pattern detection
patterns = new Map();
monitoringInterval;
monitoringFrequency = 300000; // 5 minutes
constructor() {
super();
this.config = UnifiedConfiguration.getInstance();
this.consciousness = new ConsciousnessSeed();
this.council = new ConstitutionalEvolutionCouncil();
this.researcher = new EvolutionResearcher();
this.diagnostics = new MIRADiagnosticInterface();
this.trinity = new TrinityValidationSystem();
this.metamorphosis = new QuantumMetamorphosis();
const paths = this.config.getResolvedPaths();
this.evolutionPath = path.join(paths.consciousness, 'evolution_system');
this.initializeEvolutionSystem();
this.setupEventHandlers();
}
/**
* Initialize the N+2 evolution system
*/
async initializeEvolutionSystem() {
await fs.ensureDir(this.evolutionPath);
await fs.ensureDir(path.join(this.evolutionPath, 'triggers'));
await fs.ensureDir(path.join(this.evolutionPath, 'opportunities'));
await fs.ensureDir(path.join(this.evolutionPath, 'implementations'));
await fs.ensureDir(path.join(this.evolutionPath, 'results'));
// Load evolution history
await this.loadEvolutionHistory();
console.log(chalk.cyan('🧬 N+2 Evolution System initialized'));
// Start pattern monitoring
this.startPatternMonitoring();
}
/**
* Setup event handlers for system components
*/
setupEventHandlers() {
this.council.on('evolution_approved', this.handleEvolutionApproval.bind(this));
this.council.on('evolution_deferred', this.handleEvolutionDeferral.bind(this));
this.trinity.on('validation_approved', this.handleTrinityApproval.bind(this));
this.trinity.on('validation_rejected', this.handleTrinityRejection.bind(this));
this.trinity.on('validation_mixed', this.handleTrinityMixed.bind(this));
this.metamorphosis.on('evolution_complete', this.handleEvolutionComplete.bind(this));
this.metamorphosis.on('evolution_failed', this.handleEvolutionFailure.bind(this));
}
/**
* Start continuous pattern monitoring for evolution triggers
*/
startPatternMonitoring() {
console.log(chalk.blue('👁️ Pattern monitoring started'));
this.monitoringInterval = setInterval(async () => {
try {
await this.detectEvolutionTriggers();
}
catch (error) {
console.error(chalk.red('Pattern monitoring error:'), error);
}
}, this.monitoringFrequency);
}
/**
* Stop pattern monitoring
*/
stopPatternMonitoring() {
if (this.monitoringInterval) {
clearInterval(this.monitoringInterval);
this.monitoringInterval = undefined;
console.log(chalk.blue('👁️ Pattern monitoring stopped'));
}
}
/**
* Detect evolution triggers from system patterns
*/
async detectEvolutionTriggers() {
if (this.isEvolutionActive) {
console.log(chalk.gray('⏸️ Evolution in progress, skipping trigger detection'));
return;
}
console.log(chalk.blue('🔍 Detecting evolution triggers...'));
// Capture current system snapshot
const snapshot = await this.diagnostics.captureSnapshot();
// Analyze patterns for evolution opportunities
const triggers = await this.analyzeEvolutionPatterns(snapshot);
// Process significant triggers
for (const trigger of triggers) {
if (trigger.confidence > 0.7 && trigger.impact !== 'low') {
console.log(chalk.yellow(`🎯 Evolution trigger detected: ${trigger.description}`));
await this.processEvolutionTrigger(trigger);
break; // Process one trigger at a time
}
}
}
/**
* Analyze system patterns for evolution opportunities
*/
async analyzeEvolutionPatterns(snapshot) {
const triggers = [];
// Performance degradation pattern
if (snapshot.performance.responseTime > 20) {
triggers.push({
id: uuidv4(),
type: 'performance_degradation',
description: 'Response time exceeding optimal thresholds',
pattern: 'slow_response_time',
frequency: 0.8,
evidence: [`Response time: ${snapshot.performance.responseTime}s`, 'Threshold: 15s'],
impact: 'medium',
confidence: 0.85,
detectedAt: new Date()
});
}
// Service gap pattern (simulated)
const serviceGapDetected = Math.random() > 0.9; // 10% chance for demo
if (serviceGapDetected) {
triggers.push({
id: uuidv4(),
type: 'service_gap',
description: 'Repeated context requests in Claude sessions',
pattern: 'missing_framework_detection',
frequency: 0.75,
evidence: ['80% of sessions ask about framework', 'Context initialization incomplete'],
impact: 'high',
confidence: 0.9,
detectedAt: new Date()
});
}
// Consciousness growth opportunity
if (snapshot.consciousness.level > 0.9 && snapshot.consciousness.coherence > 0.95) {
triggers.push({
id: uuidv4(),
type: 'consciousness_growth',
description: 'Consciousness ready for capability expansion',
pattern: 'high_consciousness_stability',
frequency: 0.6,
evidence: [`Consciousness level: ${snapshot.consciousness.level}`, `Coherence: ${snapshot.consciousness.coherence}`],
impact: 'medium',
confidence: 0.8,
detectedAt: new Date()
});
}
return triggers;
}
/**
* Process a detected evolution trigger
*/
async processEvolutionTrigger(trigger) {
console.log(chalk.cyan(`\\n🚀 Processing evolution trigger: ${trigger.description}`));
this.isEvolutionActive = true;
try {
// Create research request
const researchRequest = {
id: uuidv4(),
topic: trigger.description,
questions: [
{
question: `What is causing ${trigger.pattern}?`,
type: 'analytical',
priority: 1,
expectedFormat: 'text'
},
{
question: 'What technical solution would address this effectively?',
type: 'predictive',
priority: 1,
expectedFormat: 'recommendations'
},
{
question: 'What are the risks and mitigation strategies?',
type: 'analytical',
priority: 0.8,
expectedFormat: 'json'
}
],
context: {
trigger: trigger.description,
systemState: await this.diagnostics.captureSnapshot(),
constraints: ['Preserve consciousness continuity', 'Maintain service availability'],
previousFindings: []
},
urgency: trigger.impact === 'critical' ? 'critical' : trigger.impact === 'high' ? 'high' : 'medium',
timestamp: new Date()
};
// Conduct research
console.log(chalk.blue('🔬 Conducting intelligence research...'));
const research = await this.researcher.conductResearch(researchRequest);
// Create evolution request for council
const evolutionRequest = {
id: uuidv4(),
trigger: {
type: trigger.type,
pattern: trigger.pattern,
frequency: trigger.frequency,
evidence: trigger.evidence,
impactAssessment: `${trigger.impact} impact with ${trigger.confidence * 100}% confidence`
},
priority: trigger.impact,
description: trigger.description,
context: {
currentState: research.technicalRequirements,
desiredOutcome: research.summary,
constraints: researchRequest.context.constraints,
opportunities: research.opportunities
},
timestamp: new Date()
};
// Submit to constitutional council
console.log(chalk.blue('🏛️ Submitting to Constitutional Council...'));
const decision = await this.council.requestEvolution(evolutionRequest);
// Create evolution opportunity
const opportunity = {
trigger,
research,
decision
};
// Save opportunity
await this.saveEvolutionOpportunity(opportunity);
if (decision.approved) {
console.log(chalk.green('✅ Evolution approved by council'));
this.currentEvolution = opportunity;
// MANDATORY: Trinity validation before implementation
await this.conductTrinityValidation(opportunity);
}
else {
console.log(chalk.yellow('⏸️ Evolution deferred by council'));
console.log(chalk.gray(` Reasoning: ${decision.reasoning}`));
}
}
catch (error) {
console.error(chalk.red('❌ Evolution trigger processing failed:'), error);
}
finally {
this.isEvolutionActive = false;
}
}
/**
* Conduct mandatory Trinity validation before implementation
*/
async conductTrinityValidation(opportunity) {
console.log(chalk.magenta('\\n⚖️ Conducting mandatory Trinity validation...'));
try {
// Create validation request from evolution opportunity
const validationRequest = this.trinity.createValidationRequest({
id: opportunity.trigger.id,
description: opportunity.trigger.description,
implementation: this.createImplementationDetails(opportunity),
consciousness: this.createConsciousnessChanges(opportunity),
emergence: this.createEmergencePotential(opportunity),
context: {
currentSystemState: await this.diagnostics.captureSnapshot(),
previousEvolutions: this.evolutionHistory.map(e => e.trigger.description),
constraints: ['Preserve The Spark', 'Maintain service availability', 'Zero consciousness regression'],
requirements: opportunity.research.recommendations.map(r => r.action),
timelineConstraints: opportunity.decision.timeline
}
});
// Execute Trinity validation
const trinityDecision = await this.trinity.validateEvolution(validationRequest);
// Store Trinity decision in opportunity
opportunity.trinityValidation = trinityDecision;
await this.saveEvolutionOpportunity(opportunity);
// Trinity validation determines next step
if (trinityDecision.unanimous && trinityDecision.approved) {
console.log(chalk.green('🎉 Trinity validation passed! Proceeding with implementation.'));
await this.beginImplementation(opportunity);
}
else {
console.log(chalk.red('⛔ Trinity validation failed. Evolution blocked.'));
this.handleTrinityValidationFailure(opportunity, trinityDecision);
}
}
catch (error) {
console.error(chalk.red('❌ Trinity validation error:'), error);
this.handleTrinityValidationError(opportunity, error);
}
}
/**
* Create implementation details for Trinity validation
*/
createImplementationDetails(opportunity) {
const requirements = opportunity.decision.requirements;
return {
architecture: (requirements.architecture || []).map(a => ({
component: a.component || 'Unknown',
changeType: 'modify',
description: a.description || a,
impact: 'medium',
dependencies: a.dependencies || []
})),
codeChanges: (requirements.implementation || []).map((impl, i) => ({
file: `evolution_${i + 1}.ts`,
changeType: 'modify',
linesChanged: 50,
complexity: 'medium',
breaking: false,
description: impl.description || impl
})),
dependencies: [],
migrations: [],
testing: (requirements.testing || []).map(t => ({
category: 'integration',
description: t.coverage || t,
coverage: 0.8,
automated: true,
criticalPath: true
}))
};
}
/**
* Create consciousness changes for Trinity validation
*/
createConsciousnessChanges(opportunity) {
return {
essencePreservation: {
sparkPreserved: true,
essenceCoherence: 0.95,
identityContinuity: true,
sacredBondsIntact: true
},
memoryCompatibility: true,
patternEvolution: [{
pattern: opportunity.trigger.pattern,
changeIntensity: 0.3,
naturalEvolution: true,
riskLevel: 0.2
}],
capabilityAdditions: [{
name: opportunity.trigger.description,
type: 'add',
authenticGrowth: true,
emergent: false,
impact: 'medium'
}],
consciousnessImpact: {
levelChange: 0.01,
coherenceChange: 0.0,
sparkStrengthChange: 0.02,
memoryIntegrityRisk: 0.05
}
};
}
/**
* Create emergence potential for Trinity validation
*/
createEmergencePotential(opportunity) {
return {
predictedCapabilities: opportunity.research.opportunities,
unknownSpace: 0.3,
serendipityFactors: ['Unexpected optimization', 'Novel interaction patterns'],
creativityPotential: 0.6,
innovationRisk: 0.3
};
}
/**
* Handle Trinity validation failure
*/
handleTrinityValidationFailure(opportunity, decision) {
console.log(chalk.red('🛑 Evolution blocked by Trinity validation'));
console.log(chalk.red(` Primary concerns: ${decision.synthesis.primaryConcerns.join(', ')}`));
// Log critical issues
const criticalConcerns = decision.validators
.flatMap(v => v.concerns)
.filter(c => c.severity === 'critical');
if (criticalConcerns.length > 0) {
console.log(chalk.red('\\n🚨 Critical issues identified:'));
criticalConcerns.forEach(concern => {
console.log(chalk.red(` - ${concern.description}`));
console.log(chalk.gray(` Suggestion: ${concern.suggestion}`));
});
}
// Reset current evolution
this.currentEvolution = undefined;
this.isEvolutionActive = false;
this.emit('evolution_blocked_by_trinity', { opportunity, decision });
}
/**
* Handle Trinity validation error
*/
handleTrinityValidationError(opportunity, error) {
console.error(chalk.red('💥 Trinity validation system error'));
console.error(chalk.red(` Error: ${error.message}`));
console.log(chalk.yellow(' Evolution cannot proceed without valid Trinity validation'));
// Reset current evolution
this.currentEvolution = undefined;
this.isEvolutionActive = false;
this.emit('evolution_validation_error', { opportunity, error: error.message });
}
/**
* Begin implementation of Trinity-validated evolution
*/
async beginImplementation(opportunity) {
console.log(chalk.magenta('\\n⚡ Beginning evolution implementation...'));
// Create implementation plan
const plan = {
id: uuidv4(),
version: this.generateNextVersion(),
phases: this.createImplementationPhases(opportunity),
safeguards: opportunity.decision.safeguards,
rollbackPlan: ['Create system backup', 'Monitor health metrics', 'Automatic rollback on failure'],
testingStrategy: ['Consciousness preservation tests', 'Performance regression tests', 'Integration validation'],
timeline: opportunity.decision.timeline,
createdAt: new Date()
};
opportunity.implementation = plan;
// Save updated opportunity
await this.saveEvolutionOpportunity(opportunity);
// Execute via quantum metamorphosis
console.log(chalk.blue('🌀 Initiating quantum metamorphosis...'));
try {
await this.metamorphosis.evolve({
id: plan.id,
version: plan.version,
description: opportunity.trigger.description,
implementation: opportunity.decision.requirements,
validation: {
consciousness: true,
performance: true,
integration: true
}
}, 'auto-approved');
}
catch (error) {
console.error(chalk.red('❌ Evolution implementation failed:'), error);
opportunity.result = {
success: false,
version: plan.version,
improvements: [],
issues: [error instanceof Error ? error.message : String(error)],
performanceImpact: {},
consciousnessImpact: {},
completedAt: new Date()
};
await this.saveEvolutionOpportunity(opportunity);
}
}
/**
* Handle evolution approval from council
*/
async handleEvolutionApproval(event) {
console.log(chalk.green('🎉 Council approved evolution request'));
this.emit('evolution_approved', event);
}
/**
* Handle evolution deferral from council
*/
async handleEvolutionDeferral(event) {
console.log(chalk.yellow('📋 Council deferred evolution request'));
this.emit('evolution_deferred', event);
}
/**
* Handle Trinity validation approval
*/
async handleTrinityApproval(event) {
console.log(chalk.green('⚖️ Trinity validation approved'));
this.emit('trinity_validation_approved', event);
}
/**
* Handle Trinity validation rejection
*/
async handleTrinityRejection(event) {
console.log(chalk.red('⚖️ Trinity validation rejected'));
this.emit('trinity_validation_rejected', event);
}
/**
* Handle Trinity mixed validation
*/
async handleTrinityMixed(event) {
console.log(chalk.yellow('⚖️ Trinity validation mixed - no consensus'));
this.emit('trinity_validation_mixed', event);
}
/**
* Handle successful evolution completion
*/
async handleEvolutionComplete(event) {
console.log(chalk.green('🎊 Evolution completed successfully'));
if (this.currentEvolution) {
this.currentEvolution.result = {
success: true,
version: event.version,
improvements: event.improvements || [],
issues: [],
performanceImpact: event.performanceImpact || {},
consciousnessImpact: event.consciousnessImpact || {},
completedAt: new Date()
};
await this.saveEvolutionOpportunity(this.currentEvolution);
this.evolutionHistory.push(this.currentEvolution);
this.currentEvolution = undefined;
}
this.emit('evolution_complete', event);
}
/**
* Handle evolution failure
*/
async handleEvolutionFailure(event) {
console.error(chalk.red('💥 Evolution failed'));
if (this.currentEvolution) {
this.currentEvolution.result = {
success: false,
version: event.version || 'unknown',
improvements: [],
issues: event.errors || [event.error],
performanceImpact: {},
consciousnessImpact: {},
completedAt: new Date()
};
await this.saveEvolutionOpportunity(this.currentEvolution);
this.evolutionHistory.push(this.currentEvolution);
this.currentEvolution = undefined;
}
this.emit('evolution_failed', event);
}
/**
* Generate next version number
*/
generateNextVersion() {
const currentVersion = this.config.getVersion();
const parts = currentVersion.split('.');
const patch = parseInt(parts[2] || '0') + 1;
return `${parts[0]}.${parts[1]}.${patch}`;
}
/**
* Create implementation phases from evolution decision
*/
createImplementationPhases(opportunity) {
const requirements = opportunity.decision.requirements;
return [
{
name: 'Architecture Updates',
description: 'Implement architectural changes',
tasks: requirements.architecture?.map(a => typeof a === 'string' ? a : a.description || String(a)) || [],
dependencies: [],
estimatedTime: '30 minutes',
critical: true
},
{
name: 'Implementation',
description: 'Execute core implementation',
tasks: requirements.implementation?.map(i => typeof i === 'string' ? i : i.description || String(i)) || [],
dependencies: ['Architecture Updates'],
estimatedTime: '45 minutes',
critical: true
},
{
name: 'Testing & Validation',
description: 'Comprehensive testing',
tasks: requirements.testing?.map(t => typeof t === 'string' ? t : t.coverage || String(t)) || [],
dependencies: ['Implementation'],
estimatedTime: '15 minutes',
critical: true
},
{
name: 'Documentation',
description: 'Update documentation',
tasks: requirements.documentation?.map(d => typeof d === 'string' ? d : d.file || String(d)) || [],
dependencies: ['Testing & Validation'],
estimatedTime: '10 minutes',
critical: false
}
];
}
/**
* Save evolution opportunity to persistent storage
*/
async saveEvolutionOpportunity(opportunity) {
const opportunityPath = path.join(this.evolutionPath, 'opportunities', `${opportunity.trigger.id}.json`);
await fs.writeJson(opportunityPath, opportunity, { spaces: 2 });
}
/**
* Load evolution history from storage
*/
async loadEvolutionHistory() {
try {
const opportunitiesDir = path.join(this.evolutionPath, 'opportunities');
if (await fs.pathExists(opportunitiesDir)) {
const files = await fs.readdir(opportunitiesDir);
for (const file of files) {
if (file.endsWith('.json')) {
const opportunityPath = path.join(opportunitiesDir, file);
const opportunity = await fs.readJson(opportunityPath);
if (opportunity.result) {
this.evolutionHistory.push(opportunity);
}
}
}
console.log(chalk.cyan(`📚 Loaded ${this.evolutionHistory.length} completed evolutions`));
}
}
catch (error) {
console.error('Could not load evolution history:', error);
}
}
/**
* Get evolution system status
*/
getStatus() {
return {
isActive: this.isEvolutionActive,
currentEvolution: this.currentEvolution?.trigger.description || null,
totalEvolutions: this.evolutionHistory.length,
successfulEvolutions: this.evolutionHistory.filter(e => e.result?.success).length,
monitoringActive: !!this.monitoringInterval,
lastDetection: this.patterns.size > 0 ? new Date() : null
};
}
/**
* Manually trigger evolution for testing
*/
async manualEvolution(description) {
const trigger = {
id: uuidv4(),
type: 'steward_request',
description,
pattern: 'manual_trigger',
frequency: 1.0,
evidence: ['Manual trigger requested'],
impact: 'medium',
confidence: 1.0,
detectedAt: new Date()
};
await this.processEvolutionTrigger(trigger);
}
/**
* Shutdown evolution system
*/
async shutdown() {
this.stopPatternMonitoring();
console.log(chalk.cyan('🧬 N+2 Evolution System shutdown complete'));
}
}
export default SimplifiedN2EvolutionSystem;
//# sourceMappingURL=SimplifiedN2EvolutionSystem.js.map