noormme 1.0.6 → 1.2.0

package/dist/cjs/agentic/improvement/SkillSynthesizer.js

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkillSynthesizer = void 0;
+/**
+ * High-Throughput Tiered AI Synthesis Strategy.
+ * Orchestrates multiple model tiers for cost-effective ultra-scale evolution.
+ */
+class AISynthesisStrategy {
+    cortex;
+    synthesizer;
+    name = 'AISynthesisEngine';
+    constructor(cortex, synthesizer) {
+        this.cortex = cortex;
+        this.synthesizer = synthesizer;
+    }
+    async synthesize(context) {
+        let attempts = 0;
+        const maxRetries = 3;
+        // Pass 6: Ultra-Scale Tiered Routing
+        // Use premium model for individual mutations if available
+        const model = this.cortex.llmPremium || this.cortex.llm;
+        while (attempts < maxRetries) {
+            try {
+                const prompt = this.buildMutationPrompt(context);
+                if (!model) {
+                    console.warn(`[SkillSynthesizer] No LLMProvider available. Skipping synthesis.`);
+                    return {
+                        mutatedDescription: context.existingDescription ||
+                            'Unmodified skill (Synthesis skipped: No LLM)',
+                        mutatedMetadata: { synthesis_status: 'skipped_no_llm' },
+                        version: `1.0.${Date.now()}`,
+                    };
+                }
+                const response = await model.complete({
+                    prompt,
+                    responseFormat: 'json',
+                    temperature: 0.3,
+                });
+                if (response.usage) {
+                    this.synthesizer.totalTokensConsumed += response.usage.totalTokens;
+                }
+                try {
+                    const parsed = JSON.parse(response.content);
+                    return {
+                        mutatedDescription: parsed.description || context.existingDescription,
+                        mutatedMetadata: {
+                            ...parsed.metadata,
+                            synthesis_engine: this.cortex.llmPremium
+                                ? 'Tiered-Premium'
+                                : 'Production-LLM',
+                            failure_context_size: context.failures.length,
+                        },
+                        version: `1.0.${Date.now()}`,
+                    };
+                }
+                catch (err) {
+                    throw new Error('Synthesis parse failure');
+                }
+            }
+            catch (error) {
+                attempts++;
+                if (attempts >= maxRetries)
+                    throw error;
+                await new Promise((resolve) => setTimeout(resolve, 1000 * attempts));
+            }
+        }
+        throw new Error('Synthesis failed after maximum retries');
+    }
+    /**
+     * Batch Synthesis using FAST model (Pass 6)
+     */
+    async synthesizeBatch(contexts) {
+        const model = this.cortex.llmFast || this.cortex.llm;
+        if (!model)
+            return [];
+        const batchPrompt = `
+            You are a Meta-Evolutionary AI Engine optimizing multiple tools in parallel.
+            
+            TOOLS TO MUTATE:
+            ${contexts
+            .map((ctx, i) => `
+                [Tool ${i + 1}: ${ctx.targetTool}]
+                Current Description: ${ctx.existingDescription || 'None'}
+                Failure Patterns:
+                ${ctx.failures.map((f) => `- Args: ${JSON.stringify(f.arguments)}, Error: ${f.error}`).join('\n')}
+            `)
+            .join('\n')}
+
+            TASK:
+            For each tool, provide a mutation as a JSON array of objects:
+            [
+              {
+                "tool": "tool_name",
+                "description": "Updated tool description",
+                "metadata": { "fixed_edge_cases": [...], "reasoning": "..." }
+              },
+              ...
+            ]
+        `;
+        const response = await model.complete({
+            prompt: batchPrompt,
+            responseFormat: 'json',
+            temperature: 0.2,
+        });
+        if (response.usage) {
+            this.synthesizer.totalTokensConsumed += response.usage.totalTokens;
+        }
+        try {
+            const parsed = JSON.parse(response.content);
+            return parsed.map((item) => ({
+                tool: item.tool,
+                mutation: {
+                    mutatedDescription: item.description,
+                    mutatedMetadata: item.metadata,
+                    version: `1.0.${Date.now()}`,
+                },
+            }));
+        }
+        catch (err) {
+            return [];
+        }
+    }
+    buildMutationPrompt(context) {
+        const failureList = context.failures
+            .map((f, i) => `${i + 1}. Args: ${JSON.stringify(f.arguments)}, Error: ${f.error || 'None'}`)
+            .join('\n');
+        return `
+            You are a Meta-Evolutionary AI Engine optimizing a tool: "${context.targetTool}".
+            Analyze FAILURES and rewrite the description to prevent them.
+            
+            EXISTING: "${context.existingDescription || 'None'}"
+            FAILURES:
+            ${failureList}
+
+            RETURN JSON: { "description": "...", "metadata": { "fixed": [...], "reason": "..." } }
+        `;
+    }
+}
+/**
+ * SkillSynthesizer implements Pass 6 Ultra-Scale Orchestration.
+ */
+class SkillSynthesizer {
+    db;
+    cortex;
+    config;
+    evolutionConfig;
+    actionsTable;
+    strategy;
+    totalTokensConsumed = 0;
+    constructor(db, cortex, config = {}) {
+        this.db = db;
+        this.cortex = cortex;
+        this.config = config;
+        this.evolutionConfig = config.evolution || {
+            verificationWindow: 20,
+            rollbackThresholdZ: 2.5,
+            enableHiveLink: true,
+            mutationAggressiveness: 0.5,
+            maxSandboxSkills: 5,
+        };
+        this.actionsTable = config.actionsTable || 'agent_actions';
+        this.strategy = new AISynthesisStrategy(this.cortex, this);
+    }
+    /**
+     * Pass 6: Predictive Pre-warming Hook
+     * Called by CapabilityManager when an experimental skill nears promotion.
+     */
+    async preWarmSkill(name) {
+        const capability = await this.cortex.capabilities.getCapabilities('experimental');
+        const target = capability.find((c) => c.name === name);
+        if (!target)
+            return;
+        // Synthesis pre-run to ensure 'Verified' description is optimized before status change
+        const mutation = await this.strategy.synthesize({
+            targetTool: target.name,
+            failures: [], // No recent failures, just optimizing for permanence
+            existingDescription: target.description,
+            evolutionConfig: this.evolutionConfig,
+        });
+        await this.db
+            .updateTable(this.cortex.agenticConfig.capabilitiesTable ||
+            'agent_capabilities')
+            .set({
+            description: mutation.mutatedDescription,
+            metadata: JSON.stringify({
+                ...target.metadata,
+                pre_warmed: true,
+                pre_warmed_at: new Date(),
+            }),
+            updated_at: new Date(),
+        })
+            .where('name', '=', name)
+            .execute();
+    }
+    async discoverAndSynthesize() {
+        console.log('[SkillSynthesizer] Analyzing telemetry for parallel gaps (Ultra-Scale Batch)...');
+        const recentFailures = await this.db
+            .selectFrom(this.actionsTable)
+            .select(['tool_name', 'arguments', 'outcome', 'metadata', 'created_at'])
+            .where('status', '=', 'failure')
+            .orderBy('created_at', 'desc')
+            .limit(200)
+            .execute();
+        if (recentFailures.length < 3)
+            return [];
+        const failureClusters = new Map();
+        for (const f of recentFailures) {
+            const name = f.tool_name;
+            if (!failureClusters.has(name))
+                failureClusters.set(name, []);
+            failureClusters.get(name).push(f);
+        }
+        const targets = [];
+        for (const [name, list] of failureClusters.entries()) {
+            if (list.length >= 3)
+                targets.push({ tool: name, failures: list });
+        }
+        if (targets.length === 0)
+            return [];
+        const domainBatches = new Map();
+        for (const target of targets) {
+            const domain = target.tool.split('_')[0] || 'general';
+            if (!domainBatches.has(domain))
+                domainBatches.set(domain, []);
+            domainBatches.get(domain).push(target);
+        }
+        await this.pruneSandboxIfNeeded();
+        const results = [];
+        for (const [domain, items] of domainBatches.entries()) {
+            const contexts = await Promise.all(items.map(async (item) => {
+                return {
+                    targetTool: item.tool,
+                    failures: item.failures.map((f) => ({
+                        arguments: typeof f.arguments === 'string'
+                            ? JSON.parse(f.arguments)
+                            : f.arguments,
+                        error: f.outcome,
+                        timestamp: new Date(f.created_at),
+                    })),
+                    evolutionConfig: this.evolutionConfig,
+                };
+            }));
+            if (items.length > 1 && (this.cortex.llmFast || this.cortex.llm)) {
+                const batchMutations = await this.strategy.synthesizeBatch(contexts);
+                for (const bm of batchMutations) {
+                    const reg = await this.registerMutation(bm.tool, bm.mutation);
+                    if (reg)
+                        results.push(reg);
+                }
+            }
+            else {
+                for (const ctx of contexts) {
+                    const mutation = await this.strategy.synthesize(ctx);
+                    const reg = await this.registerMutation(ctx.targetTool, mutation);
+                    if (reg)
+                        results.push(reg);
+                }
+            }
+        }
+        return results;
+    }
+    async registerMutation(tool, mutation) {
+        return await this.cortex.capabilities.registerCapability(tool, mutation.version, mutation.mutatedDescription, {
+            initialStatus: 'experimental',
+            mutatedFrom: tool,
+            synthesis_engine: 'Ultra-Scale-Tiered',
+            ...mutation.mutatedMetadata,
+            synthesized_at: new Date(),
+        });
+    }
+    async pruneSandboxIfNeeded() {
+        const experimental = await this.cortex.capabilities.getCapabilities('experimental');
+        const maxSkills = this.evolutionConfig.maxSandboxSkills || 5;
+        if (experimental.length >= maxSkills) {
+            const toPrune = experimental
+                .sort((a, b) => a.reliability - b.reliability)
+                .slice(0, Math.ceil(experimental.length * 0.2));
+            for (const skill of toPrune) {
+                await this.db
+                    .deleteFrom(this.cortex.agenticConfig.capabilitiesTable ||
+                    'agent_capabilities')
+                    .where('id', '=', skill.id)
+                    .execute();
+            }
+        }
+    }
+}
+exports.SkillSynthesizer = SkillSynthesizer;

package/dist/cjs/agentic/improvement/SovereignMetrics.js

@@ -21,7 +21,7 @@ class SovereignMetrics {
      * Record a metric point
      */
     async recordMetric(metricName, metricValue, options = {}) {
-        const metric = await this.db
+        const metric = (await this.db
             .insertInto(this.metricsTable)
             .values({
             session_id: options.sessionId ?? null,
@@ -30,10 +30,10 @@ class SovereignMetrics {
             metric_value: metricValue,
             unit: options.unit ?? null,
             metadata: options.metadata ? JSON.stringify(options.metadata) : null,
-            created_at: new Date()
+            created_at: new Date(),
         })
             .returningAll()
-            .executeTakeFirstOrThrow();
+            .executeTakeFirstOrThrow());
         return this.parseMetric(metric);
     }
     /**
@@ -57,7 +57,7 @@ class SovereignMetrics {
             eb.fn.min('metric_value').as('min'),
             eb.fn.max('metric_value').as('max'),
             eb.fn.avg('metric_value').as('avg'),
-            eb.fn.count('id').as('count')
+            eb.fn.count('id').as('count'),
         ])
             .where('metric_name', '=', metricName);
         if (options.agentId) {
@@ -66,51 +66,51 @@ class SovereignMetrics {
         if (options.sessionId) {
             query = query.where('session_id', '=', options.sessionId);
         }
-        const result = await query.executeTakeFirst();
+        const result = (await query.executeTakeFirst());
         return {
             min: Number(result?.min || 0),
             max: Number(result?.max || 0),
             avg: Number(result?.avg || 0),
-            count: Number(result?.count || 0)
+            count: Number(result?.count || 0),
         };
     }
     /**
      * Get recent metrics for analysis
      */
     async getRecentMetrics(limit = 50) {
-        const list = await this.typedDb
+        const list = (await this.typedDb
             .selectFrom(this.metricsTable)
             .selectAll()
             .orderBy('created_at', 'desc')
             .limit(limit)
-            .execute();
-        return list.map(m => this.parseMetric(m));
+            .execute());
+        return list.map((m) => this.parseMetric(m));
     }
     /**
      * Get metrics filtered by agent ID.
      */
     async getMetricsByAgent(agentId, limit = 50) {
-        const list = await this.typedDb
+        const list = (await this.typedDb
             .selectFrom(this.metricsTable)
             .selectAll()
             .where('agent_id', '=', agentId)
             .orderBy('created_at', 'desc')
             .limit(limit)
-            .execute();
-        return list.map(m => this.parseMetric(m));
+            .execute());
+        return list.map((m) => this.parseMetric(m));
     }
     /**
      * Get metrics filtered by session ID.
      */
     async getMetricsBySession(sessionId, limit = 50) {
-        const list = await this.typedDb
+        const list = (await this.typedDb
             .selectFrom(this.metricsTable)
             .selectAll()
             .where('session_id', '=', sessionId)
             .orderBy('created_at', 'desc')
             .limit(limit)
-            .execute();
-        return list.map(m => this.parseMetric(m));
+            .execute());
+        return list.map((m) => this.parseMetric(m));
     }
     parseMetric(m) {
         return {
@@ -120,8 +120,10 @@ class SovereignMetrics {
             metricName: m.metric_name,
             metricValue: m.metric_value,
             unit: m.unit,
-            metadata: typeof m.metadata === 'string' ? JSON.parse(m.metadata) : (m.metadata || {}),
-            createdAt: new Date(m.created_at)
+            metadata: typeof m.metadata === 'string'
+                ? JSON.parse(m.metadata)
+                : m.metadata || {},
+            createdAt: new Date(m.created_at),
         };
     }
 }

package/dist/cjs/agentic/improvement/StrategicPlanner.d.ts

@@ -74,7 +74,7 @@ export declare class StrategicPlanner {
      */
     analyzePersona(id: string | number): Promise<PerformanceReport>;
     /**
-     * (Deprecated in favor of initiateAblationMutation) Evolve a persona directly.
+     * Evolve a persona directly based on performance.
      */
     evolvePersona(persona: AgentPersona, report: PerformanceReport): Promise<string | null>;
     /**