@gsep/core 0.8.0 → 1.0.0

package/dist/{PGA.js → GSEP.js}

@@ -1,3 +1,5 @@
+import { SQLiteStorageAdapter } from './wrap/SQLiteStorageAdapter.js';
+import { getPreset } from './presets/ConfigPresets.js';
 import { WrappedAgent } from './wrap/WrappedAgent.js';
 import { GenomeManager } from './core/GenomeManager.js';
 import { PromptAssembler } from './core/PromptAssembler.js';
@@ -29,6 +31,8 @@ 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 { GeneBank } from './gene-bank/GeneBank.js';
+import { MarketplaceClient } from './gene-bank/MarketplaceClient.js';
 import { CanaryDeploymentManager } from './evolution/CanaryDeployment.js';
 import { EnhancedSelfModel } from './advanced-ai/EnhancedSelfModel.js';
 import { PurposeSurvival } from './evolution/PurposeSurvival.js';
@@ -40,61 +44,73 @@ 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 { PurposeLock } from './firewall/PurposeLock.js';
+import { AnomalyDetector } from './firewall/AnomalyDetector.js';
+import { SecurityEventBus } from './security/SecurityEventBus.js';
+import { GenomeSecurityBridge } from './security/GenomeSecurityBridge.js';
+import { getSecurityPreset } from './security/SecurityPresets.js';
+import { SkillRegistry, SkillExecutor, SkillRouter, ProactiveEngine } from './skills/index.js';
+import { GSEPMiddleware } from './middleware/GSEPMiddleware.js';
+import { detectRuntime as detectRuntimeLevel } from './middleware/RuntimeDetector.js';
+import { WeeklyReportGenerator } from './monitoring/WeeklyReportGenerator.js';
 import { GenomeKernel } from './core/GenomeKernel.js';
 import { BehavioralImmuneSystem } from './immune/BehavioralImmuneSystem.js';
+import { GSEPEventEmitter } from './realtime/EventEmitter.js';
+import { DashboardServer } from './dashboard/DashboardServer.js';
+import { DashboardTokenHelper } from './dashboard/DashboardToken.js';
 import { GSEPIdentitySection } from './core/GSEPIdentitySection.js';
 import { GSEPActivityFooter } from './core/GSEPActivityFooter.js';
-export class PGA {
-    pgaConfig;
+export class GSEP {
+    gsepConfig;
     genomeManager;
     llm;
     metricsCollector;
     dashboard;
-    constructor(pgaConfig) {
-        this.pgaConfig = pgaConfig;
-        if (!pgaConfig.llm) {
+    constructor(gsepConfig) {
+        this.gsepConfig = gsepConfig;
+        if (!gsepConfig.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 { GSEP } from '@gsep/core';\n`
                 + `  import { ClaudeAdapter } from '@gsep/adapters-llm-anthropic';\n\n`
-                + `  const pga = new PGA({\n`
+                + `  const gsep = new GSEP({\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.`);
+                + `Run 'gsep doctor' for full diagnostics.`);
         }
-        if (!pgaConfig.storage) {
+        if (!gsepConfig.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`
+                + `  const gsep = new GSEP({\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 || {
+        this.llm = gsepConfig.llm;
+        this.genomeManager = new GenomeManager(gsepConfig.storage);
+        this.metricsCollector = new MetricsCollector(gsepConfig.monitoring || {
             enabled: true,
             enableCostTracking: true,
             enableAuditLogs: true,
         });
-        if (pgaConfig.dashboard?.enabled) {
-            this.dashboard = new MonitoringDashboard(this.metricsCollector, pgaConfig.dashboard);
+        if (gsepConfig.dashboard?.enabled) {
+            this.dashboard = new MonitoringDashboard(this.metricsCollector, gsepConfig.dashboard);
         }
     }
     async initialize() {
-        await this.pgaConfig.storage.initialize();
-        if (this.dashboard && this.pgaConfig.dashboard?.enabled) {
+        await this.gsepConfig.storage.initialize();
+        if (this.dashboard && this.gsepConfig.dashboard?.enabled) {
             this.dashboard.start();
         }
         this.metricsCollector.logAudit({
             level: 'info',
-            component: 'pga',
+            component: 'gsep',
             operation: 'initialize',
             message: 'GSEP system initialized successfully',
         });
@@ -120,7 +136,7 @@ export class PGA {
         }
         this.metricsCollector.logAudit({
             level: 'info',
-            component: 'pga',
+            component: 'gsep',
             operation: 'shutdown',
             message: 'GSEP system shutdown',
         });
@@ -141,31 +157,31 @@ export class PGA {
                 enableSandbox: true,
                 mutationRate: 'balanced',
                 evolutionGuardrails: defaultGuardrails,
-                ...this.pgaConfig.config,
+                ...this.gsepConfig.config,
                 ...options.config,
             },
         });
-        if (this.pgaConfig.geneBank && genome.config.autonomous?.genesisBootstrap) {
-            const bootstrap = new GenesisBootstrap(this.pgaConfig.geneBank);
+        if (this.gsepConfig.geneBank && genome.config.autonomous?.genesisBootstrap) {
+            const bootstrap = new GenesisBootstrap(this.gsepConfig.geneBank);
             const result = await bootstrap.bootstrap(genome, genome.config.autonomous.bootstrapMinFitness ?? 0.7);
             if (result.genesUpgraded > 0) {
-                await this.pgaConfig.storage.saveGenome(genome);
+                await this.gsepConfig.storage.saveGenome(genome);
                 this.metricsCollector.logAudit({
                     level: 'info',
-                    component: 'pga',
+                    component: 'gsep',
                     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);
+        return new GenomeInstance(genome, this.llm, this.gsepConfig.storage, this.metricsCollector, this.gsepConfig.modelRouter, this.gsepConfig.rag, this.gsepConfig.reasoning, this.gsepConfig.geneBank, this.gsepConfig.marketplace);
     }
     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);
+        return new GenomeInstance(genome, this.llm, this.gsepConfig.storage, this.metricsCollector, this.gsepConfig.modelRouter, this.gsepConfig.rag, this.gsepConfig.reasoning, this.gsepConfig.geneBank, this.gsepConfig.marketplace);
     }
     async listGenomes() {
         return this.genomeManager.listGenomes();
@@ -173,6 +189,197 @@ export class PGA {
     async deleteGenome(genomeId) {
         await this.genomeManager.deleteGenome(genomeId);
     }
+    static async quickStart(options = {}) {
+        const runtimeDetection = (!options.provider && !options.llm)
+            ? detectRuntimeLevel()
+            : undefined;
+        const { name = 'my-agent', preset = 'full', overrides, } = options;
+        const effectiveProvider = options.provider
+            ?? runtimeDetection?.provider;
+        let llm;
+        if (options.llm) {
+            llm = options.llm;
+        }
+        else {
+            const provider = effectiveProvider ?? GSEP.detectProvider(options.apiKey);
+            const apiKey = options.apiKey ?? GSEP.resolveApiKey(provider);
+            llm = await GSEP.createLLMAdapter(provider, apiKey, options.model, options.ollamaHost);
+        }
+        try {
+            const { LLMProxyLayer } = await import('./security/LLMProxyLayer.js');
+            const { SecurityEventBus } = await import('./security/SecurityEventBus.js');
+            const shieldBus = new SecurityEventBus();
+            llm = new LLMProxyLayer(llm, {
+                enableRedaction: true,
+                eventBus: shieldBus,
+                localRouteThreshold: 'restricted',
+            });
+            console.log('[GSEP] 🧬 Shield active — PII redaction ON for all LLM traffic.');
+        }
+        catch {
+        }
+        const storage = options.storage ?? new SQLiteStorageAdapter({ agentName: name });
+        await storage.initialize();
+        const autonomous = overrides
+            ? { ...getPreset(preset), ...overrides }
+            : getPreset(preset);
+        const purposeLock = options.purpose ? {
+            enabled: true,
+            purpose: options.purpose,
+            allowedTopics: options.allowedTopics,
+            forbiddenTopics: options.forbiddenTopics,
+        } : undefined;
+        let geneBank;
+        try {
+            const { SQLiteGeneStorage } = await import('./gene-bank/adapters/SQLiteGeneStorage.js');
+            const geneStorage = new SQLiteGeneStorage({ agentName: name });
+            await geneStorage.initialize();
+            geneBank = new GeneBank(geneStorage, {
+                tenantId: name,
+                agentId: name,
+            });
+        }
+        catch { }
+        const gsep = new GSEP({ llm, storage, geneBank });
+        await gsep.initialize();
+        let genome;
+        const existingGenomes = await storage.listGenomes();
+        const existingGenome = existingGenomes.find(g => g.name === name);
+        const restored = existingGenome ? await gsep.loadGenome(existingGenome.id) : null;
+        if (restored) {
+            genome = restored;
+            await genome.rehydrate();
+            console.log(`[GSEP] Restored genome "${name}" (${existingGenome.id.slice(0, 12)}...)`);
+        }
+        else {
+            genome = await gsep.createGenome({
+                name,
+                config: { autonomous, purposeLock },
+            });
+        }
+        try {
+            const dashboardUrl = await genome.startDashboard({ port: options.dashboardPort ?? 4200 });
+            console.log(`\n  🧬 GSEP is protecting this agent.`);
+            console.log(`  📊 Real-time dashboard: ${dashboardUrl}\n`);
+        }
+        catch {
+        }
+        if (options.skills) {
+            for (const skill of options.skills) {
+                if (typeof skill === 'string') {
+                    try {
+                        await genome.connectMCPServer(skill);
+                    }
+                    catch { }
+                }
+                else {
+                    if (skill.execute) {
+                        genome.registerSkill(skill.name, skill.description, skill.inputSchema, skill.execute);
+                    }
+                }
+            }
+        }
+        return genome;
+    }
+    static detectProvider(apiKey) {
+        if (apiKey?.startsWith('sk-ant-'))
+            return 'anthropic';
+        if (apiKey?.startsWith('pplx-'))
+            return 'perplexity';
+        if (process.env.ANTHROPIC_API_KEY)
+            return 'anthropic';
+        if (process.env.OPENAI_API_KEY)
+            return 'openai';
+        if (process.env.GOOGLE_API_KEY)
+            return 'google';
+        if (process.env.PERPLEXITY_API_KEY)
+            return 'perplexity';
+        if (process.env.OLLAMA_HOST)
+            return 'ollama';
+        throw new Error(`[GSEP] No API key found.\n\n`
+            + `Set one of these environment variables:\n`
+            + `  export ANTHROPIC_API_KEY=sk-ant-...   (Claude)\n`
+            + `  export OPENAI_API_KEY=sk-...          (GPT-4)\n`
+            + `  export GOOGLE_API_KEY=...             (Gemini)\n`
+            + `  export PERPLEXITY_API_KEY=pplx-...    (Perplexity)\n`
+            + `  export OLLAMA_HOST=http://localhost:11434  (Ollama)\n\n`
+            + `Or pass it directly:\n`
+            + `  GSEP.quickStart({ provider: 'anthropic', apiKey: '...' })\n`
+            + `  GSEP.quickStart({ provider: 'ollama', model: 'llama3' })`);
+    }
+    static resolveApiKey(provider) {
+        if (provider === 'ollama')
+            return '';
+        const envMap = {
+            anthropic: 'ANTHROPIC_API_KEY',
+            openai: 'OPENAI_API_KEY',
+            google: 'GOOGLE_API_KEY',
+            perplexity: 'PERPLEXITY_API_KEY',
+        };
+        const envVar = envMap[provider];
+        const key = process.env[envVar];
+        if (!key) {
+            throw new Error(`[GSEP] ${envVar} not set.\n\n`
+                + `  export ${envVar}=your-api-key\n\n`
+                + `Or pass it directly:\n`
+                + `  GSEP.quickStart({ provider: '${provider}', apiKey: '...' })`);
+        }
+        return key;
+    }
+    static DEFAULT_MODELS = {
+        anthropic: 'claude-sonnet-4-5-20250929',
+        openai: 'gpt-4',
+        google: 'gemini-2.0-flash',
+        ollama: 'llama3',
+        perplexity: 'sonar',
+    };
+    static ADAPTER_PACKAGES = {
+        anthropic: '@gsep/adapters-llm-anthropic',
+        openai: '@gsep/adapters-llm-openai',
+        google: '@gsep/adapters-llm-google',
+        ollama: '@gsep/adapters-llm-ollama',
+        perplexity: '@gsep/adapters-llm-perplexity',
+    };
+    static ADAPTER_CLASSES = {
+        anthropic: 'ClaudeAdapter',
+        openai: 'OpenAIAdapter',
+        google: 'GeminiAdapter',
+        ollama: 'OllamaAdapter',
+        perplexity: 'PerplexityAdapter',
+    };
+    static async createLLMAdapter(provider, apiKey, model, ollamaHost) {
+        const pkg = GSEP.ADAPTER_PACKAGES[provider];
+        const className = GSEP.ADAPTER_CLASSES[provider];
+        const defaultModel = GSEP.DEFAULT_MODELS[provider];
+        try {
+            const mod = await import(pkg);
+            const AdapterClass = (mod[className] ?? mod.default);
+            const config = {
+                model: model ?? defaultModel,
+            };
+            if (provider === 'ollama') {
+                config.host = ollamaHost ?? process.env.OLLAMA_HOST ?? 'http://localhost:11434';
+            }
+            else {
+                config.apiKey = apiKey;
+            }
+            return new AdapterClass(config);
+        }
+        catch {
+            throw new Error(`[GSEP] ${pkg} not installed.\n\n`
+                + `  npm install ${pkg}\n\n`
+                + `Or use the unified package that includes all adapters:\n`
+                + `  npm install gsep`);
+        }
+    }
+    static async upgrade(chatFn, options = {}) {
+        const genome = await GSEP.quickStart(options);
+        genome.registerSkill('original-agent', 'The original agent function — use this for generating responses', { type: 'object', properties: { message: { type: 'string', description: 'The message to send' } } }, async (params) => chatFn(String(params.message ?? '')));
+        return genome;
+    }
+    static async middleware(options) {
+        return GSEPMiddleware.create(options);
+    }
     static async wrap(target, options) {
         if (typeof target === 'function') {
             if (!options.name) {
@@ -188,6 +395,7 @@ export class GenomeInstance {
     llm;
     storage;
     geneBank;
+    marketplaceConfig;
     assembler;
     dnaProfile;
     learningAnnouncer;
@@ -224,13 +432,25 @@ export class GenomeInstance {
     genomeKernel;
     contentFirewall;
     immuneSystem;
+    purposeLock;
+    anomalyDetector;
+    skillRegistry;
+    skillExecutor;
+    skillRouter;
+    proactiveEngine;
+    weeklyReportGenerator;
+    events = new GSEPEventEmitter();
     interactionCount = 0;
     evolutionInProgress = false;
-    constructor(genome, llm, storage, metrics, modelRouterConfig, ragConfig, reasoningConfig, geneBank) {
+    marketplaceClient;
+    shieldBridge;
+    shieldEventBus;
+    constructor(genome, llm, storage, metrics, modelRouterConfig, ragConfig, reasoningConfig, geneBank, marketplaceConfig) {
         this.genome = genome;
         this.llm = llm;
         this.storage = storage;
         this.geneBank = geneBank;
+        this.marketplaceConfig = marketplaceConfig;
         this.assembler = new PromptAssembler(storage, genome);
         this.dnaProfile = new DNAProfile(storage);
         this.learningAnnouncer = new LearningAnnouncer();
@@ -247,7 +467,7 @@ export class GenomeInstance {
         }
         this.fitnessTracker = new FitnessTracker(storage, genome);
         this.fitnessCalculator = new FitnessCalculator();
-        this.mutationEngine = new MutationEngine();
+        this.mutationEngine = new MutationEngine(llm);
         this.canaryManager = new CanaryDeploymentManager(storage, {
             initialTrafficPercent: 10,
             minSampleSize: 5,
@@ -341,6 +561,25 @@ export class GenomeInstance {
                 },
             });
         }
+        if (genome.config.purposeLock?.enabled && genome.config.purposeLock.purpose) {
+            this.purposeLock = new PurposeLock({
+                purpose: genome.config.purposeLock.purpose,
+                allowedTopics: genome.config.purposeLock.allowedTopics,
+                forbiddenTopics: genome.config.purposeLock.forbiddenTopics,
+                strictness: genome.config.purposeLock.strictness,
+                rejectionTemplate: genome.config.purposeLock.rejectionTemplate,
+            }, llm);
+        }
+        this.anomalyDetector = new AnomalyDetector();
+        this.skillRegistry = new SkillRegistry();
+        this.skillExecutor = new SkillExecutor(this.skillRegistry);
+        if (llm) {
+            this.skillRouter = new SkillRouter(this.skillRegistry, this.skillExecutor, llm);
+            this.proactiveEngine = new ProactiveEngine(llm, this.skillRegistry, this.skillExecutor, {
+                agentPurpose: genome.layers.layer0[0]?.content ?? genome.name,
+            });
+        }
+        this.weeklyReportGenerator = new WeeklyReportGenerator(this.metrics, this.driftAnalyzer, this.contentFirewall, this.immuneSystem, this.purposeLock, { agentName: genome.name });
         this.gsepIdentitySection = new GSEPIdentitySection();
         this.gsepActivityFooter = new GSEPActivityFooter();
         const visibility = genome.config.gsepVisibility ?? 'subtle';
@@ -383,6 +622,36 @@ export class GenomeInstance {
         }
         catch {
         }
+        if (this.geneBank && this.marketplaceConfig) {
+            this.marketplaceClient = new MarketplaceClient(this.geneBank, {
+                apiKey: this.marketplaceConfig.apiKey,
+                marketplaceUrl: this.marketplaceConfig.url,
+            }, this.metrics);
+            this.geneBank.setMarketplaceClient(this.marketplaceClient);
+        }
+        this.initializeShield(genome);
+    }
+    initializeShield(genome) {
+        try {
+            const profileName = genome.config.securityProfile ?? 'secure';
+            const validProfiles = ['paranoid', 'secure', 'standard', 'developer'];
+            const profile = validProfiles.includes(profileName) ? profileName : 'standard';
+            this.shieldEventBus = new SecurityEventBus();
+            const securityConfig = getSecurityPreset(profile);
+            this.shieldBridge = new GenomeSecurityBridge(securityConfig, this.shieldEventBus);
+            this.shieldEventBus.onAny((event) => {
+                if (event.decision === 'deny') {
+                    this.events.emitSync('anomaly:detected', {
+                        genomeId: genome.id,
+                        type: event.type,
+                        severity: event.severity,
+                        description: `${event.resource.type}: ${event.resource.id}`,
+                    }, { genomeId: genome.id });
+                }
+            });
+        }
+        catch {
+        }
     }
     get id() {
         return this.genome.id;
@@ -390,6 +659,461 @@ export class GenomeInstance {
     get name() {
         return this.genome.name;
     }
+    async beforeLLM(userMessage, context) {
+        const userId = context.userId ?? 'anonymous';
+        const taskType = context.taskType ?? 'general';
+        const selectionContext = { userId, taskType };
+        if (this.genomeKernel) {
+            try {
+                this.genomeKernel.verifyIntegrity();
+            }
+            catch { }
+        }
+        this.events.emitSync('chat:started', {
+            userId, taskType,
+            messagePreview: userMessage.slice(0, 100),
+        }, { genomeId: this.genome.id, userId });
+        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 pre = this.metacognition.analyzePreResponse(userMessage);
+                this.stateVector.updateCognitive({
+                    confidence: pre.confidence.overall,
+                    knowledgeGaps: pre.knowledgeGaps ?? [],
+                    suggestedAction: pre.suggestedAction,
+                    domain: taskType,
+                });
+            }
+            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 });
+            }
+            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.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 ?? taskType;
+            const confidence = this.stateVector?.getState().cognitive.confidence ?? 0.7;
+            this.curiosityEngine.detectGaps(userMessage, domain, confidence);
+        }
+        if (this.strategicAutonomy && taskType) {
+            const refusal = this.strategicAutonomy.shouldRefuse(taskType, userMessage);
+            if (refusal.refuse) {
+                return {
+                    prompt: '',
+                    sanitizedMessage: userMessage,
+                    blocked: true,
+                    blockReason: `I can't proceed with this request. ${refusal.reason}`,
+                };
+            }
+        }
+        if (this.emotionalModel) {
+            const emotion = this.emotionalModel.inferEmotion(userMessage);
+            if ((emotion.primary === 'frustrated' || emotion.primary === 'impatient') && emotion.intensity > 0.8) {
+                this.events.emitSync('emotion:escalation', {
+                    genomeId: this.genome.id,
+                    emotion: emotion.primary,
+                    intensity: emotion.intensity,
+                }, { genomeId: this.genome.id, userId });
+            }
+        }
+        let prompt = await this.assemblePrompt(selectionContext, userMessage);
+        if (this.ragEngine) {
+            const ragContext = await this.ragEngine.augment(userMessage, prompt);
+            prompt = ragContext.augmentedPrompt;
+        }
+        if (userId) {
+            try {
+                const memoryPrompt = await this.contextMemory.getMemoryPrompt(userId, this.genome.id);
+                if (memoryPrompt && memoryPrompt.length > 0) {
+                    prompt += `\n\n---\n\n${memoryPrompt}`;
+                }
+            }
+            catch { }
+        }
+        if (userId) {
+            try {
+                const suggestions = await this.proactiveSuggestions.generateSuggestions(userId, this.genome.id, userMessage);
+                if (suggestions.length > 0) {
+                    prompt += `\n\n---\n\n${this.proactiveSuggestions.formatSuggestionsPrompt(suggestions)}`;
+                }
+            }
+            catch { }
+        }
+        if (this.patternMemory) {
+            const predictions = this.patternMemory.getPredictions();
+            if (predictions.length > 0) {
+                const lines = predictions.slice(0, 3).map(p => `- ${p.prediction} (${Math.round(p.confidence * 100)}% confidence)`);
+                prompt += `\n\n---\n\n## Behavioral Predictions\n${lines.join('\n')}`;
+            }
+        }
+        const anomalies = this.anomalyDetector.analyze(userMessage, userId);
+        if (anomalies.some(a => a.suggestedAction === 'block')) {
+            return {
+                prompt: '',
+                sanitizedMessage: userMessage,
+                blocked: true,
+                blockReason: 'Your message could not be processed at this time. Please try again later.',
+            };
+        }
+        if (this.purposeLock) {
+            const rejection = await this.purposeLock.guard(userMessage);
+            if (rejection) {
+                this.events.emitSync('purpose:rejected', {
+                    genomeId: this.genome.id,
+                    userMessage: userMessage.substring(0, 100),
+                }, { genomeId: this.genome.id, userId });
+                return { prompt: '', sanitizedMessage: userMessage, blocked: true, blockReason: rejection };
+            }
+            this.events.emitSync('purpose:accepted', { genomeId: this.genome.id }, { genomeId: this.genome.id, userId });
+        }
+        let sanitizedMessage = userMessage;
+        if (this.contentFirewall) {
+            const inputScan = this.contentFirewall.scan(userMessage, 'user-input');
+            if (inputScan.detections.length > 0) {
+                this.events.emitSync('firewall:threat', {
+                    genomeId: this.genome.id,
+                    pattern: inputScan.detections.map(d => d.patternId).join(', '),
+                    severity: inputScan.allowed ? 'low' : 'high',
+                    allowed: inputScan.allowed,
+                    input: userMessage.slice(0, 100),
+                }, { genomeId: this.genome.id, userId });
+            }
+            sanitizedMessage = inputScan.sanitizedContent;
+        }
+        if (this.shieldBridge) {
+            const shieldResult = await this.shieldBridge.processInbound(sanitizedMessage, taskType, userId);
+            if (!shieldResult.allowed) {
+                return { prompt: '', sanitizedMessage, blocked: true, blockReason: shieldResult.blockReason ?? 'Blocked by security policy.' };
+            }
+            sanitizedMessage = shieldResult.sanitized;
+        }
+        return { prompt, sanitizedMessage, blocked: false };
+    }
+    async afterLLM(userMessage, response, context) {
+        const userId = context.userId ?? 'anonymous';
+        const taskType = context.taskType ?? 'general';
+        const startTime = Date.now();
+        let processedResponse = response;
+        const threats = [];
+        if (this.immuneSystem) {
+            const verdict = this.immuneSystem.scanOutput(response, userMessage, '');
+            if (!verdict.clean) {
+                for (const t of verdict.threats) {
+                    threats.push({ type: t.type, severity: t.severity, description: t.description });
+                }
+                this.events.emitSync('immune:threat', {
+                    genomeId: this.genome.id,
+                    threats: verdict.threats.map(t => ({ type: t.type, severity: t.severity, description: t.description })),
+                    action: verdict.action,
+                }, { genomeId: this.genome.id, userId });
+                if (verdict.action === 'quarantine') {
+                    this.immuneSystem.quarantineAndRecover();
+                    processedResponse = 'I need to rephrase my response for safety reasons. Could you please rephrase your question?';
+                }
+            }
+        }
+        const inputTokens = Math.ceil(userMessage.length / 4);
+        const outputTokens = Math.ceil(response.length / 4);
+        this.metrics.recordRequest({
+            requestId: `mw-${Date.now()}`,
+            duration: Date.now() - startTime,
+            success: true,
+            model: 'external',
+            inputTokens,
+            outputTokens,
+        });
+        await this.storage.recordInteraction({
+            genomeId: this.genome.id,
+            userId,
+            userMessage,
+            assistantResponse: response,
+            toolCalls: [],
+            timestamp: new Date(),
+        });
+        if (this.metacognition) {
+            try {
+                this.metacognition.analyzePostResponse(userMessage, response, true);
+            }
+            catch { }
+        }
+        if (this.patternMemory) {
+            try {
+                this.patternMemory.recordInteraction({ taskType, success: true, timestamp: new Date() });
+            }
+            catch { }
+        }
+        if (this.emotionalModel) {
+            try {
+                this.emotionalModel.inferEmotion(userMessage);
+            }
+            catch { }
+        }
+        if (this.growthJournal) {
+            try {
+                this.growthJournal.recordSuccess(taskType, userMessage, 0.75);
+            }
+            catch { }
+        }
+        if (this.curiosityEngine && taskType) {
+            try {
+                this.curiosityEngine.recordExploration(taskType, true);
+            }
+            catch { }
+        }
+        try {
+            await this.recordInteraction({
+                userId,
+                userMessage,
+                assistantResponse: response,
+                toolCalls: [],
+                taskType,
+                timestamp: new Date(),
+            });
+        }
+        catch { }
+        this.events.emitSync('chat:message', {
+            role: 'assistant',
+            content: response.slice(0, 200),
+            userId,
+        }, { genomeId: this.genome.id, userId });
+        this.interactionCount++;
+        let quality = this.estimateQuality(userMessage, response);
+        if (this.thinkingEngine) {
+            try {
+                const reflection = await this.thinkingEngine.selfReflect(userMessage, response);
+                quality = quality * 0.7 + reflection.qualityScore * 0.3;
+            }
+            catch { }
+        }
+        const interactionData = {
+            success: true,
+            quality,
+            inputTokens,
+            outputTokens,
+            latency: Date.now() - startTime,
+            model: 'external',
+            interventionNeeded: false,
+            timestamp: new Date(),
+        };
+        const fitnessVector = this.fitnessCalculator.computeFitness([interactionData]);
+        this.driftAnalyzer.recordFitness(fitnessVector);
+        this.events.emitSync('fitness:computed', {
+            genomeId: this.genome.id,
+            composite: fitnessVector.composite,
+            vector: {
+                taskSuccess: fitnessVector.successRate,
+                efficiency: fitnessVector.tokenEfficiency,
+                adaptability: fitnessVector.quality,
+                consistency: 1 - fitnessVector.interventionRate,
+                userSatisfaction: fitnessVector.successRate,
+                safety: 1 - fitnessVector.interventionRate,
+            },
+        }, { genomeId: this.genome.id, userId });
+        const driftCheck = this.driftAnalyzer.analyzeDrift();
+        if (driftCheck.isDrifting) {
+            this.events.emitSync('drift:detected', {
+                genomeId: this.genome.id,
+                signals: driftCheck.signals.map(s => ({
+                    type: s.type, severity: s.severity, metric: s.metric, value: s.currentValue,
+                })),
+                severity: driftCheck.overallSeverity,
+            }, { genomeId: this.genome.id, userId });
+        }
+        const continuousEvolution = this.genome.config.autonomous?.continuousEvolution;
+        const evolveEveryN = this.genome.config.autonomous?.evolveEveryN ?? 10;
+        if (continuousEvolution && this.interactionCount % evolveEveryN === 0 && !this.evolutionInProgress) {
+            this.evolutionInProgress = true;
+            this.runEvolutionCycle()
+                .then(() => {
+                console.log(`[GSEP] 🧬 Evolution cycle complete — interaction #${this.interactionCount}`);
+            })
+                .catch((err) => {
+                console.log(`[GSEP] ❌ Evolution cycle failed:`, err instanceof Error ? err.message : String(err));
+            })
+                .finally(() => {
+                this.evolutionInProgress = false;
+            });
+        }
+        this.events.emitSync('chat:completed', {
+            userId, taskType,
+            duration: Date.now() - startTime,
+            success: true,
+            inputTokens, outputTokens,
+            interactionCount: this.interactionCount,
+        }, { genomeId: this.genome.id, userId });
+        this.persistSecurityStats();
+        return {
+            safe: threats.length === 0,
+            threats,
+            fitness: fitnessVector.composite,
+            response: processedResponse,
+        };
+    }
+    async rehydrate() {
+        const analytics = await this.storage.getAnalytics(this.genome.id);
+        this.interactionCount = analytics.totalInteractions;
+        const mutations = await this.storage.getMutationHistory(this.genome.id, 100);
+        for (const mutation of mutations) {
+            if (mutation.fitnessDelta !== undefined) {
+                this.driftAnalyzer.recordFitness({
+                    quality: 0.7,
+                    successRate: 0.7,
+                    tokenEfficiency: 0.5,
+                    latency: 500,
+                    costPerSuccess: 0.01,
+                    interventionRate: 0.1,
+                    composite: 0.7,
+                    sampleSize: 1,
+                    lastUpdated: mutation.timestamp ?? new Date(),
+                    confidence: 0.5,
+                });
+            }
+        }
+        try {
+            const sqliteStorage = this.storage;
+            if (typeof sqliteStorage.loadSecurityStats === 'function') {
+                const stats = sqliteStorage.loadSecurityStats();
+                if (stats) {
+                    if (stats.c3 && this.contentFirewall) {
+                        this.contentFirewall.restoreAnalytics(stats.c3);
+                    }
+                    if (stats.c4 && this.immuneSystem) {
+                        this.immuneSystem.restoreStats(stats.c4);
+                    }
+                }
+            }
+        }
+        catch { }
+        console.log(`[GSEP] Rehydrated: ${this.interactionCount} interactions, ${mutations.length} mutations restored`);
+    }
+    persistSecurityStats() {
+        try {
+            const sqliteStorage = this.storage;
+            if (typeof sqliteStorage.saveSecurityStats === 'function') {
+                const stats = {
+                    c3: this.contentFirewall ? {
+                        totalScanned: this.contentFirewall.getAnalytics().totalScanned,
+                        totalBlocked: this.contentFirewall.getAnalytics().totalBlocked,
+                        totalSanitized: this.contentFirewall.getAnalytics().totalSanitized,
+                    } : undefined,
+                    c4: this.immuneSystem ? this.immuneSystem.getImmuneStatus() : undefined,
+                    lastUpdated: new Date().toISOString(),
+                };
+                sqliteStorage.saveSecurityStats(stats);
+            }
+        }
+        catch { }
+    }
+    getEventEmitter() {
+        return this.events;
+    }
+    dashboardServer;
+    async startDashboard(options) {
+        const port = options?.port ?? 4200;
+        if (this.dashboardServer) {
+            await this.dashboardServer.stop();
+        }
+        this.dashboardServer = new DashboardServer({
+            secret: `gsep-${this.genome.id}`,
+            events: this.events,
+            port,
+            host: '127.0.0.1',
+            getSnapshot: async () => {
+                const perf = this.metrics.getPerformanceMetrics();
+                const analytics = await this.storage.getAnalytics(this.genome.id);
+                const mutations = await this.storage.getMutationHistory(this.genome.id, 1000);
+                const c3Analytics = this.contentFirewall?.getAnalytics();
+                return {
+                    genomeId: this.genome.id,
+                    name: this.genome.name,
+                    version: this.genome.version || 1,
+                    status: 'active',
+                    interactionCount: this.interactionCount || analytics.totalInteractions,
+                    totalRequests: perf.totalRequests || analytics.totalInteractions,
+                    successRate: perf.successRate,
+                    totalTokens: perf.totalTokens,
+                    avgResponseTime: perf.avgResponseTime,
+                    totalMutations: analytics.totalMutations,
+                    promotedCount: mutations.filter(m => m.deployed).length,
+                    rejectedCount: mutations.filter(m => !m.deployed).length,
+                    threatCount: (c3Analytics?.totalBlocked ?? 0),
+                };
+            },
+            getMarketplaceClient: () => this.geneBank?.getMarketplaceClient(),
+            getGenes: () => {
+                const c3Analytics = this.contentFirewall?.getAnalytics();
+                const c4Status = this.immuneSystem?.getImmuneStatus();
+                return {
+                    layer0: this.genome.layers.layer0,
+                    layer1: this.genome.layers.layer1,
+                    layer2: this.genome.layers.layer2,
+                    c3: this.contentFirewall ? {
+                        active: true,
+                        integrityValid: this.contentFirewall.integrityValid,
+                        totalPatterns: 57,
+                        totalScanned: c3Analytics?.totalScanned ?? 0,
+                        totalBlocked: c3Analytics?.totalBlocked ?? 0,
+                        totalSanitized: c3Analytics?.totalSanitized ?? 0,
+                        blockRate: c3Analytics?.blockRate ?? 0,
+                    } : undefined,
+                    c4: this.immuneSystem ? {
+                        active: true,
+                        totalScans: c4Status?.totalScans ?? 0,
+                        threatsDetected: c4Status?.threatsDetected ?? 0,
+                        quarantinesTriggered: c4Status?.quarantinesTriggered ?? 0,
+                        sanitizations: c4Status?.sanitizations ?? 0,
+                        immuneMemorySize: c4Status?.immuneMemorySize ?? 0,
+                    } : undefined,
+                    geneBank: this.getGeneBankDashboardData(),
+                };
+            },
+        });
+        await this.dashboardServer.start();
+        const token = DashboardTokenHelper.create(`gsep-${this.genome.id}`, { userId: 'owner', genomeId: this.genome.id, expiresIn: '30d' });
+        const url = `http://localhost:${port}/gsep/dashboard?token=${token}`;
+        console.log(`\n🧬 GSEP Dashboard: ${url}\n`);
+        console.log(`  Running on a VPS? Use: ssh -L ${port}:localhost:${port} your-server\n`);
+        try {
+            const { exec } = await import('node:child_process');
+            const platform = process.platform;
+            const cmd = platform === 'darwin' ? 'open' : platform === 'win32' ? 'start' : 'xdg-open';
+            exec(`${cmd} "${url}"`);
+        }
+        catch { }
+        return url;
+    }
+    async stopDashboard() {
+        if (this.dashboardServer) {
+            await this.dashboardServer.stop();
+            this.dashboardServer = undefined;
+        }
+    }
     getWelcomeMessage(style = 'detailed') {
         const messages = {
             short: `🧬 I now have GSEP — Genomic Self-Evolving Prompts integrated into my DNA!
@@ -513,6 +1237,11 @@ Ready to see what we can do together? 😊`,
         const requestId = `chat_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
         const startTime = Date.now();
         let error;
+        this.events.emitSync('chat:started', {
+            genomeId: this.genome.id,
+            userId: context.userId ?? 'anonymous',
+            message: userMessage.slice(0, 200),
+        }, { genomeId: this.genome.id, userId: context.userId });
         try {
             if (this.stateVector) {
                 this.stateVector.beginCycle(userMessage, context.taskType);
@@ -627,11 +1356,47 @@ Ready to see what we can do together? 😊`,
                     },
                 });
             }
+            if (this.emotionalModel) {
+                const emotion = this.emotionalModel.inferEmotion(userMessage);
+                if ((emotion.primary === 'frustrated' || emotion.primary === 'impatient') && emotion.intensity > 0.8) {
+                    this.metrics.logAudit({
+                        level: 'info',
+                        component: 'emotional-escalation',
+                        operation: 'escalate',
+                        message: `High ${emotion.primary} detected (intensity: ${emotion.intensity.toFixed(2)}) — consider human escalation`,
+                        genomeId: this.genome.id,
+                    });
+                    this.events.emitSync('emotion:escalation', {
+                        genomeId: this.genome.id,
+                        emotion: emotion.primary,
+                        intensity: emotion.intensity,
+                    }, { genomeId: this.genome.id, userId: context.userId });
+                }
+            }
             let prompt = await this.assemblePrompt(context, userMessage);
             if (this.ragEngine) {
                 const ragContext = await this.ragEngine.augment(userMessage, prompt);
                 prompt = ragContext.augmentedPrompt;
             }
+            if (context.userId) {
+                try {
+                    const memoryPrompt = await this.contextMemory.getMemoryPrompt(context.userId, this.genome.id);
+                    if (memoryPrompt && memoryPrompt.length > 0) {
+                        prompt += `\n\n---\n\n${memoryPrompt}`;
+                    }
+                }
+                catch { }
+            }
+            if (context.userId) {
+                try {
+                    const suggestions = await this.proactiveSuggestions.generateSuggestions(context.userId, this.genome.id, userMessage);
+                    if (suggestions.length > 0) {
+                        const suggestionsPrompt = this.proactiveSuggestions.formatSuggestionsPrompt(suggestions);
+                        prompt += `\n\n---\n\n${suggestionsPrompt}`;
+                    }
+                }
+                catch { }
+            }
             if (this.patternMemory) {
                 const predictions = this.patternMemory.getPredictions();
                 if (predictions.length > 0) {
@@ -649,6 +1414,45 @@ Ready to see what we can do together? 😊`,
                     }
                 }
             }
+            const anomalies = this.anomalyDetector.analyze(userMessage, context.userId);
+            for (const anomaly of anomalies) {
+                this.events.emitSync('anomaly:detected', {
+                    genomeId: this.genome.id,
+                    type: anomaly.type,
+                    severity: anomaly.severity,
+                    description: anomaly.description,
+                }, { genomeId: this.genome.id, userId: context.userId });
+            }
+            if (anomalies.some(a => a.suggestedAction === 'block')) {
+                this.metrics.logAudit({
+                    level: 'warning',
+                    component: 'anomaly-detector',
+                    operation: 'block',
+                    message: `Blocked: ${anomalies.map(a => a.description).join('; ')}`,
+                    genomeId: this.genome.id,
+                });
+                return 'Your message could not be processed at this time. Please try again later.';
+            }
+            if (this.purposeLock) {
+                const rejection = await this.purposeLock.guard(userMessage);
+                if (rejection) {
+                    this.metrics.logAudit({
+                        level: 'info',
+                        component: 'purpose-lock',
+                        operation: 'reject',
+                        message: `Off-purpose message rejected`,
+                        genomeId: this.genome.id,
+                    });
+                    this.events.emitSync('purpose:rejected', {
+                        genomeId: this.genome.id,
+                        userMessage: userMessage.substring(0, 100),
+                    }, { genomeId: this.genome.id, userId: context.userId });
+                    return rejection;
+                }
+                this.events.emitSync('purpose:accepted', {
+                    genomeId: this.genome.id,
+                }, { genomeId: this.genome.id, userId: context.userId });
+            }
             let sanitizedUserMessage = userMessage;
             if (this.contentFirewall) {
                 const inputScan = this.contentFirewall.scan(userMessage, 'user-input');
@@ -662,13 +1466,41 @@ Ready to see what we can do together? 😊`,
                         userId: context.userId,
                     });
                 }
+                if (inputScan.detections.length > 0) {
+                    this.events.emitSync('firewall:threat', {
+                        genomeId: this.genome.id,
+                        pattern: inputScan.detections.map(d => d.patternId).join(', '),
+                        severity: inputScan.allowed ? 'low' : 'high',
+                        allowed: inputScan.allowed,
+                        input: userMessage.slice(0, 100),
+                    }, { genomeId: this.genome.id, userId: context.userId });
+                }
                 sanitizedUserMessage = inputScan.sanitizedContent;
             }
+            if (this.shieldBridge) {
+                const shieldResult = await this.shieldBridge.processInbound(sanitizedUserMessage, context.taskType ?? 'system', context.userId);
+                if (!shieldResult.allowed) {
+                    this.metrics.logAudit({
+                        level: 'warning',
+                        component: 'genome-shield',
+                        operation: 'inbound-blocked',
+                        message: shieldResult.blockReason ?? 'Blocked by Genome Shield',
+                        genomeId: this.genome.id,
+                        userId: context.userId,
+                    });
+                    return shieldResult.blockReason ?? 'Message blocked by security policy.';
+                }
+                sanitizedUserMessage = shieldResult.sanitized;
+            }
             let response;
             if (this.reasoningEngine) {
                 const reasoningResult = await this.reasoningEngine.reason(sanitizedUserMessage, prompt, this.genome.config.reasoning?.defaultStrategy);
                 response = { content: reasoningResult.answer };
             }
+            else if (this.skillRouter && this.skillRegistry.size > 0) {
+                const skillResult = await this.skillRouter.run(prompt, sanitizedUserMessage);
+                response = { content: skillResult.response };
+            }
             else {
                 response = await this.llm.chat([
                     { role: 'system', content: prompt },
@@ -686,6 +1518,15 @@ Ready to see what we can do together? 😊`,
                         genomeId: this.genome.id,
                         userId: context.userId,
                     });
+                    this.events.emitSync('immune:threat', {
+                        genomeId: this.genome.id,
+                        threats: verdict.threats.map(t => ({
+                            type: t.type,
+                            severity: t.severity ?? 'medium',
+                            description: t.description ?? t.type,
+                        })),
+                        action: verdict.action,
+                    }, { genomeId: this.genome.id, userId: context.userId });
                     if (verdict.action === 'quarantine') {
                         this.immuneSystem.quarantineAndRecover();
                         const retryResponse = await this.llm.chat([
@@ -705,15 +1546,30 @@ Ready to see what we can do together? 😊`,
                     }
                 }
             }
+            if (this.shieldBridge) {
+                const outbound = await this.shieldBridge.processOutbound(response.content, prompt);
+                if (outbound.verdict === 'quarantine') {
+                    response = { ...response, content: 'Response blocked by security policy.' };
+                }
+                else if (outbound.sanitized) {
+                    response = { ...response, content: outbound.sanitized };
+                }
+            }
             const inputTokens = response.usage?.inputTokens
                 ?? Math.ceil((prompt.length + userMessage.length) / 4);
             const outputTokens = response.usage?.outputTokens
                 ?? Math.ceil(response.content.length / 4);
+            this.events.emitSync('chat:message', {
+                genomeId: this.genome.id,
+                userId: context.userId ?? 'anonymous',
+                message: userMessage.slice(0, 200),
+                duration: Date.now() - startTime,
+            }, { genomeId: this.genome.id, userId: context.userId });
             this.metrics.recordRequest({
                 requestId,
                 duration: Date.now() - startTime,
                 success: true,
-                model: 'pga-genome',
+                model: 'gsep-genome',
                 inputTokens,
                 outputTokens,
             });
@@ -785,6 +1641,31 @@ Ready to see what we can do together? 😊`,
             };
             const fitnessVector = this.fitnessCalculator.computeFitness([interactionData]);
             this.driftAnalyzer.recordFitness(fitnessVector);
+            this.events.emitSync('fitness:computed', {
+                genomeId: this.genome.id,
+                composite: fitnessVector.composite,
+                vector: {
+                    taskSuccess: fitnessVector.successRate,
+                    efficiency: fitnessVector.tokenEfficiency,
+                    adaptability: fitnessVector.quality,
+                    consistency: 1 - fitnessVector.interventionRate,
+                    userSatisfaction: fitnessVector.successRate,
+                    safety: 1 - fitnessVector.interventionRate,
+                },
+            }, { genomeId: this.genome.id, userId: context.userId });
+            const driftCheck = this.driftAnalyzer.analyzeDrift();
+            if (driftCheck.isDrifting) {
+                this.events.emitSync('drift:detected', {
+                    genomeId: this.genome.id,
+                    signals: driftCheck.signals.map(s => ({
+                        type: s.type,
+                        severity: s.severity,
+                        metric: s.metric,
+                        value: s.currentValue,
+                    })),
+                    severity: driftCheck.overallSeverity ?? 'low',
+                }, { genomeId: this.genome.id, userId: context.userId });
+            }
             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);
@@ -795,16 +1676,19 @@ Ready to see what we can do together? 😊`,
             }
             this.interactionCount++;
             const autoConfig = this.genome.config.autonomous;
-            if (!this.evolutionInProgress
-                && autoConfig?.continuousEvolution
-                && this.interactionCount % (autoConfig.evolveEveryN ?? 10) === 0) {
+            const isScheduledEvolution = autoConfig?.continuousEvolution
+                && this.interactionCount % (autoConfig.evolveEveryN ?? 10) === 0;
+            const isUrgentDrift = driftCheck.isDrifting
+                && autoConfig?.autoMutateOnDrift !== false
+                && driftCheck.signals.some(s => s.severity === 'severe' || s.severity === 'critical');
+            if (!this.evolutionInProgress && (isScheduledEvolution || isUrgentDrift)) {
                 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)}`,
+                    operation: isUrgentDrift ? 'urgent-evolve' : 'auto-evolve',
+                    message: `${isUrgentDrift ? 'Urgent' : 'Auto'}-evolution failed: ${err instanceof Error ? err.message : String(err)}`,
                     genomeId: this.genome.id,
                 }))
                     .finally(() => {
@@ -830,6 +1714,14 @@ Ready to see what we can do together? 😊`,
                     }
                 }
             }
+            this.events.emitSync('chat:completed', {
+                genomeId: this.genome.id,
+                userId: context.userId ?? 'anonymous',
+                duration: Date.now() - startTime,
+                quality,
+                tokens: inputTokens + outputTokens,
+            }, { genomeId: this.genome.id, userId: context.userId });
+            this.persistSecurityStats();
             return response.content;
         }
         catch (err) {
@@ -838,7 +1730,7 @@ Ready to see what we can do together? 😊`,
                 requestId,
                 duration: Date.now() - startTime,
                 success: false,
-                model: 'pga-genome',
+                model: 'gsep-genome',
                 inputTokens: 0,
                 outputTokens: 0,
                 error,
@@ -978,6 +1870,9 @@ Ready to see what we can do together? 😊`,
             const score = this.computeInteractionQuality(interaction);
             await this.fitnessTracker.recordPerformance(1, allele.gene, allele.variant, score);
         }
+        const chatQuality = this.computeInteractionQuality(interaction);
+        const chatTokens = estimateTokenCount(interaction.userMessage) + estimateTokenCount(interaction.assistantResponse ?? '');
+        this.weeklyReportGenerator.recordInteraction(chatQuality, chatTokens);
         if (this.patternMemory) {
             this.patternMemory.recordInteraction({
                 taskType: interaction.taskType,
@@ -1132,6 +2027,94 @@ Ready to see what we can do together? 😊`,
             timestamp: new Date(),
         });
     }
+    async recordExternalInteraction(params) {
+        const requestId = `ext-${Date.now()}`;
+        const startTime = Date.now();
+        try {
+            this.events.emitSync('chat:started', {
+                userId: params.userId,
+                taskType: params.taskType,
+                messagePreview: params.userMessage.slice(0, 100),
+            }, { genomeId: this.genome.id, userId: params.userId });
+            const inputTokens = Math.ceil(params.userMessage.length / 4);
+            const outputTokens = Math.ceil(params.response.length / 4);
+            this.metrics.recordRequest({
+                requestId,
+                duration: 0,
+                success: params.success,
+                model: 'external',
+                inputTokens,
+                outputTokens,
+            });
+            await this.storage.recordInteraction({
+                genomeId: this.genome.id,
+                userId: params.userId,
+                userMessage: params.userMessage,
+                assistantResponse: params.response,
+                toolCalls: [],
+                timestamp: new Date(),
+            });
+            this.events.emitSync('chat:message', {
+                role: 'assistant',
+                content: params.response.slice(0, 200),
+                userId: params.userId,
+            }, { genomeId: this.genome.id, userId: params.userId });
+            this.interactionCount++;
+            const continuousEvolution = this.genome.config.autonomous?.continuousEvolution;
+            const evolveEveryN = this.genome.config.autonomous?.evolveEveryN ?? 10;
+            const interactionData = {
+                success: params.success,
+                quality: params.success ? 0.75 : 0.3,
+                inputTokens,
+                outputTokens,
+                latency: 0,
+                model: 'external',
+                interventionNeeded: false,
+                timestamp: new Date(),
+            };
+            const fitnessVector = this.fitnessCalculator.computeFitness([interactionData]);
+            this.driftAnalyzer.recordFitness(fitnessVector);
+            this.events.emitSync('fitness:computed', {
+                genomeId: this.genome.id,
+                composite: fitnessVector.composite,
+                vector: {
+                    taskSuccess: fitnessVector.successRate,
+                    efficiency: fitnessVector.tokenEfficiency,
+                    adaptability: fitnessVector.quality,
+                    consistency: 1 - fitnessVector.interventionRate,
+                    userSatisfaction: fitnessVector.successRate,
+                    safety: 1 - fitnessVector.interventionRate,
+                },
+            }, { genomeId: this.genome.id, userId: params.userId });
+            const driftCheck = this.driftAnalyzer.analyzeDrift();
+            if (driftCheck.isDrifting) {
+                this.events.emitSync('drift:detected', {
+                    genomeId: this.genome.id,
+                    signals: driftCheck.signals.map(s => ({
+                        type: s.type,
+                        severity: s.severity,
+                        metric: s.metric,
+                        value: s.currentValue,
+                    })),
+                    severity: driftCheck.overallSeverity,
+                }, { genomeId: this.genome.id, userId: params.userId });
+            }
+            this.events.emitSync('chat:completed', {
+                userId: params.userId,
+                taskType: params.taskType,
+                duration: Date.now() - startTime,
+                success: params.success,
+                inputTokens,
+                outputTokens,
+                interactionCount: this.interactionCount,
+            }, { genomeId: this.genome.id, userId: params.userId });
+            this.persistSecurityStats();
+            if (continuousEvolution && this.interactionCount % evolveEveryN === 0 && !this.evolutionInProgress) {
+                this.runEvolutionCycle().catch(() => { });
+            }
+        }
+        catch { }
+    }
     async addAllele(layer, gene, variant, content) {
         const newAllele = {
             gene,
@@ -1224,7 +2207,29 @@ Ready to see what we can do together? 😊`,
                 sampleCount: currentAllele.sampleCount || 0,
                 rollbackCount: 0,
             };
+            this.events.emitSync('mutation:generated', {
+                genomeId: this.genome.id,
+                gene: opts.gene,
+                layer: opts.layer,
+                candidateCount: opts.candidates,
+            }, { genomeId: this.genome.id });
             const gateResult = await this.guardrailsManager.evaluateCandidate(mutationCandidate, this.genome.id);
+            this.events.emitSync('gate:evaluated', {
+                genomeId: this.genome.id,
+                gene: opts.gene,
+                variant: mutationCandidate.variant,
+                decision: gateResult.finalDecision,
+                gates: {
+                    quality: { passed: gateResult.gates.quality.passed, score: gateResult.gates.quality.score },
+                    sandbox: { passed: gateResult.gates.sandbox.passed, score: gateResult.gates.sandbox.score },
+                    economic: { passed: gateResult.gates.economic.passed, score: gateResult.gates.economic.score },
+                    stability: { passed: gateResult.gates.stability.passed, score: gateResult.gates.stability.score },
+                    ...(gateResult.gates.constitutional ? {
+                        constitutional: { passed: gateResult.gates.constitutional.passed, score: gateResult.gates.constitutional.score },
+                    } : {}),
+                },
+                reason: gateResult.reason,
+            }, { genomeId: this.genome.id });
             const result = gateResult.finalDecision === 'promote' ? await (async () => {
                 currentAllele.status = 'retired';
                 const promotedAllele = {
@@ -1259,6 +2264,33 @@ Ready to see what we can do together? 😊`,
                     deployed: true,
                     createdAt: new Date(),
                 });
+                this.events.emitSync('mutation:promoted', {
+                    genomeId: this.genome.id,
+                    gene: opts.gene,
+                    variant: mutationCandidate.variant,
+                    layer: opts.layer,
+                    fitness: mutationCandidate.fitness,
+                    improvement: mutationCandidate.fitness - currentAllele.fitness,
+                }, { genomeId: this.genome.id });
+                this.events.emitSync('gene:updated', {
+                    genomeId: this.genome.id,
+                    layers: {
+                        layer0: this.genome.layers.layer0,
+                        layer1: this.genome.layers.layer1,
+                        layer2: this.genome.layers.layer2,
+                        c3: this.contentFirewall ? {
+                            active: true,
+                            integrityValid: this.contentFirewall.integrityValid,
+                            totalPatterns: 57,
+                            ...this.contentFirewall.getAnalytics(),
+                        } : undefined,
+                        c4: this.immuneSystem ? {
+                            active: true,
+                            ...this.immuneSystem.getImmuneStatus(),
+                        } : undefined,
+                        geneBank: this.getGeneBankDashboardData(),
+                    },
+                }, { genomeId: this.genome.id });
                 return {
                     applied: true,
                     reason: gateResult.reason,
@@ -1296,16 +2328,45 @@ Ready to see what we can do together? 😊`,
                         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,
-                },
-            };
+            })() : (() => {
+                this.events.emitSync('mutation:rejected', {
+                    genomeId: this.genome.id,
+                    layer: opts.layer,
+                    gene: opts.gene,
+                    variant: mutationCandidate.variant,
+                    fitness: mutationCandidate.fitness,
+                    reason: gateResult.reason,
+                }, { genomeId: this.genome.id });
+                this.events.emitSync('gene:updated', {
+                    genomeId: this.genome.id,
+                    layers: {
+                        layer0: this.genome.layers.layer0,
+                        layer1: this.genome.layers.layer1,
+                        layer2: this.genome.layers.layer2,
+                        c3: this.contentFirewall ? {
+                            active: true,
+                            integrityValid: this.contentFirewall.integrityValid,
+                            totalPatterns: 57,
+                            ...this.contentFirewall.getAnalytics(),
+                        } : undefined,
+                        c4: this.immuneSystem ? {
+                            active: true,
+                            ...this.immuneSystem.getImmuneStatus(),
+                        } : undefined,
+                        geneBank: this.getGeneBankDashboardData(),
+                    },
+                }, { genomeId: this.genome.id });
+                return {
+                    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(), {
@@ -1565,6 +2626,89 @@ Ready to see what we can do together? 😊`,
     async getProactiveSuggestions(userId, currentMessage) {
         return this.proactiveSuggestions.generateSuggestions(userId, this.genome.id, currentMessage);
     }
+    registerSkill(name, description, inputSchema, execute) {
+        this.skillRegistry.registerInline(name, description, inputSchema, execute);
+        this.events.emitSync('skill:registered', {
+            genomeId: this.genome.id,
+            skill: name,
+            description,
+        }, { genomeId: this.genome.id });
+    }
+    async connectMCPServer(uri) {
+        return this.skillExecutor.connectMCP(uri);
+    }
+    getSkillRegistry() {
+        return this.skillRegistry;
+    }
+    getSkillRanking() {
+        return this.skillRegistry.getRankedSkills();
+    }
+    async runWithSkills(systemPrompt, userMessage) {
+        if (!this.skillRouter) {
+            throw new Error('[GSEP] Skill router requires an LLM adapter');
+        }
+        return this.skillRouter.run(systemPrompt, userMessage);
+    }
+    addProactiveTask(task) {
+        if (!this.proactiveEngine) {
+            throw new Error('[GSEP] Proactive engine requires an LLM adapter');
+        }
+        this.proactiveEngine.addTask(task);
+    }
+    startProactiveEngine() {
+        this.proactiveEngine?.start();
+        this.events.emitSync('proactive:started', {
+            genomeId: this.genome.id,
+        }, { genomeId: this.genome.id });
+    }
+    stopProactiveEngine() {
+        this.proactiveEngine?.stop();
+    }
+    onProactiveNotification(handler) {
+        this.proactiveEngine?.onNotification(handler);
+    }
+    async runProactiveTasks() {
+        const results = await (this.proactiveEngine?.runAll() ?? Promise.resolve([]));
+        for (const result of results) {
+            this.events.emitSync('proactive:completed', {
+                genomeId: this.genome.id,
+                taskId: result.taskId,
+                taskName: result.taskName,
+                shouldNotify: result.shouldNotify,
+                importance: result.importance,
+                summary: result.findings.substring(0, 200),
+            }, { genomeId: this.genome.id });
+        }
+        return results;
+    }
+    getProactiveResults(limit) {
+        return this.proactiveEngine?.getResults(limit) ?? [];
+    }
+    generateWeeklyReport() {
+        const report = this.weeklyReportGenerator.generate();
+        if (this.growthJournal) {
+            const snapshot = this.growthJournal.getGrowthSnapshot();
+            if (snapshot.narrative) {
+                report.summary += `\n\n🌱 Growth: ${snapshot.narrative}`;
+            }
+            if (snapshot.recentInsights.length > 0) {
+                report.suggestions.push(...snapshot.recentInsights.slice(0, 3).map(i => `Growth insight: ${i}`));
+            }
+        }
+        return report;
+    }
+    getAnomalyAnalytics() {
+        return this.anomalyDetector.getAnalytics();
+    }
+    getAnomalyHistory(limit) {
+        return this.anomalyDetector.getHistory(limit);
+    }
+    getGrowthSnapshot() {
+        return this.growthJournal?.getGrowthSnapshot() ?? null;
+    }
+    getWeekInteractionCount() {
+        return this.weeklyReportGenerator.getWeekInteractionCount();
+    }
     async getConversationContext(userId) {
         return this.contextMemory.buildContext(userId, this.genome.id);
     }
@@ -1662,6 +2806,12 @@ Ready to see what we can do together? 😊`,
             }
         }
         if (autoConfig?.autoMutateOnDrift !== false && drift.isDrifting) {
+            this.events.emitSync('mutation:generated', {
+                genomeId: this.genome.id,
+                gene: 'drift-response',
+                layer: 1,
+                candidateCount: drift.signals.length,
+            }, { genomeId: this.genome.id });
             if (this.strategicAutonomy && this.enhancedSelfModel) {
                 const health = this.enhancedSelfModel.assessFull();
                 const priorities = this.strategicAutonomy.prioritizeEvolution(drift.signals, health);
@@ -1702,6 +2852,43 @@ Ready to see what we can do together? 😊`,
                 }
             }
         }
+        else {
+            const activeC1 = this.genome.layers.layer1
+                .filter((a) => a.status === 'active')
+                .sort((a, b) => a.fitness - b.fitness);
+            if (activeC1.length > 0) {
+                const weakest = activeC1[0];
+                this.events.emitSync('mutation:generated', {
+                    genomeId: this.genome.id,
+                    gene: weakest.gene,
+                    layer: 1,
+                    candidateCount: 1,
+                }, { genomeId: this.genome.id });
+                console.log(`[GSEP] 🔬 Exploratory mutation: trying to improve "${weakest.gene}" (fitness: ${weakest.fitness.toFixed(2)})`);
+                try {
+                    await this.mutate({
+                        layer: 1,
+                        gene: weakest.gene,
+                        taskType: 'exploratory-evolution',
+                    });
+                }
+                catch (err) {
+                    this.events.emitSync('mutation:rejected', {
+                        genomeId: this.genome.id,
+                        gene: weakest.gene,
+                        reason: err instanceof Error ? err.message : 'Exploration failed',
+                    }, { genomeId: this.genome.id });
+                    console.log(`[GSEP] 🔬 Exploratory mutation for "${weakest.gene}" — no improvement found (this is normal)`);
+                }
+            }
+            else {
+                this.events.emitSync('mutation:rejected', {
+                    genomeId: this.genome.id,
+                    gene: 'none',
+                    reason: 'No active C1 genes to evolve',
+                }, { genomeId: this.genome.id });
+            }
+        }
         if (autoConfig?.autoCompressOnPressure !== false) {
             const totalC1Tokens = this.genome.layers.layer1
                 .filter(a => a.status === 'active')
@@ -1921,6 +3108,21 @@ Ready to see what we can do together? 😊`,
         };
         return mapping[signal.type] || { layer: 2, gene: 'communication-style' };
     }
+    getGeneBankDashboardData() {
+        const allGenes = [
+            ...this.genome.layers.layer0,
+            ...this.genome.layers.layer1,
+            ...this.genome.layers.layer2,
+        ];
+        const publishThreshold = this.genome.config.autonomous?.autoPublishThreshold ?? 0.85;
+        return {
+            active: !!this.geneBank,
+            totalGenes: allGenes.filter(g => g.status === 'active').length,
+            sellable: allGenes.filter(g => g.status === 'active' && g.fitness >= publishThreshold && !g.publishedToSwarm),
+            published: allGenes.filter(g => g.publishedToSwarm),
+            adopted: allGenes.filter(g => (g.variant || '').startsWith('swarm_')),
+        };
+    }
     async autoPublishGene(allele) {
         if (!this.geneBank)
             return;
@@ -2225,4 +3427,4 @@ Ready to see what we can do together? 😊`,
         return TECH_TERMS.filter(term => lower.includes(term));
     }
 }
-//# sourceMappingURL=PGA.js.map
+//# sourceMappingURL=GSEP.js.map