noormme 1.0.6 → 1.2.0

package/dist/esm/agentic/improvement/GovernanceManager.js

@@ -24,62 +24,83 @@ export class GovernanceManager {
     async performAudit() {
         const issues = [];
         // Fetch active policies
-        const policies = await this.db
+        const policies = (await this.db
             .selectFrom(this.policiesTable)
             .selectAll()
             .where('is_enabled', '=', true)
-            .execute();
+            .execute());
         const getPolicyValue = (name, type, fallback) => {
-            const p = policies.find(p => p.name === name || p.type === type);
+            const p = policies.find((p) => p.name === name || p.type === type);
             if (!p)
                 return fallback;
-            const def = typeof p.definition === 'string' ? JSON.parse(p.definition) : p.definition;
+            const def = typeof p.definition === 'string'
+                ? JSON.parse(p.definition)
+                : p.definition;
             return def.threshold ?? fallback;
         };
-        // 1. Check for cost spikes in the last hour
-        const budgetThreshold = getPolicyValue('hourly_budget', 'budget', 1.0);
-        const recentCost = await this.db
-            .selectFrom(this.metricsTable)
-            .select((eb) => eb.fn.sum('metric_value').as('total'))
-            .where('metric_name', '=', 'total_cost')
-            .where('created_at', '>', new Date(Date.now() - 3600000))
-            .executeTakeFirst();
-        const cost = Number(recentCost?.total || 0);
-        if (cost > budgetThreshold) {
-            issues.push(`Critical: High cost detected ($${cost.toFixed(2)} vs limit $${budgetThreshold})`);
+        // 1. Budgetary Governance: Check for cost spikes in various windows
+        const hourlyLimit = getPolicyValue('hourly_budget', 'budget', 1.0);
+        const dailyLimit = getPolicyValue('daily_budget', 'budget', 10.0);
+        const getCostInWindow = async (ms) => {
+            const result = await this.db
+                .selectFrom(this.metricsTable)
+                .select((eb) => eb.fn.sum('metric_value').as('total'))
+                .where('metric_name', '=', 'total_cost')
+                .where('created_at', '>', new Date(Date.now() - ms))
+                .executeTakeFirst();
+            return Number(result?.total || 0);
+        };
+        const hCost = await getCostInWindow(3600000);
+        if (hCost > hourlyLimit) {
+            issues.push(`Budget Violations: Hourly cost ($${hCost.toFixed(2)}) exceeded policy ($${hourlyLimit.toFixed(2)})`);
+        }
+        const dCost = await getCostInWindow(86400000);
+        if (dCost > dailyLimit) {
+            issues.push(`Budget Violations: Daily cumulative cost ($${dCost.toFixed(2)}) exceeded safety ceiling ($${dailyLimit.toFixed(2)})`);
         }
-        // 2. Check for success rate drop
-        const successThreshold = getPolicyValue('min_success_rate', 'safety', 0.5);
-        const avgSuccess = await this.db
+        // 2. Performance Governance: Success Rates & Success Stability
+        const minSuccess = getPolicyValue('min_success_rate', 'safety', 0.6);
+        // Statistical Success Rate (last 100 events)
+        const recentSuccess = await this.db
             .selectFrom(this.metricsTable)
             .select((eb) => eb.fn.avg('metric_value').as('avg'))
             .where('metric_name', '=', 'success_rate')
+            .orderBy('created_at', 'desc')
+            .limit(100)
             .executeTakeFirst();
-        const success = Number(avgSuccess?.avg || 1);
-        if (success < successThreshold) {
-            issues.push(`Critical: Success rate dropped to ${Math.round(success * 100)}% (limit ${successThreshold * 100}%)`);
+        const success = Number(recentSuccess?.avg || 1);
+        if (success < minSuccess) {
+            issues.push(`Performance Degradation: Rolling success rate (${Math.round(success * 100)}%) is below policy requirement (${minSuccess * 100}%)`);
+        }
+        // 3. Infrastructure Integrity: Reliability of Verified Skills
+        // Detect if any "verified" skills are participating in "failure" loops
+        const reliabiltyLimit = getPolicyValue('reliability_floor', 'integrity', 0.7);
+        const failingVerified = await this.db
+            .selectFrom(this.config.capabilitiesTable || 'agent_capabilities')
+            .select(['name', 'reliability'])
+            .where('status', '=', 'verified')
+            .where('reliability', '<', reliabiltyLimit)
+            .execute();
+        for (const cap of failingVerified) {
+            issues.push(`Integrity Failure: Verified skill '${cap.name}' reliability (${cap.reliability.toFixed(2)}) dropped below floor (${reliabiltyLimit})`);
         }
         if (issues.length > 0) {
-            console.warn(`[GovernanceManager] Audit failed: ${issues.join(', ')}`);
-            // Critical Self-Healing: If persona is in verification or success rate is catastrophically low
+            console.warn(`[GovernanceManager] AUDIT FAILED [${new Date().toISOString()}]: ${issues.length} compliance issues detected.`);
+            // Phase 1: Emergency Rollbacks
             const activePersona = await this.getActivePersona();
-            if (activePersona) {
-                const isVerifying = activePersona.metadata?.evolution_status === 'verifying';
-                if (isVerifying || success < 0.3) {
-                    const reason = isVerifying ? `Verification failed` : `Catastrophic failure`;
-                    console.error(`[GovernanceManager] ${reason} detected. Triggering emergency rollback for persona ${activePersona.id}`);
-                    await this.cortex.strategy.rollbackPersona(activePersona.id);
-                    issues.push(`Self-Healed: Triggered emergency rollback for persona ${activePersona.id} (${reason})`);
-                }
+            if (activePersona && (success < 0.4 || hCost > hourlyLimit * 1.5)) {
+                console.error(`[GovernanceManager] CRITICAL THRESHOLD BREACH. Initiating emergency containment for persona ${activePersona.id}`);
+                await this.cortex.strategy.rollbackPersona(activePersona.id);
+                issues.push(`Containment: Emergency rollback triggered for persona ${activePersona.id}`);
             }
-            // Automatically record a "Panic" reflection
-            await this.cortex.reflections.reflect(null, 'failure', 'Infrastructure Audit Failure', [`Issues found: ${issues.join('; ')}`]);
-            // Trigger remediation rituals (compression, pruning)
+            // Phase 2: Systemic Reflections
+            await this.cortex.reflections.reflect(null, 'failure', 'Governance Compliance Audit', issues);
+            // Phase 3: Remediation Rituals
             await this.triggerRemediation(issues);
         }
         return {
             healthy: issues.length === 0,
-            issues
+            issues,
         };
     }
     /**
@@ -89,28 +110,39 @@ export class GovernanceManager {
         const active = await this.db
             .selectFrom(this.personasTable)
             .selectAll()
-            .where('name', '=', 'default') // Or however we track the "active" one
+            .where('status', '=', 'active')
             .executeTakeFirst();
         if (!active)
             return null;
         return {
             ...active,
-            metadata: typeof active.metadata === 'string' ? JSON.parse(active.metadata) : (active.metadata || {})
+            metadata: typeof active.metadata === 'string'
+                ? JSON.parse(active.metadata)
+                : active.metadata || {},
         };
     }
     /**
-     * Trigger autonomous remediation steps
+     * Trigger autonomous remediation steps based on specific failure modes
      */
     async triggerRemediation(issues) {
-        console.log(`[GovernanceManager] Triggering automated remediation for ${issues.length} issues...`);
         for (const issue of issues) {
-            if (issue.includes('High cost')) {
-                // Immediate remediation: schedule emergency compression ritual
-                await this.cortex.rituals.scheduleRitual('Emergency Compression', 'compression', 'hourly', 'Governance triggered emergency compression due to high cost.', { priority: 'high', reason: issue });
+            if (issue.includes('Budget Violations')) {
+                await this.cortex.rituals.scheduleRitual('Budget Remediation', 'compression', 'hourly', `Automated response to: ${issue}`, { priority: 'critical', enforce_limits: true });
+            }
+            if (issue.includes('Performance Degradation')) {
+                await this.cortex.rituals.scheduleRitual('Reliability Sweep', 'pruning', 'daily', `Sanitizing high-noise memories due to: ${issue}`, { priority: 'medium', target: 'longtail' });
             }
-            if (issue.includes('Success rate')) {
-                // Immediate remediation: prune zombies and zombies
-                await this.cortex.rituals.scheduleRitual('Emergency Pruning', 'pruning', 'hourly', 'Governance triggered emergency pruning due to low success rate.', { priority: 'high', reason: issue });
+            if (issue.includes('Integrity Failure')) {
+                // Force demotion of the specific skill back to sandbox or experimental
+                const skillName = issue.match(/'([^']+)'/)?.[1];
+                if (skillName) {
+                    console.log(`[GovernanceManager] Demoting tainted skill out of verified pool: ${skillName}`);
+                    await this.db
+                        .updateTable(this.config.capabilitiesTable || 'agent_capabilities')
+                        .set({ status: 'experimental', updated_at: new Date() })
+                        .where('name', '=', skillName)
+                        .execute();
+                }
             }
         }
     }
@@ -135,11 +167,15 @@ export class GovernanceManager {
         const slowTables = new Set();
         for (const q of recentSlowQueries) {
             try {
-                const meta = typeof q.metadata === 'string' ? JSON.parse(q.metadata) : (q.metadata || {});
+                const meta = typeof q.metadata === 'string'
+                    ? JSON.parse(q.metadata)
+                    : q.metadata || {};
                 if (meta.table)
                     slowTables.add(meta.table);
             }
-            catch (e) { /* ignore parse errors */ }
+            catch (e) {
+                /* ignore parse errors */
+            }
         }
         for (const table of slowTables) {
             repairs.push(`Table '${table}' is experiencing periodic latency spikes. Suggesting 'CREATE INDEX' for common filters.`);
@@ -152,11 +188,11 @@ export class GovernanceManager {
         // 3. Check for cold storage candidates
         const sessionsTable = this.config.sessionsTable || 'agent_sessions';
         const oldThreshold = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000); // 30 days
-        const oldSessions = await this.db
+        const oldSessions = (await this.db
             .selectFrom(sessionsTable)
             .select((eb) => eb.fn.count('id').as('count'))
             .where('created_at', '<', oldThreshold)
-            .executeTakeFirst();
+            .executeTakeFirst());
         if (Number(oldSessions?.count || 0) > 100) {
             repairs.push(`[STORAGE OPTIMIZATION] Found ${oldSessions.count} sessions older than 30 days. Consider moving to cold storage to reduce primary database size and improve backup speed.`);
         }

package/dist/esm/agentic/improvement/HiveLink.d.ts

@@ -22,4 +22,13 @@ export declare class HiveLink {
      * Increases confidence of all items with this tag, representing "domain mastery".
      */
     syncDomain(domainTag: string, boostFactor?: number): Promise<number>;
+    /**
+     * Propagate high-performing capabilities globally and block known-bad ones.
+     * High-Throughput Refactor: Batch updates and optimized set-based checks.
+     */
+    broadcastSkills(): Promise<number>;
+    /**
+     * Simple semver-style version comparison.
+     */
+    private compareVersions;
 }

package/dist/esm/agentic/improvement/HiveLink.js

@@ -1,4 +1,5 @@
 /// <reference types="./HiveLink.d.ts" />
+import { sql } from '../../raw-builder/sql.js';
 /**
  * HiveLink facilitates "Collective Intelligence" by synchronizing
  * knowledge and lessons learned across different agent personas.
@@ -24,12 +25,12 @@ export class HiveLink {
     async broadcastKnowledge(minConfidence = 0.9) {
         console.log(`[HiveLink] Broadcasting knowledge with confidence >= ${minConfidence}`);
         // Find high-confidence items that are "local" (have a source_session_id)
-        const items = await this.typedDb
+        const items = (await this.typedDb
             .selectFrom(this.knowledgeTable)
             .selectAll()
             .where('confidence', '>=', minConfidence)
             .where('source_session_id', 'is not', null) // Only local items
-            .execute();
+            .execute());
         let promotedCount = 0;
         for (const item of items) {
             // Check if a global version already exists
@@ -48,7 +49,7 @@ export class HiveLink {
                     .updateTable(this.knowledgeTable)
                     .set({
                     confidence: newConfidence,
-                    updated_at: new Date()
+                    updated_at: new Date(),
                 })
                     .where('id', '=', existingGlobal.id)
                     .execute();
@@ -69,10 +70,10 @@ export class HiveLink {
                     metadata: JSON.stringify({
                         ...item.metadata,
                         promoted_from: item.id,
-                        promoted_at: new Date()
+                        promoted_at: new Date(),
                     }),
                     created_at: new Date(),
-                    updated_at: new Date()
+                    updated_at: new Date(),
                 })
                     .execute();
                 promotedCount++;
@@ -85,29 +86,122 @@ export class HiveLink {
      * Increases confidence of all items with this tag, representing "domain mastery".
      */
     async syncDomain(domainTag, boostFactor = 0.05) {
-        console.log(`[HiveLink] Syncing/Boosting domain '${domainTag}'`);
-        // Find items with this tag
-        // Note: simplified tag matching using LIKE for JSON array
-        const items = await this.typedDb
-            .selectFrom(this.knowledgeTable)
-            .selectAll()
+        console.log(`[HiveLink] Syncing/Boosting domain '${domainTag}' (Set-Based)`);
+        // Use a single SQL update for high throughput
+        const result = await this.db
+            .updateTable(this.knowledgeTable)
+            .set({
+            confidence: sql `MIN(1.0, confidence + ${boostFactor})`,
+            updated_at: new Date(),
+        })
             .where('tags', 'like', `%"${domainTag}"%`)
+            .where('confidence', '<', 1.0)
             .execute();
-        let updatedCount = 0;
-        for (const item of items) {
-            if (item.confidence >= 1.0)
-                continue;
-            const newConfidence = Math.min(1.0, item.confidence + boostFactor);
-            await this.db
-                .updateTable(this.knowledgeTable)
-                .set({
-                confidence: newConfidence,
-                updated_at: new Date()
-            })
-                .where('id', '=', item.id)
-                .execute();
-            updatedCount++;
+        // Kysely update .execute() returns an array of results or similar depending on adapter
+        // For simple update, we might just return the count if supported or 1
+        return Number(result[0]?.numUpdatedRows ?? 1);
+    }
+    /**
+     * Propagate high-performing capabilities globally and block known-bad ones.
+     * High-Throughput Refactor: Batch updates and optimized set-based checks.
+     */
+    async broadcastSkills() {
+        if (!this.config.evolution?.enableHiveLink &&
+            this.config.evolution !== undefined) {
+            console.log('[HiveLink] Skill broadcasting disabled by config.');
+            return 0;
+        }
+        console.log(`[HiveLink] Broadcasting emergent skills across the Hive (Performance-Aware)...`);
+        let broadcastCount = 0;
+        const capTable = this.config.capabilitiesTable || 'agent_capabilities';
+        await this.db.transaction().execute(async (trx) => {
+            // 1. Resolve Verified Skills with "Survival of the Fittest" logic
+            const verifiedSkills = await this.cortex.capabilities.getCapabilities('verified');
+            for (const skill of verifiedSkills) {
+                const meta = typeof skill.metadata === 'string'
+                    ? JSON.parse(skill.metadata)
+                    : skill.metadata || {};
+                if (meta.broadcasted)
+                    continue;
+                // Check for competing global versions
+                const baseName = meta.mutatedFrom || skill.name;
+                const competitor = await trx
+                    .selectFrom(capTable)
+                    .selectAll()
+                    .where('name', 'like', `%${baseName}%`)
+                    .where('status', '=', 'verified')
+                    .where('id', '!=', skill.id)
+                    .executeTakeFirst();
+                let shouldBroadcast = true;
+                if (competitor) {
+                    const comp = competitor;
+                    const compRel = comp.reliability || 0;
+                    // Performance-Based Conflict Resolution: Only broadcast if reliability is strictly better
+                    // or if it's a direct version upgrade with equal/better reliability
+                    const isNewer = this.compareVersions(skill.version, comp.version) > 0;
+                    if (compRel > skill.reliability) {
+                        shouldBroadcast = false;
+                    }
+                    else if (compRel === skill.reliability && !isNewer) {
+                        shouldBroadcast = false;
+                    }
+                }
+                if (shouldBroadcast) {
+                    await trx
+                        .updateTable(capTable)
+                        .set({
+                        metadata: JSON.stringify({
+                            ...meta,
+                            broadcasted: true,
+                            hive_verified: true,
+                            broadcasted_at: new Date(),
+                            conflict_resolved: !!competitor,
+                        }),
+                    })
+                        .where('id', '=', skill.id)
+                        .execute();
+                    broadcastCount++;
+                }
+            }
+            // 2. Broadcast Blacklisted Skills (Immediate Immune Propagations)
+            const blacklisted = await this.cortex.capabilities.getCapabilities('blacklisted');
+            for (const skill of blacklisted) {
+                const meta = typeof skill.metadata === 'string'
+                    ? JSON.parse(skill.metadata)
+                    : skill.metadata || {};
+                if (!meta.broadcasted) {
+                    await trx
+                        .updateTable(capTable)
+                        .set({
+                        metadata: JSON.stringify({
+                            ...meta,
+                            broadcasted: true,
+                            hive_blacklisted: true,
+                            blocked_at: new Date(),
+                        }),
+                    })
+                        .where('id', '=', skill.id)
+                        .execute();
+                    broadcastCount++;
+                }
+            }
+        });
+        return broadcastCount;
+    }
+    /**
+     * Simple semver-style version comparison.
+     */
+    compareVersions(v1, v2) {
+        const p1 = v1.split('.').map(Number);
+        const p2 = v2.split('.').map(Number);
+        for (let i = 0; i < Math.max(p1.length, p2.length); i++) {
+            const num1 = p1[i] || 0;
+            const num2 = p2[i] || 0;
+            if (num1 > num2)
+                return 1;
+            if (num2 > num1)
+                return -1;
         }
-        return updatedCount;
+        return 0;
     }
 }

package/dist/esm/agentic/improvement/KnowledgeDistiller.d.ts

@@ -34,6 +34,7 @@ export declare class KnowledgeDistiller {
     private config;
     private knowledgeTable;
     private linksTable;
+    private bloomFilter;
     constructor(db: Kysely<any>, // accepting any Kysely but casting internally for our specific tables
     config?: AgenticConfig);
     /**
@@ -100,5 +101,6 @@ export declare class KnowledgeDistiller {
      */
     consolidateKnowledge(): Promise<number>;
     private mergeItems;
+    private bloomHash;
     private parseKnowledge;
 }