@pga-ai/core 0.4.0 → 0.8.0

package/dist/PGA.js

@@ -1,3 +1,4 @@
+import { WrappedAgent } from './wrap/WrappedAgent.js';
 import { GenomeManager } from './core/GenomeManager.js';
 import { PromptAssembler } from './core/PromptAssembler.js';
 import { DNAProfile } from './core/DNAProfile.js';
@@ -11,6 +12,28 @@ 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 { 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 { ContentFirewall } from './firewall/ContentFirewall.js';
 export class PGA {
     pgaConfig;
     genomeManager;
@@ -19,6 +42,30 @@ export class PGA {
     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 '@pga-ai/core';\n`
+                + `  import { ClaudeAdapter } from '@pga-ai/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`
+                + `  - @pga-ai/adapters-llm-anthropic (Claude)\n`
+                + `  - @pga-ai/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 '@pga-ai/core';\n\n`
+                + `  const pga = new PGA({\n`
+                + `    llm: yourLLMAdapter,\n`
+                + `    storage: new InMemoryStorage(),\n`
+                + `  });\n\n`
+                + `For production, use: @pga-ai/adapters-storage-postgres`);
+        }
         this.llm = pgaConfig.llm;
         this.genomeManager = new GenomeManager(pgaConfig.storage);
         this.metricsCollector = new MetricsCollector(pgaConfig.monitoring || {
@@ -39,7 +86,7 @@ export class PGA {
             level: 'info',
             component: 'pga',
             operation: 'initialize',
-            message: 'PGA system initialized successfully',
+            message: 'GSEP system initialized successfully',
         });
     }
     getMetrics() {
@@ -65,7 +112,7 @@ export class PGA {
             level: 'info',
             component: 'pga',
             operation: 'shutdown',
-            message: 'PGA system shutdown',
+            message: 'GSEP system shutdown',
         });
     }
     async createGenome(options) {
@@ -88,13 +135,27 @@ export class PGA {
                 ...options.config,
             },
         });
-        return new GenomeInstance(genome, this.llm, this.pgaConfig.storage, this.metricsCollector, this.pgaConfig.modelRouter, this.pgaConfig.rag, this.pgaConfig.reasoning);
+        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);
+        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();
@@ -102,11 +163,21 @@ export class PGA {
     async deleteGenome(genomeId) {
         await this.genomeManager.deleteGenome(genomeId);
     }
+    static async wrap(target, options) {
+        if (typeof target === 'function') {
+            if (!options.name) {
+                throw new Error('PGA.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;
@@ -117,10 +188,27 @@ export class GenomeInstance {
     metrics;
     ragEngine;
     reasoningEngine;
-    constructor(genome, llm, storage, metrics, modelRouterConfig, ragConfig, reasoningConfig) {
+    fitnessTracker;
+    fitnessCalculator;
+    mutationEngine;
+    driftAnalyzer;
+    selfModel;
+    patternMemory;
+    metacognition;
+    emotionalModel;
+    calibratedAutonomy;
+    personalNarrative;
+    analyticMemory;
+    canaryManager;
+    enhancedSelfModel;
+    purposeSurvival;
+    strategicAutonomy;
+    interactionCount = 0;
+    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();
@@ -135,7 +223,67 @@ export class GenomeInstance {
         if (genome.config.reasoning?.enabled) {
             this.reasoningEngine = new ReasoningEngine(llm, reasoningConfig);
         }
-        new FitnessTracker(storage, genome);
+        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);
+        }
+        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.firewall?.enabled !== false) {
+            const firewall = new ContentFirewall();
+            this.assembler.setFirewall(firewall);
+        }
     }
     get id() {
         return this.genome.id;
@@ -145,7 +293,7 @@ export class GenomeInstance {
     }
     getWelcomeMessage(style = 'detailed') {
         const messages = {
-            short: `🧬 I now have PGA — Genomic Self-Evolving Prompts integrated into my DNA!
+            short: `🧬 I now have GSEP — Genomic Self-Evolving Prompts integrated into my DNA!
 
 This means I can:
 ✓ Learn from every interaction
@@ -153,7 +301,7 @@ This means I can:
 ✓ Improve continuously without manual updates
 
 I'm ready to evolve with you!`,
-            detailed: `🧬 Great news! I now have PGA — Genomic Self-Evolving Prompts integrated into my core system!
+            detailed: `🧬 Great news! I now have GSEP — Genomic Self-Evolving Prompts integrated into my core system!
 
 What this means for you:
 
@@ -179,7 +327,7 @@ What this means for you:
    4. You'll notice me getting better at understanding your needs
 
 Let's evolve together! How can I help you today?`,
-            technical: `🧬 System Update: PGA (Genomic Self-Evolving Prompts) — ACTIVE
+            technical: `🧬 System Update: GSEP (Genomic Self-Evolving Prompts) — ACTIVE
 
 **Architecture Overview:**
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
@@ -211,7 +359,7 @@ Every interaction contributes to:
 4. Performance optimization
 
 System ready. Genomic evolution: INITIALIZED.`,
-            casual: `🧬 Hey! Exciting update — I just got upgraded with PGA (think of it as evolutionary AI)!
+            casual: `🧬 Hey! Exciting update — I just got upgraded with GSEP (think of it as evolutionary AI)!
 
 Here's the cool part:
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
@@ -240,6 +388,10 @@ Ready to see what we can do together? 😊`,
         return this.assembler.assemblePrompt(context, currentMessage);
     }
     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.`);
+        }
         const requestId = `chat_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
         const startTime = Date.now();
         let error;
@@ -249,6 +401,16 @@ Ready to see what we can do together? 😊`,
                 const ragContext = await this.ragEngine.augment(userMessage, prompt);
                 prompt = ragContext.augmentedPrompt;
             }
+            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 response;
             if (this.reasoningEngine) {
                 const reasoningResult = await this.reasoningEngine.reason(userMessage, prompt, this.genome.config.reasoning?.defaultStrategy);
@@ -283,6 +445,56 @@ Ready to see what we can do together? 😊`,
                     outputTokens,
                 },
             });
+            const quality = this.estimateQuality(userMessage, response.content);
+            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 (autoConfig?.continuousEvolution && this.interactionCount % (autoConfig.evolveEveryN ?? 10) === 0) {
+                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,
+                }));
+            }
             if (context.userId) {
                 const previousDNA = await this.dnaProfile.getDNA(context.userId, this.genome.id);
                 await this.recordInteraction({
@@ -338,6 +550,114 @@ Ready to see what we can do together? 😊`,
         };
         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 && interaction.taskType) {
+            this.analyticMemory.recordObservation({
+                subject: interaction.userId,
+                action: 'performed',
+                object: interaction.taskType,
+                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(() => { });
+                }
+            }
+        }
+    }
+    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 (autoConfig?.continuousEvolution && this.interactionCount % (autoConfig.evolveEveryN ?? 10) === 0) {
+            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,
+            }));
+        }
+        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);
@@ -395,12 +715,34 @@ Ready to see what we can do together? 😊`,
                 };
             }
             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: currentAllele.content,
-                fitness: currentAllele.fitness + 0.05,
+                content: mutatedContent,
+                fitness: currentAllele.fitness + expectedImprovement,
                 sandboxScore: 0.75,
                 sampleCount: currentAllele.sampleCount || 0,
                 rollbackCount: 0,
@@ -416,16 +758,33 @@ Ready to see what we can do together? 😊`,
                     economic: gateResult.gates.economic,
                     stability: gateResult.gates.stability,
                 },
-            } : gateResult.finalDecision === 'canary' ? {
-                applied: false,
-                reason: `${gateResult.reason} - Canary deployment not yet implemented`,
-                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: {
@@ -447,7 +806,7 @@ Ready to see what we can do together? 😊`,
                     gene: opts.gene,
                     operators: opts.operators,
                     decision: gateResult.finalDecision,
-                    improvement: result.improvement,
+                    improvement: 'improvement' in result ? result.improvement : undefined,
                     gatesPassed: Object.values(gateResult.gates).filter(g => g.passed).length,
                     totalGates: Object.keys(gateResult.gates).length,
                 },
@@ -543,6 +902,26 @@ Ready to see what we can do together? 😊`,
         }
         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,
@@ -560,8 +939,28 @@ Ready to see what we can do together? 😊`,
         if (this.genome.familyId && this.genome.familyId !== familyId) {
             throw new Error(`Cannot inherit from different family: ${familyId}`);
         }
-        throw new Error(`Gene Registry inheritance under development - ` +
-            `will inherit gene '${gene}' from family '${familyId}' to layer ${targetLayer ?? 'auto'}`);
+        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);
@@ -632,5 +1031,596 @@ Ready to see what we can do together? 😊`,
     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;
+        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(() => { });
+            }
+        }
+    }
+    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 layerKey = `layer${deployment.layer}`;
+                    const canaryContent = this.genome.layers[layerKey]
+                        ?.find(a => a.variant === deployment.canaryVariant)?.content;
+                    if (canaryContent) {
+                        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(() => { });
+        this.metrics.logAudit({
+            level: 'warning',
+            component: 'genome',
+            operation: 'emergency-rollback',
+            message: `Restored from snapshot taken at ${snapshot.timestamp.toISOString()}`,
+            genomeId: this.genome.id,
+        });
+    }
 }
 //# sourceMappingURL=PGA.js.map