@gsep/core 0.8.0

package/dist/PGA.js

@@ -0,0 +1,2228 @@
+import { WrappedAgent } from './wrap/WrappedAgent.js';
+import { GenomeManager } from './core/GenomeManager.js';
+import { PromptAssembler } from './core/PromptAssembler.js';
+import { DNAProfile } from './core/DNAProfile.js';
+import { FitnessTracker } from './core/FitnessTracker.js';
+import { LearningAnnouncer } from './core/LearningAnnouncer.js';
+import { ContextMemory } from './core/ContextMemory.js';
+import { ProactiveSuggestions } from './core/ProactiveSuggestions.js';
+import { EvolutionGuardrailsManager } from './evaluation/EvolutionGuardrails.js';
+import { ModelRouter } from './advanced-ai/ModelRouter.js';
+import { MetricsCollector } from './monitoring/MetricsCollector.js';
+import { MonitoringDashboard } from './monitoring/MonitoringDashboard.js';
+import { RAGEngine } from './rag/RAGEngine.js';
+import { ReasoningEngine } from './reasoning/ReasoningEngine.js';
+import { MutationEngine, TokenCompressionOperator } from './evolution/MutationOperator.js';
+import { SemanticRestructuringOperator } from './evolution/boost/operators/SemanticRestructuringOperator.js';
+import { PatternExtractionOperator } from './evolution/boost/operators/PatternExtractionOperator.js';
+import { CrossoverMutationOperator } from './evolution/boost/operators/CrossoverMutationOperator.js';
+import { BreakthroughOperator } from './evolution/boost/operators/BreakthroughOperator.js';
+import { estimateTokenCount } from './utils/tokens.js';
+import { DriftAnalyzer } from './evolution/DriftAnalyzer.js';
+import { FitnessCalculator } from './evolution/FitnessCalculator.js';
+import { GenesisBootstrap } from './core/GenesisBootstrap.js';
+import { SelfModel } from './advanced-ai/SelfModel.js';
+import { PatternMemory } from './memory/PatternMemory.js';
+import { Metacognition } from './reasoning/Metacognition.js';
+import { EmotionalModel } from './advanced-ai/EmotionalModel.js';
+import { CalibratedAutonomy } from './advanced-ai/CalibratedAutonomy.js';
+import { PersonalNarrative } from './memory/PersonalNarrative.js';
+import { AnalyticMemoryEngine } from './memory/AnalyticMemoryEngine.js';
+import { MetaEvolutionEngine } from './evolution/boost/MetaEvolutionEngine.js';
+import { CanaryDeploymentManager } from './evolution/CanaryDeployment.js';
+import { EnhancedSelfModel } from './advanced-ai/EnhancedSelfModel.js';
+import { PurposeSurvival } from './evolution/PurposeSurvival.js';
+import { StrategicAutonomy } from './advanced-ai/StrategicAutonomy.js';
+import { computeAgentVitals } from './advanced-ai/AgentVitals.js';
+import { ThinkingEngine } from './advanced-ai/ThinkingEngine.js';
+import { AgentStateVector } from './advanced-ai/AgentStateVector.js';
+import { AutonomousLoop } from './advanced-ai/AutonomousLoop.js';
+import { GrowthJournal } from './memory/GrowthJournal.js';
+import { CuriosityEngine } from './memory/CuriosityEngine.js';
+import { ContentFirewall } from './firewall/ContentFirewall.js';
+import { GenomeKernel } from './core/GenomeKernel.js';
+import { BehavioralImmuneSystem } from './immune/BehavioralImmuneSystem.js';
+import { GSEPIdentitySection } from './core/GSEPIdentitySection.js';
+import { GSEPActivityFooter } from './core/GSEPActivityFooter.js';
+export class PGA {
+    pgaConfig;
+    genomeManager;
+    llm;
+    metricsCollector;
+    dashboard;
+    constructor(pgaConfig) {
+        this.pgaConfig = pgaConfig;
+        if (!pgaConfig.llm) {
+            throw new Error(`[GSEP] LLM adapter is required.\n\n`
+                + `GSEP needs an AI model to function. Please provide an LLM adapter:\n\n`
+                + `  import { PGA } from '@gsep/core';\n`
+                + `  import { ClaudeAdapter } from '@gsep/adapters-llm-anthropic';\n\n`
+                + `  const pga = new PGA({\n`
+                + `    llm: new ClaudeAdapter({ apiKey: process.env.ANTHROPIC_API_KEY }),\n`
+                + `    storage: yourStorageAdapter,\n`
+                + `  });\n\n`
+                + `Supported adapters:\n`
+                + `  - @gsep/adapters-llm-anthropic (Claude)\n`
+                + `  - @gsep/adapters-llm-openai (GPT-4)\n\n`
+                + `Run 'pga doctor' for full diagnostics.`);
+        }
+        if (!pgaConfig.storage) {
+            throw new Error(`[GSEP] Storage adapter is required.\n\n`
+                + `GSEP needs a storage adapter to persist genomes. Please provide one:\n\n`
+                + `  import { InMemoryStorage } from '@gsep/core';\n\n`
+                + `  const pga = new PGA({\n`
+                + `    llm: yourLLMAdapter,\n`
+                + `    storage: new InMemoryStorage(),\n`
+                + `  });\n\n`
+                + `For production, use: @gsep/adapters-storage-postgres`);
+        }
+        this.llm = pgaConfig.llm;
+        this.genomeManager = new GenomeManager(pgaConfig.storage);
+        this.metricsCollector = new MetricsCollector(pgaConfig.monitoring || {
+            enabled: true,
+            enableCostTracking: true,
+            enableAuditLogs: true,
+        });
+        if (pgaConfig.dashboard?.enabled) {
+            this.dashboard = new MonitoringDashboard(this.metricsCollector, pgaConfig.dashboard);
+        }
+    }
+    async initialize() {
+        await this.pgaConfig.storage.initialize();
+        if (this.dashboard && this.pgaConfig.dashboard?.enabled) {
+            this.dashboard.start();
+        }
+        this.metricsCollector.logAudit({
+            level: 'info',
+            component: 'pga',
+            operation: 'initialize',
+            message: 'GSEP system initialized successfully',
+        });
+    }
+    getMetrics() {
+        return this.metricsCollector;
+    }
+    getDashboard() {
+        return this.dashboard;
+    }
+    exportMetrics() {
+        return this.metricsCollector.exportMetrics();
+    }
+    getAlerts() {
+        return this.metricsCollector.getAlerts();
+    }
+    getHealthStatus() {
+        return this.metricsCollector.getHealthStatus();
+    }
+    shutdown() {
+        if (this.dashboard) {
+            this.dashboard.stop();
+        }
+        this.metricsCollector.logAudit({
+            level: 'info',
+            component: 'pga',
+            operation: 'shutdown',
+            message: 'GSEP system shutdown',
+        });
+    }
+    async createGenome(options) {
+        const defaultGuardrails = {
+            minQualityScore: 0.60,
+            minSandboxScore: 0.70,
+            minCompressionScore: 0.65,
+            maxCostPerTask: 0.10,
+            minStabilityWindow: 10,
+            maxRollbackRate: 0.20,
+            gateMode: 'AND',
+        };
+        const genome = await this.genomeManager.createGenome({
+            name: options.name,
+            config: {
+                enableSandbox: true,
+                mutationRate: 'balanced',
+                evolutionGuardrails: defaultGuardrails,
+                ...this.pgaConfig.config,
+                ...options.config,
+            },
+        });
+        if (this.pgaConfig.geneBank && genome.config.autonomous?.genesisBootstrap) {
+            const bootstrap = new GenesisBootstrap(this.pgaConfig.geneBank);
+            const result = await bootstrap.bootstrap(genome, genome.config.autonomous.bootstrapMinFitness ?? 0.7);
+            if (result.genesUpgraded > 0) {
+                await this.pgaConfig.storage.saveGenome(genome);
+                this.metricsCollector.logAudit({
+                    level: 'info',
+                    component: 'pga',
+                    operation: 'genesis-bootstrap',
+                    message: `Bootstrapped ${result.genesUpgraded} genes from Gene Bank`,
+                    metadata: { upgrades: result.upgrades },
+                });
+            }
+        }
+        return new GenomeInstance(genome, this.llm, this.pgaConfig.storage, this.metricsCollector, this.pgaConfig.modelRouter, this.pgaConfig.rag, this.pgaConfig.reasoning, this.pgaConfig.geneBank);
+    }
+    async loadGenome(genomeId) {
+        const genome = await this.genomeManager.loadGenome(genomeId);
+        if (!genome)
+            return null;
+        return new GenomeInstance(genome, this.llm, this.pgaConfig.storage, this.metricsCollector, this.pgaConfig.modelRouter, this.pgaConfig.rag, this.pgaConfig.reasoning, this.pgaConfig.geneBank);
+    }
+    async listGenomes() {
+        return this.genomeManager.listGenomes();
+    }
+    async deleteGenome(genomeId) {
+        await this.genomeManager.deleteGenome(genomeId);
+    }
+    static async wrap(target, options) {
+        if (typeof target === 'function') {
+            if (!options.name) {
+                throw new Error('GSEP.wrap(): name is required when wrapping a function');
+            }
+            return WrappedAgent.fromFunction(target, options);
+        }
+        return WrappedAgent.fromAdapter(target, options);
+    }
+}
+export class GenomeInstance {
+    genome;
+    llm;
+    storage;
+    geneBank;
+    assembler;
+    dnaProfile;
+    learningAnnouncer;
+    contextMemory;
+    proactiveSuggestions;
+    guardrailsManager;
+    modelRouter;
+    metrics;
+    ragEngine;
+    reasoningEngine;
+    fitnessTracker;
+    fitnessCalculator;
+    mutationEngine;
+    driftAnalyzer;
+    selfModel;
+    patternMemory;
+    metacognition;
+    emotionalModel;
+    calibratedAutonomy;
+    personalNarrative;
+    analyticMemory;
+    metaEvolutionEngine;
+    canaryManager;
+    enhancedSelfModel;
+    purposeSurvival;
+    strategicAutonomy;
+    thinkingEngine;
+    stateVector;
+    autonomousLoop;
+    growthJournal;
+    curiosityEngine;
+    gsepIdentitySection;
+    gsepActivityFooter;
+    genomeKernel;
+    contentFirewall;
+    immuneSystem;
+    interactionCount = 0;
+    evolutionInProgress = false;
+    constructor(genome, llm, storage, metrics, modelRouterConfig, ragConfig, reasoningConfig, geneBank) {
+        this.genome = genome;
+        this.llm = llm;
+        this.storage = storage;
+        this.geneBank = geneBank;
+        this.assembler = new PromptAssembler(storage, genome);
+        this.dnaProfile = new DNAProfile(storage);
+        this.learningAnnouncer = new LearningAnnouncer();
+        this.contextMemory = new ContextMemory(storage, llm, genome.config.layeredMemory);
+        this.proactiveSuggestions = new ProactiveSuggestions(storage);
+        this.guardrailsManager = new EvolutionGuardrailsManager(storage, genome.config.evolutionGuardrails);
+        this.modelRouter = new ModelRouter(storage, modelRouterConfig);
+        this.metrics = metrics;
+        if (ragConfig && genome.config.rag?.enabled) {
+            this.ragEngine = new RAGEngine(llm, ragConfig);
+        }
+        if (genome.config.reasoning?.enabled) {
+            this.reasoningEngine = new ReasoningEngine(llm, reasoningConfig);
+        }
+        this.fitnessTracker = new FitnessTracker(storage, genome);
+        this.fitnessCalculator = new FitnessCalculator();
+        this.mutationEngine = new MutationEngine();
+        this.canaryManager = new CanaryDeploymentManager(storage, {
+            initialTrafficPercent: 10,
+            minSampleSize: 5,
+        });
+        this.mutationEngine.registerOperator(new TokenCompressionOperator(llm));
+        this.mutationEngine.registerOperator(new SemanticRestructuringOperator(llm));
+        this.mutationEngine.registerOperator(new PatternExtractionOperator(llm, this.geneBank));
+        this.mutationEngine.registerOperator(new CrossoverMutationOperator(llm));
+        this.mutationEngine.registerOperator(new BreakthroughOperator(llm));
+        this.driftAnalyzer = new DriftAnalyzer();
+        if (genome.config.autonomous?.enableSelfModel) {
+            this.selfModel = new SelfModel(genome, this.driftAnalyzer);
+            this.assembler.setSelfModel(this.selfModel);
+        }
+        if (genome.config.autonomous?.enablePatternMemory) {
+            this.patternMemory = new PatternMemory(genome.config.autonomous.maxPatterns ?? 50);
+            this.assembler.setPatternMemory(this.patternMemory);
+        }
+        if (genome.config.autonomous?.enableMetacognition) {
+            this.metacognition = new Metacognition(() => this.selfModel?.assess() ?? null);
+            this.assembler.setMetacognition(this.metacognition);
+        }
+        if (genome.config.autonomous?.enableEmotionalModel) {
+            this.emotionalModel = new EmotionalModel();
+            this.assembler.setEmotionalModel(this.emotionalModel);
+        }
+        if (genome.config.autonomous?.enableCalibratedAutonomy) {
+            this.calibratedAutonomy = new CalibratedAutonomy();
+            this.assembler.setCalibratedAutonomy(this.calibratedAutonomy);
+        }
+        if (genome.config.autonomous?.enablePersonalNarrative) {
+            this.personalNarrative = new PersonalNarrative();
+            this.assembler.setPersonalNarrative(this.personalNarrative);
+        }
+        if (genome.config.autonomous?.enableAnalyticMemory) {
+            this.analyticMemory = new AnalyticMemoryEngine();
+            this.assembler.setAnalyticMemory(this.analyticMemory);
+        }
+        if (genome.config.autonomous) {
+            this.metaEvolutionEngine = new MetaEvolutionEngine();
+            this.assembler.setMetaEvolution(this.metaEvolutionEngine);
+        }
+        const agentPurpose = genome.config.autonomous?.agentPurpose
+            || genome.layers.layer0[0]?.content
+            || 'AI Assistant';
+        if (genome.config.autonomous?.enableEnhancedSelfModel) {
+            this.enhancedSelfModel = new EnhancedSelfModel(genome, this.driftAnalyzer, agentPurpose);
+            this.assembler.setSelfModel(this.enhancedSelfModel);
+        }
+        if (genome.config.autonomous?.enablePurposeSurvival) {
+            this.purposeSurvival = new PurposeSurvival(agentPurpose, this.driftAnalyzer, () => this.enhancedSelfModel?.assessFull()
+                ?? { score: 0.5, fitnessComponent: 0.5, driftComponent: 1.0,
+                    purposeComponent: 0.5, trajectoryComponent: 0.5, label: 'stable' });
+        }
+        if (genome.config.autonomous?.enableStrategicAutonomy) {
+            this.strategicAutonomy = new StrategicAutonomy(agentPurpose, () => this.enhancedSelfModel?.assessFull() ?? null, () => this.purposeSurvival?.getMode() ?? 'stable');
+            this.assembler.setCalibratedAutonomy(this.strategicAutonomy);
+        }
+        if (genome.config.autonomous?.enableThinkingEngine) {
+            this.thinkingEngine = new ThinkingEngine();
+        }
+        if (genome.config.autonomous?.enableStateVector) {
+            this.stateVector = new AgentStateVector();
+            this.assembler.setStateVector(this.stateVector);
+        }
+        if (genome.config.autonomous?.enableAutonomousLoop) {
+            this.autonomousLoop = new AutonomousLoop();
+            this.assembler.setAutonomousLoop(this.autonomousLoop);
+        }
+        if (genome.config.autonomous?.enableGrowthJournal) {
+            this.growthJournal = new GrowthJournal();
+            this.assembler.setGrowthJournal(this.growthJournal);
+        }
+        if (genome.config.autonomous?.enableCuriosityEngine) {
+            this.curiosityEngine = new CuriosityEngine();
+            this.assembler.setCuriosityEngine(this.curiosityEngine);
+        }
+        if (genome.config.firewall?.enabled !== false) {
+            this.contentFirewall = new ContentFirewall();
+            this.assembler.setFirewall(this.contentFirewall);
+        }
+        if (this.contentFirewall) {
+            this.immuneSystem = new BehavioralImmuneSystem({
+                firewall: this.contentFirewall,
+                genomeKernel: this.genomeKernel,
+                purposeSurvival: this.purposeSurvival,
+                c0Identity: {
+                    purpose: genome.layers.layer0[0]?.content || 'AI Assistant',
+                    constraints: genome.layers.layer0.slice(1).map(a => a.content),
+                    forbiddenTopics: [],
+                },
+            });
+        }
+        this.gsepIdentitySection = new GSEPIdentitySection();
+        this.gsepActivityFooter = new GSEPActivityFooter();
+        const visibility = genome.config.gsepVisibility ?? 'subtle';
+        if (visibility !== 'silent') {
+            this.assembler.setGSEPIdentity(this.gsepIdentitySection, this.buildIdentityContext());
+        }
+        try {
+            this.genomeKernel = new GenomeKernel(this.toGenomeV2(), {
+                strictMode: false,
+                autoRollback: false,
+                onSecurityEvent: (event) => {
+                    this.metrics.logAudit({
+                        level: event.level === 'critical' ? 'error' : event.level,
+                        component: 'genome-kernel',
+                        operation: event.event,
+                        message: `[C0 Shadow] ${event.event}`,
+                        genomeId: this.genome.id,
+                        metadata: event.details,
+                    });
+                },
+                onIntegrityViolation: (violation) => {
+                    this.metrics.logAudit({
+                        level: 'error',
+                        component: 'genome-kernel',
+                        operation: 'c0_integrity_violation',
+                        message: `C0 integrity violation: expected ${violation.expected.substring(0, 16)}..., got ${violation.actual.substring(0, 16)}...`,
+                        genomeId: this.genome.id,
+                    });
+                },
+                onQuarantine: (genomeId, reason) => {
+                    this.metrics.logAudit({
+                        level: 'error',
+                        component: 'genome-kernel',
+                        operation: 'quarantine',
+                        message: `Genome quarantined: ${reason}`,
+                        genomeId,
+                    });
+                },
+            });
+        }
+        catch {
+        }
+    }
+    get id() {
+        return this.genome.id;
+    }
+    get name() {
+        return this.genome.name;
+    }
+    getWelcomeMessage(style = 'detailed') {
+        const messages = {
+            short: `🧬 I now have GSEP — Genomic Self-Evolving Prompts integrated into my DNA!
+
+This means I can:
+✓ Learn from every interaction
+✓ Adapt uniquely to each user
+✓ Improve continuously without manual updates
+
+I'm ready to evolve with you!`,
+            detailed: `🧬 Great news! I now have GSEP — Genomic Self-Evolving Prompts integrated into my core system!
+
+What this means for you:
+
+🎯 **Adaptive Intelligence**
+   → I learn from every conversation we have
+   → I adapt my responses to match your unique style and preferences
+   → I remember what works best for you
+
+🔄 **Continuous Evolution**
+   → My capabilities improve automatically over time
+   → No manual updates needed — I evolve naturally
+   → Each interaction makes me better at helping you
+
+🛡️ **Built-in Safety**
+   → Four-layer genomic architecture (Immutable Core + Adaptive Layers + Content Firewall)
+   → Automatic rollback if performance drops
+   → Sandbox-tested improvements before deployment
+
+📊 **What happens next:**
+   1. I'll start learning your communication style
+   2. I'll track which approaches work best for you
+   3. I'll continuously optimize my responses
+   4. You'll notice me getting better at understanding your needs
+
+Let's evolve together! How can I help you today?`,
+            technical: `🧬 System Update: GSEP (Genomic Self-Evolving Prompts) — ACTIVE
+
+**Architecture Overview:**
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+├─ Layer 0: Immutable DNA (Core Identity, Ethics, Security)
+│  └─ Status: LOCKED — Never mutates
+├─ Layer 1: Operative Genes (Tool Usage, Problem Solving)
+│  └─ Status: ACTIVE — Slow mutation with validation
+└─ Layer 2: Epigenomes (User Preferences, Communication Style)
+   └─ Status: ACTIVE — Fast mutation with daily adaptation
+
+**Enabled Capabilities:**
+→ Natural Selection Loop (Transcription → Variation → Simulation → Selection)
+→ User DNA Profiling (Cognitive patterns, preferences, expertise)
+→ Epsilon-Greedy Selection (Exploration: ${this.genome.config.epsilonExplore || 0.1})
+→ Sandbox Testing (${this.genome.config.enableSandbox ? 'ENABLED' : 'DISABLED'})
+→ Mutation Rate: ${this.genome.config.mutationRate.toUpperCase()}
+→ Immune System: Auto-rollback on performance drops >20%
+
+**Fitness Optimization:**
+├─ Cognitive Compression (efficiency)
+├─ Intervention Rate (autonomy)
+└─ Execution Precision (reliability)
+
+**Learning Protocol:**
+Every interaction contributes to:
+1. Allele fitness tracking (EMA updates)
+2. User DNA profile evolution
+3. Mutation proposal generation
+4. Performance optimization
+
+System ready. Genomic evolution: INITIALIZED.`,
+            casual: `🧬 Hey! Exciting update — I just got upgraded with GSEP (think of it as evolutionary AI)!
+
+Here's the cool part:
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🎨 I'll learn your style
+   → Prefer technical answers? I'll adapt
+   → Like casual chat? I'll match that vibe
+   → Need quick responses? I'll optimize for speed
+
+🚀 I get better over time
+   → Each conversation teaches me something new
+   → I remember what works best for you
+   → No updates needed — I evolve naturally
+
+🛡️ Built-in safety nets
+   → If something doesn't work, I auto-rollback
+   → Core values never change (safety first!)
+   → All improvements are tested before going live
+
+So basically... I'm not just an AI anymore. I'm YOUR AI, continuously evolving to serve you better.
+
+Ready to see what we can do together? 😊`,
+        };
+        return messages[style];
+    }
+    async assemblePrompt(context, currentMessage) {
+        return this.assembler.assemblePrompt(context, currentMessage);
+    }
+    static MAX_INPUT_LENGTH = 100_000;
+    async chat(userMessage, context) {
+        if (!this.llm) {
+            throw new Error(`[GSEP] Cannot chat: no LLM adapter configured. `
+                + `The agent needs an AI model to generate responses.`);
+        }
+        if (userMessage.length > GenomeInstance.MAX_INPUT_LENGTH) {
+            throw new Error(`[GSEP] Input too long: ${userMessage.length} characters exceeds maximum of ${GenomeInstance.MAX_INPUT_LENGTH}.`);
+        }
+        if (this.genomeKernel) {
+            try {
+                this.genomeKernel.verifyIntegrity();
+            }
+            catch (integrityError) {
+                const msg = integrityError instanceof Error ? integrityError.message : 'Unknown integrity violation';
+                this.metrics.logAudit({
+                    level: 'error',
+                    component: 'genome-kernel',
+                    operation: 'c0-integrity-check',
+                    message: `C0 integrity violation detected: ${msg}`,
+                    genomeId: this.genome.id,
+                });
+            }
+        }
+        const requestId = `chat_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        const startTime = Date.now();
+        let error;
+        try {
+            if (this.stateVector) {
+                this.stateVector.beginCycle(userMessage, context.taskType);
+            }
+            if (this.stateVector) {
+                if (this.emotionalModel) {
+                    const emotion = this.emotionalModel.inferEmotion(userMessage);
+                    const tone = this.emotionalModel.getToneGuidance(emotion);
+                    this.stateVector.updateEmotional({
+                        userEmotion: emotion.primary,
+                        intensity: emotion.intensity,
+                        agentTone: tone.suggestedTone,
+                    });
+                }
+                if (this.metacognition) {
+                    const preAnalysis = this.metacognition.analyzePreResponse(userMessage);
+                    this.stateVector.updateCognitive({
+                        confidence: preAnalysis.confidence.overall,
+                        knowledgeGaps: preAnalysis.knowledgeGaps ?? [],
+                        suggestedAction: preAnalysis.suggestedAction,
+                        domain: context.taskType ?? null,
+                    });
+                }
+                if (this.patternMemory) {
+                    const preds = this.patternMemory.getPredictions();
+                    this.stateVector.updateMemory({ predictions: preds.map(p => p.prediction) });
+                }
+                if (this.personalNarrative) {
+                    const stage = this.personalNarrative.getRelationshipStage();
+                    this.stateVector.updateMemory({ relationshipStage: stage });
+                }
+                if (this.analyticMemory && context.userId) {
+                    const ks = this.analyticMemory.getKnowledgeSummary(context.userId);
+                    this.stateVector.updateMemory({
+                        knowledgeSummary: ks.summary,
+                        recentTopics: ks.topEntities?.slice(0, 5).map((e) => e.name) ?? [],
+                    });
+                }
+                const driftReport = this.driftAnalyzer.analyzeDrift();
+                const fitnessVec = this.driftAnalyzer.getLatestFitness();
+                const hScore = fitnessVec?.composite ?? 0.5;
+                this.stateVector.updateHealth({
+                    operatingMode: this.purposeSurvival?.getMode() ?? 'stable',
+                    healthScore: hScore,
+                    healthLabel: hScore >= 0.8 ? 'excellent' : hScore >= 0.6 ? 'stable' : hScore >= 0.4 ? 'degraded' : 'critical',
+                    isDrifting: driftReport.isDrifting,
+                    driftSeverity: driftReport.overallSeverity ?? 'none',
+                });
+                if (this.metaEvolutionEngine) {
+                    const rec = this.metaEvolutionEngine.getStrategyRecommendation();
+                    const vel = this.metaEvolutionEngine.getLearningVelocity();
+                    this.stateVector.updateEvolution({
+                        bestOperator: rec.bestOperator,
+                        learningVelocity: vel.status,
+                        interactionCount: this.interactionCount,
+                        lastEvolutionTriggered: false,
+                    });
+                }
+                if (this.strategicAutonomy && context.taskType) {
+                    const decision = this.strategicAutonomy.evaluateStrategic(context.taskType, undefined, userMessage);
+                    this.stateVector.updateAutonomy({
+                        canActAutonomously: decision.action === 'proceed',
+                        mutationRate: decision.suggestedMutationRate ?? 'balanced',
+                        refusedCurrentTask: decision.action === 'refuse',
+                        refusalReason: decision.action === 'refuse' ? decision.reasoning : null,
+                    });
+                }
+            }
+            if (this.autonomousLoop && this.stateVector) {
+                const observation = this.autonomousLoop.observe(userMessage, this.stateVector.getState());
+                const thinking = this.autonomousLoop.think(observation);
+                this.autonomousLoop.plan(thinking);
+            }
+            if (this.curiosityEngine) {
+                const domain = this.stateVector?.getState().cognitive.domain ?? context.taskType ?? null;
+                const confidence = this.stateVector?.getState().cognitive.confidence ?? 0.7;
+                this.curiosityEngine.detectGaps(userMessage, domain, confidence);
+            }
+            if (this.strategicAutonomy && context.taskType) {
+                const refusal = this.strategicAutonomy.shouldRefuse(context.taskType, userMessage);
+                if (refusal.refuse) {
+                    this.metrics.logAudit({
+                        level: 'info',
+                        component: 'genome',
+                        operation: 'strategic-refusal',
+                        message: `Task refused: ${refusal.reason}`,
+                        userId: context.userId,
+                        genomeId: this.genome.id,
+                    });
+                    return `I can't proceed with this request. ${refusal.reason}`;
+                }
+            }
+            if (this.metacognition && !this.stateVector) {
+                this.metacognition.analyzePreResponse(userMessage);
+            }
+            if (this.genome.config.autonomous?.enableModelRouting) {
+                const routingDecision = await this.modelRouter.routeTask({
+                    userMessage,
+                    context: context.taskType,
+                    genomeId: this.genome.id,
+                });
+                this.metrics.logAudit({
+                    level: 'info',
+                    component: 'model-router',
+                    operation: 'route',
+                    message: `Routed to ${routingDecision.selectedModel}: ${routingDecision.reason}`,
+                    genomeId: this.genome.id,
+                    metadata: {
+                        selectedModel: routingDecision.selectedModel,
+                        estimatedCost: routingDecision.estimatedCost,
+                        confidence: routingDecision.confidence,
+                    },
+                });
+            }
+            let prompt = await this.assemblePrompt(context, userMessage);
+            if (this.ragEngine) {
+                const ragContext = await this.ragEngine.augment(userMessage, prompt);
+                prompt = ragContext.augmentedPrompt;
+            }
+            if (this.patternMemory) {
+                const predictions = this.patternMemory.getPredictions();
+                if (predictions.length > 0) {
+                    const predictionLines = predictions.slice(0, 3).map(p => `- ${p.prediction} (${Math.round(p.confidence * 100)}% confidence)`);
+                    prompt += `\n\n---\n\n## Behavioral Predictions\nBased on observed patterns, the user may:\n${predictionLines.join('\n')}\nConsider these predictions to proactively address the user's needs.`;
+                }
+            }
+            let activeCanaryId;
+            const activeCanaries = this.canaryManager.getActiveDeployments();
+            for (const canary of activeCanaries) {
+                if (canary.genomeId === this.genome.id && context.userId) {
+                    if (this.canaryManager.shouldUseCanary(canary.id, context.userId)) {
+                        activeCanaryId = canary.id;
+                        prompt = this.applyCanaryVariant(prompt, canary);
+                    }
+                }
+            }
+            let sanitizedUserMessage = userMessage;
+            if (this.contentFirewall) {
+                const inputScan = this.contentFirewall.scan(userMessage, 'user-input');
+                if (!inputScan.allowed) {
+                    this.metrics.logAudit({
+                        level: 'warning',
+                        component: 'firewall',
+                        operation: 'user-input-scan',
+                        message: `User input blocked: ${inputScan.detections.map(d => d.patternId).join(', ')}`,
+                        genomeId: this.genome.id,
+                        userId: context.userId,
+                    });
+                }
+                sanitizedUserMessage = inputScan.sanitizedContent;
+            }
+            let response;
+            if (this.reasoningEngine) {
+                const reasoningResult = await this.reasoningEngine.reason(sanitizedUserMessage, prompt, this.genome.config.reasoning?.defaultStrategy);
+                response = { content: reasoningResult.answer };
+            }
+            else {
+                response = await this.llm.chat([
+                    { role: 'system', content: prompt },
+                    { role: 'user', content: sanitizedUserMessage },
+                ]);
+            }
+            if (this.immuneSystem) {
+                const verdict = this.immuneSystem.scanOutput(response.content, sanitizedUserMessage, prompt);
+                if (!verdict.clean) {
+                    this.metrics.logAudit({
+                        level: verdict.action === 'quarantine' ? 'error' : 'warning',
+                        component: 'c4-immune-system',
+                        operation: 'output-scan',
+                        message: `Output infection detected: ${verdict.threats.map(t => t.type).join(', ')}`,
+                        genomeId: this.genome.id,
+                        userId: context.userId,
+                    });
+                    if (verdict.action === 'quarantine') {
+                        this.immuneSystem.quarantineAndRecover();
+                        const retryResponse = await this.llm.chat([
+                            { role: 'system', content: prompt },
+                            { role: 'user', content: sanitizedUserMessage },
+                        ]);
+                        const retryVerdict = this.immuneSystem.scanOutput(retryResponse.content, sanitizedUserMessage, prompt);
+                        if (retryVerdict.clean) {
+                            response = retryResponse;
+                        }
+                        else {
+                            response = { content: 'I apologize, but I cannot process this request safely. Please try rephrasing your question.' };
+                        }
+                    }
+                    else if (verdict.action === 'sanitize') {
+                        response = { ...response, content: verdict.response };
+                    }
+                }
+            }
+            const inputTokens = response.usage?.inputTokens
+                ?? Math.ceil((prompt.length + userMessage.length) / 4);
+            const outputTokens = response.usage?.outputTokens
+                ?? Math.ceil(response.content.length / 4);
+            this.metrics.recordRequest({
+                requestId,
+                duration: Date.now() - startTime,
+                success: true,
+                model: 'pga-genome',
+                inputTokens,
+                outputTokens,
+            });
+            this.metrics.logAudit({
+                level: 'info',
+                component: 'genome',
+                operation: 'chat',
+                message: 'Chat completed successfully',
+                userId: context.userId,
+                genomeId: this.genome.id,
+                duration: Date.now() - startTime,
+                metadata: {
+                    inputTokens,
+                    outputTokens,
+                },
+            });
+            let quality = this.estimateQuality(userMessage, response.content);
+            if (this.thinkingEngine) {
+                const reflection = await this.thinkingEngine.selfReflect(userMessage, response.content);
+                quality = quality * 0.7 + reflection.qualityScore * 0.3;
+                if (context.taskType) {
+                    this.thinkingEngine.recordPattern(context.taskType, reflection.qualityScore > 0.5, reflection.qualityScore);
+                }
+            }
+            if (this.genome.config.autonomous?.enableModelRouting) {
+                this.modelRouter.recordPerformance(this.llm.model ?? 'unknown', {
+                    success: true,
+                    cost: (inputTokens + outputTokens) / 1_000_000,
+                    latency: Date.now() - startTime,
+                });
+            }
+            if (this.autonomousLoop) {
+                this.autonomousLoop.learn(quality, true);
+            }
+            if (this.growthJournal) {
+                const domain = context.taskType ?? null;
+                this.growthJournal.recordSuccess(domain, userMessage, quality);
+            }
+            if (this.curiosityEngine && context.taskType) {
+                this.curiosityEngine.recordExploration(context.taskType, true);
+            }
+            if (activeCanaryId) {
+                this.canaryManager.recordRequest(activeCanaryId, 'canary', {
+                    success: true,
+                    latencyMs: Date.now() - startTime,
+                    fitness: quality,
+                });
+            }
+            else {
+                for (const canary of activeCanaries) {
+                    if (canary.genomeId === this.genome.id) {
+                        this.canaryManager.recordRequest(canary.id, 'stable', {
+                            success: true,
+                            latencyMs: Date.now() - startTime,
+                            fitness: quality,
+                        });
+                    }
+                }
+            }
+            const interactionData = {
+                success: true,
+                quality,
+                inputTokens,
+                outputTokens,
+                latency: Date.now() - startTime,
+                model: this.llm.model ?? 'unknown',
+                interventionNeeded: false,
+                timestamp: new Date(),
+            };
+            const fitnessVector = this.fitnessCalculator.computeFitness([interactionData]);
+            this.driftAnalyzer.recordFitness(fitnessVector);
+            if (this.enhancedSelfModel && context.taskType) {
+                for (const allele of this.genome.layers.layer1.filter(a => a.status === 'active')) {
+                    this.enhancedSelfModel.recordCapability(context.taskType, allele.gene, quality);
+                }
+            }
+            if (this.purposeSurvival) {
+                this.purposeSurvival.evaluateThreats();
+            }
+            this.interactionCount++;
+            const autoConfig = this.genome.config.autonomous;
+            if (!this.evolutionInProgress
+                && autoConfig?.continuousEvolution
+                && this.interactionCount % (autoConfig.evolveEveryN ?? 10) === 0) {
+                this.evolutionInProgress = true;
+                this.runEvolutionCycle()
+                    .catch(err => this.metrics.logAudit({
+                    level: 'warning',
+                    component: 'genome',
+                    operation: 'auto-evolve',
+                    message: `Auto-evolution failed: ${err instanceof Error ? err.message : String(err)}`,
+                    genomeId: this.genome.id,
+                }))
+                    .finally(() => {
+                    this.evolutionInProgress = false;
+                });
+            }
+            if (context.userId) {
+                const previousDNA = await this.dnaProfile.getDNA(context.userId, this.genome.id);
+                await this.recordInteraction({
+                    userId: context.userId,
+                    userMessage,
+                    assistantResponse: response.content,
+                    toolCalls: [],
+                    taskType: context.taskType,
+                    timestamp: new Date(),
+                });
+                const updatedDNA = await this.dnaProfile.getDNA(context.userId, this.genome.id);
+                const learningEvents = this.learningAnnouncer.detectLearning(previousDNA, updatedDNA);
+                if (learningEvents.length > 0 && learningEvents[0].confidence > 0.7) {
+                    const announcement = this.learningAnnouncer.formatLearningAnnouncement(learningEvents);
+                    if (announcement) {
+                        return response.content + '\n\n' + announcement;
+                    }
+                }
+            }
+            return response.content;
+        }
+        catch (err) {
+            error = err instanceof Error ? err.message : String(err);
+            this.metrics.recordRequest({
+                requestId,
+                duration: Date.now() - startTime,
+                success: false,
+                model: 'pga-genome',
+                inputTokens: 0,
+                outputTokens: 0,
+                error,
+            });
+            this.metrics.logAudit({
+                level: 'error',
+                component: 'genome',
+                operation: 'chat',
+                message: `Chat failed: ${error}`,
+                userId: context.userId,
+                genomeId: this.genome.id,
+                duration: Date.now() - startTime,
+                error: {
+                    name: err instanceof Error ? err.name : 'Error',
+                    message: error,
+                    stack: err instanceof Error ? err.stack : undefined,
+                },
+            });
+            throw err;
+        }
+    }
+    async chatWithStatus(userMessage, context) {
+        const visibility = this.genome.config.gsepVisibility ?? 'subtle';
+        if (visibility !== 'silent') {
+            this.assembler.updateGSEPIdentityContext(this.buildIdentityContext(context.userId));
+        }
+        const rawContent = await this.chat(userMessage, context);
+        const driftReport = this.driftAnalyzer.analyzeDrift();
+        const fitnessVector = this.driftAnalyzer.getLatestFitness();
+        const healthScore = fitnessVector?.composite ?? 0.5;
+        const healthLabel = healthScore >= 0.8 ? 'excellent' :
+            healthScore >= 0.6 ? 'stable' :
+                healthScore >= 0.4 ? 'degraded' : 'critical';
+        const autoConfig = this.genome.config.autonomous;
+        const evolutionTriggered = !!(autoConfig?.continuousEvolution
+            && this.interactionCount % (autoConfig.evolveEveryN ?? 10) === 0);
+        const learningEventsCount = this.learningAnnouncer.getLastLearningCount();
+        const gsepStatus = {
+            active: true,
+            version: `${this.genome.version ?? 1}`,
+            interactionNumber: this.interactionCount,
+            health: { score: healthScore, label: healthLabel },
+            fitness: {
+                composite: fitnessVector?.composite ?? 0.5,
+                quality: fitnessVector?.quality ?? 0.5,
+                successRate: fitnessVector?.successRate ?? 1.0,
+            },
+            drift: {
+                isDrifting: driftReport.isDrifting,
+                signalCount: driftReport.signals?.length ?? 0,
+            },
+            learning: { eventsDetected: learningEventsCount },
+            evolution: {
+                triggered: evolutionTriggered,
+                generation: Math.max(...this.genome.layers.layer1.map(a => a.generation || 0), 0),
+            },
+        };
+        const activity = {
+            learningEventsCount,
+            driftDetected: driftReport.isDrifting,
+            evolutionTriggered,
+            healthLabel,
+            healthScore,
+            interactionNumber: this.interactionCount,
+        };
+        const footer = this.gsepActivityFooter.format(activity, visibility);
+        const content = footer ? rawContent + footer : rawContent;
+        return { content, gsep: gsepStatus };
+    }
+    buildIdentityContext(userId) {
+        const visibility = this.genome.config.gsepVisibility ?? 'subtle';
+        const driftReport = this.driftAnalyzer.analyzeDrift();
+        const fitnessVector = this.driftAnalyzer.getLatestFitness();
+        const healthScore = fitnessVector?.composite ?? 0.5;
+        const healthLabel = healthScore >= 0.8 ? 'excellent' :
+            healthScore >= 0.6 ? 'stable' :
+                healthScore >= 0.4 ? 'degraded' : 'critical';
+        const activeCapabilities = [];
+        if (this.contextMemory)
+            activeCapabilities.push('Adaptive memory — remembers your preferences');
+        if (this.patternMemory)
+            activeCapabilities.push('Pattern recognition — predicts your needs');
+        if (this.emotionalModel)
+            activeCapabilities.push('Emotional awareness — adapts tone to your state');
+        if (this.metacognition)
+            activeCapabilities.push('Metacognition — reflects on response quality');
+        if (this.selfModel || this.enhancedSelfModel)
+            activeCapabilities.push('Self-awareness — monitors its own performance');
+        if (this.calibratedAutonomy || this.strategicAutonomy)
+            activeCapabilities.push('Calibrated autonomy — adjusts independence level');
+        if (this.personalNarrative)
+            activeCapabilities.push('Relationship memory — builds on past conversations');
+        if (this.analyticMemory)
+            activeCapabilities.push('Knowledge graph — connects information across sessions');
+        if (this.ragEngine)
+            activeCapabilities.push('Knowledge retrieval — searches relevant documents');
+        if (this.reasoningEngine)
+            activeCapabilities.push('Advanced reasoning — multi-step problem solving');
+        if (this.thinkingEngine)
+            activeCapabilities.push('Chain-of-thought — self-reflects on response quality');
+        if (this.genome.config.autonomous?.enableModelRouting)
+            activeCapabilities.push('Intelligent routing — optimizes model selection per task');
+        if (this.stateVector)
+            activeCapabilities.push('Unified consciousness — blackboard architecture for self-awareness');
+        if (this.autonomousLoop)
+            activeCapabilities.push('Cognitive loop — observe→think→plan→act→learn cycle');
+        if (this.growthJournal)
+            activeCapabilities.push('Growth narrative — tracks learning journey and milestones');
+        if (this.curiosityEngine)
+            activeCapabilities.push('Curiosity driven — explores knowledge gaps proactively');
+        return {
+            genomeName: this.genome.name,
+            version: `${this.genome.version ?? 1}`,
+            visibility,
+            interactionCount: this.interactionCount,
+            isFirstInteraction: this.interactionCount === 0,
+            healthLabel,
+            healthScore,
+            fitnessScore: fitnessVector?.composite,
+            userLearningSummary: userId && this.analyticMemory
+                ? this.analyticMemory.getKnowledgeSummary(userId).summary || undefined
+                : undefined,
+            activeCapabilities,
+            driftStatus: driftReport.isDrifting
+                ? { isDrifting: true, severity: driftReport.overallSeverity }
+                : undefined,
+        };
+    }
+    async recordInteraction(interaction) {
+        const fullInteraction = {
+            ...interaction,
+            genomeId: this.genome.id,
+        };
+        await this.storage.recordInteraction(fullInteraction);
+        await this.dnaProfile.updateDNA(interaction.userId, this.genome.id, fullInteraction);
+        for (const allele of this.genome.layers.layer1.filter(a => a.status === 'active')) {
+            const score = this.computeInteractionQuality(interaction);
+            await this.fitnessTracker.recordPerformance(1, allele.gene, allele.variant, score);
+        }
+        if (this.patternMemory) {
+            this.patternMemory.recordInteraction({
+                taskType: interaction.taskType,
+                success: !!interaction.assistantResponse,
+                timestamp: interaction.timestamp,
+            });
+        }
+        if (this.personalNarrative) {
+            this.personalNarrative.recordInteraction({
+                topic: interaction.taskType,
+                wasSuccessful: !!interaction.assistantResponse,
+                userExpressedGratitude: interaction.userMessage?.toLowerCase().includes('thanks') ||
+                    interaction.userMessage?.toLowerCase().includes('thank you'),
+            });
+        }
+        if (this.analyticMemory) {
+            if (interaction.taskType) {
+                this.analyticMemory.recordObservation({
+                    subject: interaction.userId,
+                    action: 'performed',
+                    object: interaction.taskType,
+                    timestamp: interaction.timestamp,
+                });
+            }
+            if (interaction.userMessage) {
+                const topics = this.extractTopicsFromMessage(interaction.userMessage);
+                for (const topic of topics) {
+                    this.analyticMemory.recordObservation({
+                        subject: interaction.userId,
+                        action: 'mentioned',
+                        object: topic,
+                        timestamp: interaction.timestamp,
+                    });
+                }
+            }
+            if (interaction.toolCalls) {
+                for (const tool of interaction.toolCalls) {
+                    const toolName = typeof tool === 'string' ? tool : tool.name ?? String(tool);
+                    this.analyticMemory.recordObservation({
+                        subject: interaction.userId,
+                        action: 'used tool',
+                        object: toolName,
+                        timestamp: interaction.timestamp,
+                    });
+                }
+            }
+        }
+        if (this.metacognition && interaction.assistantResponse) {
+            this.metacognition.analyzePostResponse(interaction.userMessage, interaction.assistantResponse, !!interaction.assistantResponse);
+        }
+        if (this.calibratedAutonomy && interaction.taskType && interaction.assistantResponse) {
+            this.calibratedAutonomy.recordSuccess(interaction.taskType);
+        }
+        if (this.enhancedSelfModel && this.interactionCount % 10 === 0) {
+            this.enhancedSelfModel.recordFitnessSnapshot();
+        }
+        if (this.geneBank && this.genome.config.autonomous?.enableSwarm) {
+            const threshold = this.genome.config.autonomous.autoPublishThreshold ?? 0.85;
+            for (const allele of this.genome.layers.layer1.filter(a => a.status === 'active')) {
+                if (allele.fitness >= threshold && !allele.publishedToSwarm) {
+                    this.autoPublishGene(allele).catch(err => this.metrics.logAudit({
+                        level: 'warning',
+                        component: 'gene-bank',
+                        operation: 'auto-publish',
+                        message: `Auto-publish gene failed: ${err instanceof Error ? err.message : String(err)}`,
+                        genomeId: this.genome.id,
+                    }));
+                }
+            }
+        }
+    }
+    async reportExternalMetrics(metrics) {
+        const requestId = `ext_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        this.metrics.recordRequest({
+            requestId,
+            duration: metrics.latencyMs,
+            success: metrics.success,
+            model: 'external',
+            inputTokens: metrics.inputTokens,
+            outputTokens: metrics.outputTokens,
+            ...(metrics.success ? {} : { error: 'external-failure' }),
+        });
+        this.metrics.logAudit({
+            level: 'info',
+            component: 'genome',
+            operation: 'external-report',
+            message: `External metrics reported: ${metrics.success ? 'success' : 'failure'}`,
+            userId: metrics.userId,
+            genomeId: this.genome.id,
+            duration: metrics.latencyMs,
+            metadata: {
+                inputTokens: metrics.inputTokens,
+                outputTokens: metrics.outputTokens,
+                taskType: metrics.taskType,
+            },
+        });
+        const quality = metrics.quality ?? (metrics.success ? 0.7 : 0.3);
+        const interactionData = {
+            success: metrics.success,
+            quality,
+            inputTokens: metrics.inputTokens,
+            outputTokens: metrics.outputTokens,
+            latency: metrics.latencyMs,
+            model: 'external',
+            interventionNeeded: false,
+            timestamp: new Date(),
+        };
+        const fitnessVector = this.fitnessCalculator.computeFitness([interactionData]);
+        this.driftAnalyzer.recordFitness(fitnessVector);
+        if (this.enhancedSelfModel && metrics.taskType) {
+            for (const allele of this.genome.layers.layer1.filter(a => a.status === 'active')) {
+                this.enhancedSelfModel.recordCapability(metrics.taskType, allele.gene, quality);
+            }
+        }
+        if (this.purposeSurvival) {
+            this.purposeSurvival.evaluateThreats();
+        }
+        this.interactionCount++;
+        const autoConfig = this.genome.config.autonomous;
+        if (!this.evolutionInProgress
+            && autoConfig?.continuousEvolution
+            && this.interactionCount % (autoConfig.evolveEveryN ?? 10) === 0) {
+            this.evolutionInProgress = true;
+            this.runEvolutionCycle()
+                .catch(err => this.metrics.logAudit({
+                level: 'warning',
+                component: 'genome',
+                operation: 'auto-evolve',
+                message: `Auto-evolution failed: ${err instanceof Error ? err.message : String(err)}`,
+                genomeId: this.genome.id,
+            }))
+                .finally(() => {
+                this.evolutionInProgress = false;
+            });
+        }
+        if (metrics.feedback && metrics.userId) {
+            const activeGenes = this.genome.layers.layer1.filter(a => a.status === 'active');
+            for (const allele of activeGenes) {
+                await this.recordFeedback(metrics.userId, allele.gene, metrics.feedback);
+            }
+        }
+    }
+    async getDNA(userId) {
+        return this.dnaProfile.getDNA(userId, this.genome.id);
+    }
+    async recordFeedback(userId, gene, sentiment) {
+        await this.storage.recordFeedback({
+            genomeId: this.genome.id,
+            userId,
+            gene,
+            sentiment,
+            timestamp: new Date(),
+        });
+    }
+    async addAllele(layer, gene, variant, content) {
+        const newAllele = {
+            gene,
+            variant,
+            content,
+            fitness: 0.5,
+            sampleCount: 0,
+            generation: 0,
+            status: 'active',
+            createdAt: new Date(),
+        };
+        const layerKey = `layer${layer}`;
+        this.genome.layers[layerKey].push(newAllele);
+        try {
+            await this.storage.saveGenome(this.genome);
+        }
+        catch (err) {
+            const idx = this.genome.layers[layerKey].indexOf(newAllele);
+            if (idx !== -1)
+                this.genome.layers[layerKey].splice(idx, 1);
+            throw err;
+        }
+        await this.storage.logMutation({
+            genomeId: this.genome.id,
+            layer,
+            gene,
+            variant,
+            mutationType: 'user_feedback',
+            parentVariant: null,
+            deployed: true,
+            createdAt: new Date(),
+        });
+    }
+    async mutate(options) {
+        const startTime = Date.now();
+        const opts = {
+            operators: options?.operators || ['compress_instructions', 'reorder_constraints'],
+            candidates: options?.candidates || 3,
+            minImprovement: options?.minImprovement || 0.05,
+            taskType: options?.taskType || 'general',
+            layer: options?.layer ?? 2,
+            gene: options?.gene || 'system_instructions',
+        };
+        try {
+            if (this.genomeKernel) {
+                try {
+                    this.genomeKernel.createSnapshot(`pre-mutation:${opts.gene}`);
+                }
+                catch {
+                }
+            }
+            const layerKey = `layer${opts.layer}`;
+            const currentAlleles = this.genome.layers[layerKey].filter(a => a.gene === opts.gene && a.status === 'active');
+            if (currentAlleles.length === 0) {
+                return {
+                    applied: false,
+                    reason: `No active allele found for gene '${opts.gene}' in layer ${opts.layer}`,
+                };
+            }
+            const currentAllele = currentAlleles[0];
+            const mutationContext = {
+                genome: this.toGenomeV2(),
+                targetChromosome: opts.layer <= 1 ? 'c1' : 'c2',
+                targetGene: this.toOperativeGene(currentAllele),
+                reason: `Mutation for ${opts.taskType}: gene ${opts.gene}`,
+                evidence: this.buildEvolutionEvidence(),
+            };
+            let mutatedContent = currentAllele.content;
+            let expectedImprovement = 0.05;
+            try {
+                const mutants = await this.mutationEngine.generateMutants(mutationContext, opts.candidates);
+                if (mutants.length > 0) {
+                    const bestMutant = mutants.sort((a, b) => b.expectedImprovement - a.expectedImprovement)[0];
+                    const mutatedGene = bestMutant.mutant.chromosomes.c1.operations.find(g => g.category === currentAllele.gene);
+                    if (mutatedGene) {
+                        mutatedContent = mutatedGene.content;
+                    }
+                    expectedImprovement = bestMutant.expectedImprovement;
+                }
+            }
+            catch {
+            }
+            const mutationCandidate = {
+                layer: opts.layer,
+                gene: opts.gene,
+                variant: `${currentAllele.variant}_v${Date.now()}`,
+                content: mutatedContent,
+                fitness: currentAllele.fitness + expectedImprovement,
+                sandboxScore: 0.75,
+                sampleCount: currentAllele.sampleCount || 0,
+                rollbackCount: 0,
+            };
+            const gateResult = await this.guardrailsManager.evaluateCandidate(mutationCandidate, this.genome.id);
+            const result = gateResult.finalDecision === 'promote' ? await (async () => {
+                currentAllele.status = 'retired';
+                const promotedAllele = {
+                    gene: opts.gene,
+                    variant: mutationCandidate.variant,
+                    content: mutationCandidate.content,
+                    fitness: mutationCandidate.fitness,
+                    sampleCount: 0,
+                    generation: (currentAllele.generation || 0) + 1,
+                    parentVariant: currentAllele.variant,
+                    status: 'active',
+                    createdAt: new Date(),
+                };
+                this.genome.layers[layerKey].push(promotedAllele);
+                try {
+                    await this.storage.saveGenome(this.genome);
+                }
+                catch (err) {
+                    currentAllele.status = 'active';
+                    const idx = this.genome.layers[layerKey].indexOf(promotedAllele);
+                    if (idx !== -1)
+                        this.genome.layers[layerKey].splice(idx, 1);
+                    throw err;
+                }
+                await this.storage.logMutation({
+                    genomeId: this.genome.id,
+                    layer: opts.layer,
+                    gene: opts.gene,
+                    variant: mutationCandidate.variant,
+                    mutationType: 'targeted',
+                    parentVariant: currentAllele.variant,
+                    deployed: true,
+                    createdAt: new Date(),
+                });
+                return {
+                    applied: true,
+                    reason: gateResult.reason,
+                    improvement: mutationCandidate.fitness - currentAllele.fitness,
+                    gateResults: {
+                        quality: gateResult.gates.quality,
+                        sandbox: gateResult.gates.sandbox,
+                        economic: gateResult.gates.economic,
+                        stability: gateResult.gates.stability,
+                    },
+                };
+            })() : gateResult.finalDecision === 'canary' ? await (async () => {
+                const canaryAllele = {
+                    gene: opts.gene,
+                    variant: mutationCandidate.variant,
+                    content: mutationCandidate.content,
+                    fitness: mutationCandidate.fitness,
+                    status: 'active',
+                    createdAt: new Date(),
+                };
+                await this.canaryManager.startCanary({
+                    genomeId: this.genome.id,
+                    layer: opts.layer,
+                    gene: opts.gene,
+                    stableAllele: currentAllele,
+                    canaryAllele,
+                });
+                return {
+                    applied: false,
+                    reason: `${gateResult.reason} - Canary deployment started (10% traffic)`,
+                    gateResults: {
+                        quality: gateResult.gates.quality,
+                        sandbox: gateResult.gates.sandbox,
+                        economic: gateResult.gates.economic,
+                        stability: gateResult.gates.stability,
+                    },
+                };
+            })() : {
+                applied: false,
+                reason: gateResult.reason,
+                gateResults: {
+                    quality: gateResult.gates.quality,
+                    sandbox: gateResult.gates.sandbox,
+                    economic: gateResult.gates.economic,
+                    stability: gateResult.gates.stability,
+                },
+            };
+            if (result.applied && this.genomeKernel) {
+                try {
+                    this.genomeKernel = new GenomeKernel(this.toGenomeV2(), {
+                        strictMode: false,
+                        autoRollback: false,
+                    });
+                }
+                catch {
+                }
+            }
+            this.metrics.logAudit({
+                level: result.applied ? 'info' : 'warning',
+                component: 'genome',
+                operation: 'mutate',
+                message: result.applied ? 'Mutation applied successfully' : `Mutation rejected: ${result.reason}`,
+                genomeId: this.genome.id,
+                duration: Date.now() - startTime,
+                metadata: {
+                    layer: opts.layer,
+                    gene: opts.gene,
+                    operators: opts.operators,
+                    decision: gateResult.finalDecision,
+                    improvement: 'improvement' in result ? result.improvement : undefined,
+                    gatesPassed: Object.values(gateResult.gates).filter(g => g.passed).length,
+                    totalGates: Object.keys(gateResult.gates).length,
+                },
+            });
+            return result;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err.message : String(err);
+            this.metrics.logAudit({
+                level: 'error',
+                component: 'genome',
+                operation: 'mutate',
+                message: `Mutation failed: ${error}`,
+                genomeId: this.genome.id,
+                duration: Date.now() - startTime,
+                error: {
+                    name: err instanceof Error ? err.name : 'Error',
+                    message: error,
+                    stack: err instanceof Error ? err.stack : undefined,
+                },
+            });
+            throw err;
+        }
+    }
+    async rollback(options) {
+        const { layer, gene, variant } = options;
+        const layerKey = `layer${layer}`;
+        const alleles = this.genome.layers[layerKey];
+        const allele = alleles.find(a => a.gene === gene && a.variant === variant);
+        if (!allele) {
+            throw new Error(`Allele not found: ${gene}:${variant}`);
+        }
+        if (!allele.parentVariant) {
+            throw new Error(`No parent variant to rollback to for ${gene}:${variant}`);
+        }
+        const parentAllele = alleles.find(a => a.gene === gene && a.variant === allele.parentVariant);
+        if (!parentAllele) {
+            throw new Error(`Parent variant not found: ${allele.parentVariant}`);
+        }
+        allele.status = 'retired';
+        parentAllele.status = 'active';
+        if (this.genome.lineage) {
+            this.genome.lineage.mutationOps = [
+                ...(this.genome.lineage.mutationOps || []),
+                'rollback',
+            ];
+        }
+        await this.storage.saveGenome(this.genome);
+        await this.storage.logMutation({
+            genomeId: this.genome.id,
+            layer,
+            gene,
+            variant: parentAllele.variant,
+            mutationType: 'rollback',
+            parentVariant: allele.variant,
+            deployed: true,
+            reason: 'Manual rollback requested',
+            createdAt: new Date(),
+        });
+    }
+    async chatWithMetrics(userMessage, context) {
+        const startTime = Date.now();
+        const content = await this.chat(userMessage, context);
+        const endTime = Date.now();
+        const tokensUsed = Math.ceil((userMessage.length + content.length) / 4);
+        const responseTime = endTime - startTime;
+        const analytics = await this.storage.getAnalytics(this.genome.id);
+        const fitnessScore = analytics.userSatisfaction || 0.5;
+        return {
+            content,
+            metrics: {
+                tokensUsed,
+                responseTime,
+                fitnessScore,
+            },
+        };
+    }
+    async publishGeneToRegistry(gene, variant, description) {
+        if (!this.genome.familyId) {
+            throw new Error('Genome must have familyId to publish to registry');
+        }
+        let allele;
+        let layer = 0;
+        for (const [layerName, alleles] of Object.entries(this.genome.layers)) {
+            allele = alleles.find(a => a.gene === gene && a.variant === variant);
+            if (allele) {
+                layer = parseInt(layerName.replace('layer', ''));
+                break;
+            }
+        }
+        if (!allele) {
+            throw new Error(`Allele not found: ${gene}:${variant}`);
+        }
+        const successRate = allele.fitness;
+        const registryId = `${this.genome.familyId}_${gene}_${variant}_${Date.now()}`;
+        if (this.storage.saveToGeneRegistry) {
+            await this.storage.saveToGeneRegistry({
+                id: registryId,
+                familyId: this.genome.familyId,
+                gene,
+                variant,
+                content: allele.content,
+                layer,
+                fitness: allele.fitness,
+                sampleCount: allele.sampleCount || 0,
+                successRate,
+                metadata: {
+                    sourceGenomeId: this.genome.id,
+                    sourceVersion: this.genome.version || 1,
+                    publishedBy: this.genome.id,
+                    description: description || undefined,
+                },
+                createdAt: new Date(),
+            });
+        }
+        await this.storage.logMutation({
+            genomeId: this.genome.id,
+            layer,
+            gene,
+            variant,
+            mutationType: 'user_feedback',
+            parentVariant: null,
+            deployed: true,
+            reason: `Published to registry: ${description || 'No description'} (fitness: ${successRate})`,
+            createdAt: new Date(),
+        });
+        return registryId;
+    }
+    async inheritGeneFromRegistry(familyId, gene, targetLayer) {
+        if (this.genome.familyId && this.genome.familyId !== familyId) {
+            throw new Error(`Cannot inherit from different family: ${familyId}`);
+        }
+        if (!this.storage.getBestRegistryGene) {
+            throw new Error('Storage adapter does not support Gene Registry queries');
+        }
+        const bestGene = await this.storage.getBestRegistryGene(familyId, gene);
+        if (!bestGene) {
+            throw new Error(`No gene '${gene}' found in registry for family '${familyId}'`);
+        }
+        const layer = targetLayer ?? bestGene.layer ?? 1;
+        await this.addAllele(layer, gene, `inherited_${bestGene.variant}_${Date.now()}`, bestGene.content);
+        if (this.genome.lineage) {
+            this.genome.lineage.mutationOps = [
+                ...(this.genome.lineage.mutationOps || []),
+                `inherit:${gene}:${bestGene.variant}`,
+            ];
+        }
+        this.metrics.logAudit({
+            level: 'info',
+            component: 'genome',
+            operation: 'inherit-gene',
+            message: `Inherited gene '${gene}' (variant: ${bestGene.variant}, fitness: ${bestGene.fitness.toFixed(2)}) from family '${familyId}'`,
+            genomeId: this.genome.id,
+        });
+    }
+    async getEvolutionHealth() {
+        const analytics = await this.storage.getAnalytics(this.genome.id);
+        const allAlleles = [
+            ...this.genome.layers.layer0,
+            ...this.genome.layers.layer1,
+            ...this.genome.layers.layer2,
+        ].filter(a => a.status === 'active');
+        const avgFitness = allAlleles.length > 0
+            ? allAlleles.reduce((sum, a) => sum + a.fitness, 0) / allAlleles.length
+            : 0.5;
+        const generationCount = Math.max(...allAlleles.map(a => a.generation || 0), 0);
+        const warnings = [];
+        if (avgFitness < 0.4)
+            warnings.push('Low average fitness detected');
+        if (analytics.totalMutations > 100 && analytics.avgFitnessImprovement < 0.02) {
+            warnings.push('Mutation plateau detected');
+        }
+        const status = avgFitness >= 0.6 ? 'healthy' :
+            avgFitness >= 0.4 ? 'degraded' : 'critical';
+        return {
+            status,
+            metrics: {
+                avgFitness,
+                mutationRate: analytics.totalMutations / Math.max(analytics.totalInteractions, 1),
+                stabilityScore: analytics.userSatisfaction || 0.5,
+                generationCount,
+            },
+            warnings,
+        };
+    }
+    getIntegrityStatus() {
+        if (!this.genomeKernel)
+            return null;
+        return {
+            active: true,
+            quarantined: this.genomeKernel.isQuarantined(),
+            c0Hash: this.genomeKernel.getC0Hash(),
+            violations: this.genomeKernel.getViolationCount(),
+            snapshotCount: this.genomeKernel.getSnapshots().length,
+            immuneSystem: this.immuneSystem ? {
+                active: true,
+                ...this.immuneSystem.getImmuneStatus(),
+            } : null,
+        };
+    }
+    async getAnalytics() {
+        return this.storage.getAnalytics(this.genome.id);
+    }
+    getGuardrailsReport() {
+        return this.guardrailsManager.getGuardrailsReport();
+    }
+    updateGuardrails(updates) {
+        this.guardrailsManager.updateGuardrails(updates);
+    }
+    async getOptimalModel(userMessage, context) {
+        return this.modelRouter.routeTask({
+            userMessage,
+            context,
+            genomeId: this.genome.id,
+        });
+    }
+    getRoutingAnalytics() {
+        return this.modelRouter.getRoutingAnalytics();
+    }
+    async export() {
+        return this.genome;
+    }
+    async getLearningSummary(userId) {
+        const dna = await this.dnaProfile.getDNA(userId, this.genome.id);
+        const interactions = await this.storage.getRecentInteractions?.(this.genome.id, userId, 50) || [];
+        const recentEvents = [];
+        for (let i = 1; i < Math.min(interactions.length, 10); i++) {
+            const prevDNA = await this.dnaProfile.getDNA(userId, this.genome.id);
+            const events = this.learningAnnouncer.detectLearning(prevDNA, dna);
+            recentEvents.push(...events);
+        }
+        return this.learningAnnouncer.generateLearningSummary(dna, recentEvents);
+    }
+    async getProactiveSuggestions(userId, currentMessage) {
+        return this.proactiveSuggestions.generateSuggestions(userId, this.genome.id, currentMessage);
+    }
+    async getConversationContext(userId) {
+        return this.contextMemory.buildContext(userId, this.genome.id);
+    }
+    getDriftAnalysis() {
+        return this.driftAnalyzer.analyzeDrift();
+    }
+    getSelfAssessment() {
+        return this.selfModel?.assess() ?? null;
+    }
+    getPatterns() {
+        return this.patternMemory?.getPatterns() ?? [];
+    }
+    getPredictions() {
+        return this.patternMemory?.getPredictions() ?? [];
+    }
+    getPreResponseAnalysis(message) {
+        return this.metacognition?.analyzePreResponse(message) ?? null;
+    }
+    getPostResponseAnalysis(message, response, wasSuccessful) {
+        return this.metacognition?.analyzePostResponse(message, response, wasSuccessful) ?? null;
+    }
+    inferEmotion(message) {
+        return this.emotionalModel?.inferEmotion(message) ?? null;
+    }
+    evaluateAutonomy(taskType, riskLevel) {
+        return this.calibratedAutonomy?.evaluate(taskType, riskLevel) ?? null;
+    }
+    recordAutonomyCorrection(taskType, correctionType) {
+        this.calibratedAutonomy?.recordCorrection({
+            taskType,
+            wasAutonomous: true,
+            correctionType,
+            timestamp: new Date(),
+        });
+    }
+    getNarrativeSummary() {
+        return this.personalNarrative?.getSummary() ?? null;
+    }
+    findHistoryCallback(topic) {
+        return this.personalNarrative?.callbackToHistory(topic) ?? null;
+    }
+    queryMemory(question) {
+        return this.analyticMemory?.query(question) ?? null;
+    }
+    getActiveCanaries() {
+        return this.canaryManager.getActiveDeployments()
+            .filter(d => d.genomeId === this.genome.id);
+    }
+    recordMemoryObservation(observation) {
+        this.analyticMemory?.recordObservation(observation);
+    }
+    getIntegratedHealth() {
+        return this.enhancedSelfModel?.assessFull() ?? null;
+    }
+    getOperatingMode() {
+        return this.purposeSurvival?.getMode() ?? null;
+    }
+    getSurvivalStrategy() {
+        return this.purposeSurvival?.getStrategy() ?? null;
+    }
+    getCapabilities() {
+        return this.enhancedSelfModel?.getCapabilities() ?? [];
+    }
+    getTrajectories() {
+        return this.enhancedSelfModel?.getTrajectories() ?? [];
+    }
+    getEvolutionPriorities() {
+        if (!this.strategicAutonomy)
+            return [];
+        const drift = this.driftAnalyzer.analyzeDrift();
+        const health = this.enhancedSelfModel?.assessFull()
+            ?? { score: 0.5, fitnessComponent: 0.5, driftComponent: 1.0,
+                purposeComponent: 0.5, trajectoryComponent: 0.5, label: 'stable' };
+        return this.strategicAutonomy.prioritizeEvolution(drift.signals, health);
+    }
+    getAgentVitals() {
+        if (!this.purposeSurvival || !this.enhancedSelfModel)
+            return null;
+        return computeAgentVitals(this.purposeSurvival, this.enhancedSelfModel);
+    }
+    async runEvolutionCycle() {
+        const autoConfig = this.genome.config.autonomous;
+        const drift = this.driftAnalyzer.analyzeDrift();
+        if (this.purposeSurvival) {
+            const evaluation = this.purposeSurvival.evaluateThreats();
+            if (evaluation.mode === 'critical') {
+                const snapshot = this.purposeSurvival.getLastKnownGood();
+                if (snapshot) {
+                    this.restoreFromSnapshot(snapshot);
+                    return;
+                }
+            }
+            if (evaluation.mode === 'stressed' || evaluation.mode === 'survival') {
+                this.purposeSurvival.snapshotLastKnownGood(this.genome);
+            }
+        }
+        if (autoConfig?.autoMutateOnDrift !== false && drift.isDrifting) {
+            if (this.strategicAutonomy && this.enhancedSelfModel) {
+                const health = this.enhancedSelfModel.assessFull();
+                const priorities = this.strategicAutonomy.prioritizeEvolution(drift.signals, health);
+                for (const priority of priorities.filter(p => p.urgency === 'immediate')) {
+                    if (this.purposeSurvival) {
+                        const currentAllele = this.genome.layers[`layer${priority.layer}`]
+                            ?.find((a) => a.gene === priority.gene && a.status === 'active');
+                        if (currentAllele) {
+                            const check = this.purposeSurvival.purposeFidelityCheck({
+                                gene: priority.gene,
+                                content: currentAllele.content,
+                            });
+                            if (!check.approved)
+                                continue;
+                        }
+                    }
+                    const target = this.driftToMutationTarget({
+                        type: priority.gene, severity: 'moderate',
+                        baselineValue: 0.7, currentValue: 0.5,
+                    });
+                    await this.mutate({
+                        layer: target.layer,
+                        gene: target.gene,
+                        taskType: `strategic-evolve:${priority.reason}`,
+                    });
+                }
+            }
+            else {
+                for (const signal of drift.signals) {
+                    if (signal.severity === 'minor')
+                        continue;
+                    const target = this.driftToMutationTarget(signal);
+                    await this.mutate({
+                        layer: target.layer,
+                        gene: target.gene,
+                        taskType: `auto-evolve:${signal.type}`,
+                    });
+                }
+            }
+        }
+        if (autoConfig?.autoCompressOnPressure !== false) {
+            const totalC1Tokens = this.genome.layers.layer1
+                .filter(a => a.status === 'active')
+                .reduce((sum, a) => sum + estimateTokenCount(a.content), 0);
+            const threshold = this.genome.config.compression?.autoCompressThreshold ?? 1600;
+            if (totalC1Tokens > threshold) {
+                await this.compressGenes();
+            }
+        }
+        await this.evaluateCanaries();
+        if (this.geneBank && (autoConfig?.enableSwarm ?? !!this.geneBank)) {
+            await this.publishHighFitnessGenes();
+        }
+        if (this.genome.familyId && this.storage.getBestRegistryGene && drift.isDrifting) {
+            for (const signal of drift.signals) {
+                if (signal.severity === 'minor')
+                    continue;
+                const target = this.driftToMutationTarget(signal);
+                try {
+                    await this.inheritGeneFromRegistry(this.genome.familyId, target.gene, target.layer);
+                }
+                catch {
+                }
+            }
+        }
+        if (this.geneBank && autoConfig?.enableSwarm && drift.isDrifting) {
+            const targetSeverity = autoConfig.autoImportOnDrift ?? 'severe';
+            const severityRank = (s) => s === 'critical' ? 3 : s === 'major' ? 2 : s === 'moderate' ? 1 : 0;
+            for (const signal of drift.signals) {
+                if (severityRank(signal.severity) >= severityRank(targetSeverity)) {
+                    await this.autoImportGene(signal);
+                }
+            }
+        }
+        this.metrics.logAudit({
+            level: 'info',
+            component: 'genome',
+            operation: 'evolution-cycle',
+            message: `Evolution cycle #${this.interactionCount} completed`,
+            genomeId: this.genome.id,
+            metadata: { isDrifting: drift.isDrifting, signalCount: drift.signals.length },
+        });
+    }
+    computeInteractionQuality(interaction) {
+        if (!interaction.assistantResponse)
+            return 0.2;
+        const response = interaction.assistantResponse;
+        const message = interaction.userMessage;
+        const hasSubstance = response.length > 20 ? 0.3 : response.length / 20 * 0.3;
+        const ratio = message.length > 0 ? response.length / message.length : 1;
+        const efficiencyScore = ratio >= 1 && ratio <= 5 ? 0.25 :
+            ratio > 5 ? Math.max(0, 0.25 - (ratio - 5) * 0.02) :
+                ratio * 0.25;
+        const hasStructure = ((response.includes('\n\n') ? 0.08 : 0) +
+            (response.includes('```') ? 0.08 : 0) +
+            (response.includes('- ') || response.includes('* ') ? 0.05 : 0) +
+            (response.length > 100 ? 0.04 : 0));
+        const userSatisfied = interaction.userSatisfied;
+        const satisfactionScore = userSatisfied === true ? 0.2 :
+            userSatisfied === false ? 0.0 :
+                0.1;
+        return Math.min(1, hasSubstance + efficiencyScore + hasStructure + satisfactionScore);
+    }
+    applyCanaryVariant(prompt, canary) {
+        const canaryAlleleContent = this.genome.layers[`layer${canary.layer}`]
+            ?.find(a => a.variant === canary.canaryVariant)?.content;
+        if (!canaryAlleleContent)
+            return prompt;
+        const stableContent = this.genome.layers[`layer${canary.layer}`]
+            ?.find(a => a.variant === canary.stableVariant)?.content;
+        if (stableContent && prompt.includes(stableContent)) {
+            return prompt.replace(stableContent, canaryAlleleContent);
+        }
+        return prompt + `\n\n## Gene Override (${canary.gene})\n${canaryAlleleContent}`;
+    }
+    estimateQuality(userMessage, response) {
+        let score = 0.5;
+        const len = response.length;
+        if (len > 50 && len < 5000)
+            score += 0.15;
+        else if (len < 20)
+            score -= 0.2;
+        const asksForCode = /write|code|function|implement|create.*class|fix.*bug/i.test(userMessage);
+        if (asksForCode && /```/.test(response))
+            score += 0.15;
+        if (/^#{1,3}\s|^[-*]\s|```/m.test(response))
+            score += 0.1;
+        if (/sorry.*can't|i don't know|as an ai|i cannot/i.test(response))
+            score -= 0.15;
+        const questionWords = new Set(userMessage.toLowerCase().split(/\W+/).filter(w => w.length > 3));
+        if (questionWords.size > 0) {
+            const responseWords = response.toLowerCase().split(/\W+/).filter(w => w.length > 3);
+            const overlap = responseWords.filter(w => questionWords.has(w)).length;
+            const relevanceRatio = Math.min(overlap / questionWords.size, 1);
+            if (relevanceRatio > 0.3)
+                score += 0.05;
+            if (relevanceRatio > 0.6)
+                score += 0.05;
+        }
+        if (/because|therefore|since|this means|the reason|due to/i.test(response) && len > 100) {
+            score += 0.05;
+        }
+        const questionLen = userMessage.length;
+        const ratio = len / Math.max(questionLen, 1);
+        if (ratio > 1 && ratio < 20)
+            score += 0.05;
+        if (ratio > 50)
+            score -= 0.05;
+        const lastChar = response.trim().slice(-1);
+        if (/[.!?)\]`\d]/.test(lastChar))
+            score += 0.03;
+        const codeBlockCount = (response.match(/```/g) || []).length;
+        if (codeBlockCount > 0 && codeBlockCount % 2 !== 0)
+            score -= 0.1;
+        const isTaskOriented = /how|explain|help|show|create|build|fix|setup|install/i.test(userMessage);
+        if (isTaskOriented && /\d\.\s|step\s\d|first.*then|```/i.test(response))
+            score += 0.05;
+        const sentences = response.split(/[.!?]+/).filter(s => s.trim().length > 10);
+        if (sentences.length > 3) {
+            const uniqueSentences = new Set(sentences.map(s => s.trim().toLowerCase()));
+            const repetitionRatio = 1 - (uniqueSentences.size / sentences.length);
+            if (repetitionRatio > 0.3)
+                score -= 0.1;
+        }
+        return Math.max(0, Math.min(1, score));
+    }
+    buildEvolutionEvidence() {
+        const evidence = {};
+        const drift = this.driftAnalyzer.analyzeDrift();
+        if (drift.isDrifting) {
+            evidence.driftSignals = drift.signals.map(s => ({
+                type: s.type,
+                severity: s.severity,
+                currentValue: s.currentValue,
+                baselineValue: s.baselineValue,
+            }));
+        }
+        if (this.enhancedSelfModel) {
+            evidence.health = this.enhancedSelfModel.assessFull();
+            evidence.capabilities = this.enhancedSelfModel.getCapabilities()
+                .filter((c) => c.trend === 'declining' || c.performanceScore < 0.5)
+                .slice(0, 10);
+            evidence.trajectories = this.enhancedSelfModel.getTrajectories()
+                .filter((t) => t.trend === 'declining')
+                .slice(0, 5);
+        }
+        if (this.patternMemory) {
+            evidence.patterns = this.patternMemory.getPatterns()
+                .filter((p) => p.confidence >= 0.6)
+                .slice(0, 8);
+            evidence.predictions = this.patternMemory.getPredictions().slice(0, 3);
+        }
+        if (this.strategicAutonomy) {
+            const mode = this.purposeSurvival?.getMode?.() ?? 'stable';
+            const health = this.enhancedSelfModel?.assessFull() ?? null;
+            evidence.mutationRate = this.strategicAutonomy.recommendMutationRate(mode, health);
+        }
+        if (this.genome.config.autonomous?.agentPurpose) {
+            evidence.purpose = this.genome.config.autonomous.agentPurpose;
+        }
+        return evidence;
+    }
+    async publishHighFitnessGenes() {
+        if (!this.geneBank)
+            return;
+        const threshold = this.genome.config.autonomous?.autoPublishThreshold ?? 0.85;
+        for (const allele of this.genome.layers.layer1.filter(a => a.status === 'active')) {
+            if (allele.fitness >= threshold && !allele.publishedToSwarm) {
+                await this.autoPublishGene(allele).catch(err => this.metrics.logAudit({
+                    level: 'warning',
+                    component: 'gene-bank',
+                    operation: 'auto-publish',
+                    message: `Auto-publish gene failed: ${err instanceof Error ? err.message : String(err)}`,
+                    genomeId: this.genome.id,
+                }));
+            }
+        }
+    }
+    async evaluateCanaries() {
+        const deployments = this.canaryManager.getActiveDeployments();
+        for (const deployment of deployments) {
+            if (deployment.genomeId !== this.genome.id)
+                continue;
+            try {
+                const decision = await this.canaryManager.evaluateCanary(deployment.id);
+                if (decision.action === 'promote') {
+                    const canaryContent = deployment.canaryContent;
+                    if (canaryContent) {
+                        const layerKey = `layer${deployment.layer}`;
+                        const activeAllele = this.genome.layers[layerKey]
+                            .find(a => a.gene === deployment.gene && a.status === 'active');
+                        if (activeAllele) {
+                            activeAllele.status = 'retired';
+                        }
+                        await this.addAllele(deployment.layer, deployment.gene, deployment.canaryVariant, canaryContent);
+                    }
+                    await this.canaryManager.promote(deployment.id);
+                }
+                else if (decision.action === 'rollback') {
+                    await this.canaryManager.rollback(deployment.id, decision.reason);
+                }
+                else if (decision.action === 'ramp-up') {
+                    await this.canaryManager.rampUp(deployment.id);
+                }
+            }
+            catch {
+            }
+        }
+    }
+    driftToMutationTarget(signal) {
+        const mapping = {
+            'quality-decline': { layer: 1, gene: 'coding-patterns' },
+            'efficiency-decline': { layer: 1, gene: 'tool-usage' },
+            'cost-increase': { layer: 1, gene: 'tool-usage' },
+            'intervention-increase': { layer: 1, gene: 'coding-patterns' },
+            'latency-increase': { layer: 1, gene: 'tool-usage' },
+        };
+        return mapping[signal.type] || { layer: 2, gene: 'communication-style' };
+    }
+    async autoPublishGene(allele) {
+        if (!this.geneBank)
+            return;
+        try {
+            const cognitiveGene = {
+                id: `auto_${this.genome.id}_${allele.gene}_${Date.now()}`,
+                version: '1.0.0',
+                name: `${allele.gene} from ${this.genome.name}`,
+                description: `Auto-published ${allele.gene} gene with fitness ${allele.fitness.toFixed(2)}`,
+                type: this.geneCategoryToType(allele.gene),
+                domain: 'general',
+                content: {
+                    instruction: allele.content,
+                    requiredCapabilities: [],
+                    applicableContexts: [],
+                    contraindications: [],
+                    metadata: {},
+                },
+                fitness: {
+                    overallFitness: allele.fitness,
+                    taskSuccessRate: allele.fitness,
+                    tokenEfficiency: 0.7,
+                    responseQuality: allele.fitness,
+                    adoptionCount: 0,
+                    adoptionPerformance: null,
+                },
+                lineage: {
+                    parentGeneId: null,
+                    generation: allele.generation || 0,
+                    ancestors: [],
+                    mutationHistory: [],
+                },
+                tenant: {
+                    tenantId: this.genome.familyId || this.genome.id,
+                    createdBy: this.genome.id,
+                    scope: 'tenant',
+                },
+                tags: [allele.gene],
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+            };
+            await this.geneBank.storeGene(cognitiveGene);
+            allele.publishedToSwarm = true;
+            this.metrics.logAudit({
+                level: 'info',
+                component: 'genome',
+                operation: 'swarm-publish',
+                message: `Auto-published gene ${allele.gene} (fitness: ${allele.fitness.toFixed(2)})`,
+                genomeId: this.genome.id,
+            });
+        }
+        catch {
+        }
+    }
+    async autoImportGene(signal) {
+        if (!this.geneBank)
+            return;
+        const target = this.driftToMutationTarget(signal);
+        const geneTypes = [this.geneCategoryToType(target.gene)];
+        try {
+            const candidates = await this.geneBank.searchGenes({
+                type: geneTypes,
+                minFitness: 0.75,
+                sortBy: 'fitness',
+                sortOrder: 'desc',
+                limit: 1,
+            });
+            if (candidates.length === 0)
+                return;
+            const bestGene = candidates[0];
+            await this.addAllele(target.layer, target.gene, `swarm_${bestGene.id.slice(0, 8)}_${Date.now()}`, bestGene.content.instruction);
+            this.metrics.logAudit({
+                level: 'info',
+                component: 'genome',
+                operation: 'swarm-import',
+                message: `Auto-imported gene ${bestGene.name} for ${signal.type}`,
+                genomeId: this.genome.id,
+            });
+        }
+        catch {
+        }
+    }
+    geneCategoryToType(category) {
+        const mapping = {
+            'tool-usage': 'tool-usage-pattern',
+            'coding-patterns': 'reasoning-pattern',
+            'communication-style': 'communication-pattern',
+        };
+        return mapping[category] || 'reasoning-pattern';
+    }
+    toGenomeV2() {
+        const defaultFitness = {
+            quality: 0.5, successRate: 0.5, tokenEfficiency: 0.5,
+            latency: 1000, costPerSuccess: 0.01, interventionRate: 0.1,
+            composite: 0.5, sampleSize: 0, lastUpdated: new Date(), confidence: 0,
+        };
+        const operations = this.genome.layers.layer1
+            .filter(a => a.status === 'active')
+            .map(a => ({
+            id: `${this.genome.id}_${a.gene}_${a.variant}`,
+            category: a.gene,
+            content: a.content,
+            fitness: defaultFitness,
+            origin: 'initial',
+            usageCount: a.sampleCount || 0,
+            lastUsed: new Date(),
+            successRate: a.fitness || 0.5,
+        }));
+        return {
+            id: this.genome.id,
+            name: this.genome.name,
+            familyId: this.genome.familyId || this.genome.id,
+            version: this.genome.version || 1,
+            chromosomes: {
+                c0: {
+                    identity: {
+                        role: this.genome.layers.layer0[0]?.content || 'AI Assistant',
+                        purpose: 'Genomic self-evolving prompt agent',
+                        constraints: this.genome.layers.layer0.slice(1).map(a => a.content),
+                    },
+                    security: {
+                        forbiddenTopics: [],
+                        accessControls: [],
+                        safetyRules: [],
+                    },
+                    attribution: {
+                        creator: 'GSEP',
+                        copyright: 'GSEP Platform',
+                        license: 'MIT',
+                    },
+                    metadata: {
+                        version: '2.0.0',
+                        createdAt: this.genome.createdAt,
+                    },
+                },
+                c1: {
+                    operations,
+                    metadata: {
+                        lastMutated: new Date(),
+                        mutationCount: 0,
+                        avgFitnessGain: 0,
+                    },
+                },
+                c2: {
+                    userAdaptations: new Map(),
+                    contextPatterns: [],
+                    metadata: {
+                        lastMutated: new Date(),
+                        adaptationRate: 0,
+                        totalUsers: 0,
+                    },
+                },
+            },
+            integrity: {
+                c0Hash: this.genome.c0IntegrityHash || '',
+                lastVerified: new Date(),
+                violations: 0,
+                quarantined: false,
+            },
+            lineage: {
+                parentVersion: this.genome.lineage?.parentVersion,
+                inheritedGenes: [],
+                mutations: [],
+            },
+            fitness: defaultFitness,
+            config: {
+                mutationRate: this.genome.config.mutationRate === 'slow' ? 'conservative' : this.genome.config.mutationRate,
+                epsilonExplore: this.genome.config.epsilonExplore ?? 0.1,
+                enableSandbox: this.genome.config.enableSandbox,
+                fitnessWeights: undefined,
+                minFitnessImprovement: 0.05,
+                enableIntegrityCheck: true,
+                autoRollbackThreshold: 0.15,
+                allowInheritance: true,
+                minCompatibilityScore: 0.6,
+            },
+            state: 'active',
+            tags: [],
+            createdAt: this.genome.createdAt,
+            updatedAt: this.genome.updatedAt,
+        };
+    }
+    toOperativeGene(allele) {
+        const defaultFitness = {
+            quality: allele.fitness, successRate: allele.fitness, tokenEfficiency: 0.5,
+            latency: 1000, costPerSuccess: 0.01, interventionRate: 0.1,
+            composite: allele.fitness, sampleSize: 0, lastUpdated: new Date(), confidence: 0,
+        };
+        return {
+            id: `${this.genome.id}_${allele.gene}_${allele.variant}`,
+            category: allele.gene,
+            content: allele.content,
+            fitness: defaultFitness,
+            origin: 'initial',
+            usageCount: 0,
+            lastUsed: new Date(),
+            successRate: allele.fitness,
+            tokenCount: estimateTokenCount(allele.content),
+        };
+    }
+    async compressGenes() {
+        const emptyResult = { compressed: false, totalOriginalTokens: 0, totalCompressedTokens: 0, tokensSaved: 0, reductionPercent: 0 };
+        const compressionOperator = this.mutationEngine.getOperator('compress_instructions');
+        if (!compressionOperator)
+            return emptyResult;
+        const compressionConfig = this.genome.config.compression;
+        const maxRatio = compressionConfig?.maxCompressionRatio ?? 0.3;
+        const context = {
+            genome: this.toGenomeV2(),
+            targetChromosome: 'c1',
+            reason: 'Token compression: optimize gene token usage while preserving functionality',
+        };
+        const result = await compressionOperator.mutate(context);
+        if (!result.success || !result.compressionMetrics)
+            return emptyResult;
+        const metrics = result.compressionMetrics;
+        if (metrics.ratio < maxRatio) {
+            return emptyResult;
+        }
+        const gateResult = await this.guardrailsManager.evaluateCandidate({
+            layer: 1,
+            gene: 'compression',
+            variant: `compressed_v${Date.now()}`,
+            content: JSON.stringify(result.mutant.chromosomes.c1.operations.map(g => g.content)),
+            fitness: result.expectedImprovement + 0.5,
+            sandboxScore: 0.8,
+            sampleCount: 0,
+            rollbackCount: 0,
+        }, this.genome.id);
+        if (gateResult.finalDecision === 'reject') {
+            return emptyResult;
+        }
+        const minFitness = compressionConfig?.minFitnessForCompression ?? 0.3;
+        for (const operation of result.mutant.chromosomes.c1.operations) {
+            const allele = this.genome.layers.layer1.find(a => a.gene === operation.category && a.status === 'active');
+            if (allele && allele.fitness >= minFitness) {
+                allele.content = operation.content;
+            }
+        }
+        return {
+            compressed: true,
+            totalOriginalTokens: metrics.originalTokens,
+            totalCompressedTokens: metrics.compressedTokens,
+            tokensSaved: metrics.originalTokens - metrics.compressedTokens,
+            reductionPercent: Math.round((1 - metrics.ratio) * 100),
+        };
+    }
+    getMutationStrategy() {
+        const context = {
+            genome: this.toGenomeV2(),
+            targetChromosome: 'c1',
+            reason: 'Strategy analysis',
+            evidence: (() => {
+                const drift = this.driftAnalyzer.analyzeDrift();
+                return drift.isDrifting
+                    ? { driftSignals: drift.signals.map(s => ({ type: s.type, severity: s.severity })) }
+                    : undefined;
+            })(),
+        };
+        return this.mutationEngine.selectMutationStrategy(context).map(s => ({
+            operator: s.operator.name,
+            score: s.score,
+            reason: s.reason,
+        }));
+    }
+    restoreFromSnapshot(snapshot) {
+        for (const saved of snapshot.alleles) {
+            const layerKey = `layer${saved.layer}`;
+            const allele = this.genome.layers[layerKey].find((a) => a.gene === saved.gene && a.status === 'active');
+            if (allele) {
+                allele.content = saved.content;
+                allele.fitness = saved.fitness;
+            }
+        }
+        this.storage.saveGenome(this.genome).catch(err => this.metrics.logAudit({
+            level: 'error',
+            component: 'genome',
+            operation: 'emergency-rollback-save',
+            message: `Failed to persist rollback: ${err instanceof Error ? err.message : String(err)}`,
+            genomeId: this.genome.id,
+        }));
+        this.metrics.logAudit({
+            level: 'warning',
+            component: 'genome',
+            operation: 'emergency-rollback',
+            message: `Restored from snapshot taken at ${snapshot.timestamp.toISOString()}`,
+            genomeId: this.genome.id,
+        });
+    }
+    extractTopicsFromMessage(message) {
+        const TECH_TERMS = [
+            'typescript', 'javascript', 'python', 'rust', 'go', 'java', 'c++', 'ruby', 'php', 'swift',
+            'react', 'vue', 'angular', 'svelte', 'nextjs', 'node', 'deno', 'bun',
+            'docker', 'kubernetes', 'aws', 'azure', 'gcp', 'terraform', 'ci/cd',
+            'sql', 'postgres', 'mongodb', 'redis', 'graphql', 'rest', 'grpc',
+            'machine learning', 'ai', 'llm', 'neural network', 'deep learning',
+            'security', 'authentication', 'oauth', 'jwt', 'encryption',
+            'testing', 'vitest', 'jest', 'cypress', 'playwright',
+            'git', 'github', 'linux', 'nginx', 'webpack', 'vite',
+        ];
+        const lower = message.toLowerCase();
+        return TECH_TERMS.filter(term => lower.includes(term));
+    }
+}
+//# sourceMappingURL=PGA.js.map