noormme 1.2.0 → 1.2.2

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

@@ -1,7 +1,16 @@
 /// <reference types="./GovernanceManager.d.ts" />
+import { BudgetAuditor } from './governance/BudgetAuditor.js';
+import { PerformanceAuditor } from './governance/PerformanceAuditor.js';
+import { PersonaAuditor } from './governance/PersonaAuditor.js';
+import { SkillAuditor } from './governance/SkillAuditor.js';
+import { EmergenceAuditor } from './governance/EmergenceAuditor.js';
+import { RemediationEngine } from './governance/RemediationEngine.js';
+import { MaintenanceOracle } from './governance/MaintenanceOracle.js';
 /**
  * GovernanceManager monitors agent performance and enforces high-level "sanity"
  * across the entire agentic infrastructure.
+ *
+ * Refactored to delegate specialized auditing to modular components.
  */
 export class GovernanceManager {
     db;
@@ -10,6 +19,14 @@ export class GovernanceManager {
     metricsTable;
     policiesTable;
     personasTable;
+    skillsTable;
+    budgetAuditor;
+    performanceAuditor;
+    personaAuditor;
+    skillAuditor;
+    emergenceAuditor;
+    remediationEngine;
+    maintenanceOracle;
     constructor(db, cortex, config = {}) {
         this.db = db;
         this.cortex = cortex;
@@ -17,185 +34,147 @@ export class GovernanceManager {
         this.metricsTable = config.metricsTable || 'agent_metrics';
         this.policiesTable = config.policiesTable || 'agent_policies';
         this.personasTable = config.personasTable || 'agent_personas';
+        this.skillsTable = config.capabilitiesTable || 'agent_capabilities';
+        this.budgetAuditor = new BudgetAuditor();
+        this.performanceAuditor = new PerformanceAuditor();
+        this.personaAuditor = new PersonaAuditor();
+        this.skillAuditor = new SkillAuditor();
+        this.emergenceAuditor = new EmergenceAuditor();
+        this.remediationEngine = new RemediationEngine();
+        this.maintenanceOracle = new MaintenanceOracle();
     }
     /**
      * Perform a "Panic Check" - looking for critical failures or cost overruns
      */
     async performAudit() {
-        const issues = [];
-        // Fetch active policies
-        const policies = (await this.db
-            .selectFrom(this.policiesTable)
-            .selectAll()
-            .where('is_enabled', '=', true)
-            .execute());
-        const getPolicyValue = (name, type, fallback) => {
-            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;
-            return def.threshold ?? fallback;
+        const issuesList = [];
+        let auditMetadata = {};
+        // Execute core audit gathering phase
+        const ctx = {
+            db: this.db,
+            trx: this.db,
+            cortex: this.cortex,
+            config: this.config,
+            metricsTable: this.metricsTable,
+            policiesTable: this.policiesTable,
+            personasTable: this.personasTable,
+            skillsTable: this.skillsTable
         };
-        // 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);
+        // Run all auditors
+        const budget = await this.budgetAuditor.audit(ctx);
+        const performance = await this.performanceAuditor.audit(ctx);
+        const persona = await this.personaAuditor.audit(ctx);
+        const skills = await this.skillAuditor.audit(ctx);
+        const emergence = await this.emergenceAuditor.audit(ctx);
+        const pooledIssues = [
+            ...budget.issues,
+            ...performance.issues,
+            ...persona.issues,
+            ...skills.issues,
+            ...emergence.issues
+        ];
+        const coreAuditResult = {
+            issues: pooledIssues,
+            metadata: {
+                ...budget.metadata,
+                ...performance.metadata,
+                ...persona.metadata,
+                ...skills.metadata,
+                ...emergence.metadata
+            }
         };
-        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. 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(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 [${new Date().toISOString()}]: ${issues.length} compliance issues detected.`);
+        issuesList.push(...coreAuditResult.issues);
+        if (issuesList.length > 0) {
+            console.warn(`[GovernanceManager] AUDIT FAILED [${new Date().toISOString()}]: ${issuesList.length} compliance issues detected.`);
+            const { activePersona, success, hCost, hourlyLimit } = coreAuditResult.metadata;
             // Phase 1: Emergency Rollbacks
-            const activePersona = await this.getActivePersona();
             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}`);
+                await this.personaAuditor.quarantinePersona({ db: this.db, cortex: this.cortex }, activePersona.id, 'Critical threshold breach');
+                issuesList.push(`Containment: Emergency rollback triggered for persona ${activePersona.id}`);
             }
-            // Phase 2: Systemic Reflections
-            await this.cortex.reflections.reflect(null, 'failure', 'Governance Compliance Audit', issues);
+            await this.cortex.reflections.reflect(null, 'failure', 'Governance Compliance Audit', issuesList);
             // Phase 3: Remediation Rituals
-            await this.triggerRemediation(issues);
+            const ctx = {
+                db: this.db,
+                trx: this.db, // Standalone remediation
+                cortex: this.cortex,
+                config: this.config,
+                metricsTable: this.metricsTable,
+                policiesTable: this.policiesTable,
+                personasTable: this.personasTable,
+                skillsTable: this.skillsTable
+            };
+            await this.remediationEngine.triggerRemediation(ctx, issuesList);
         }
         return {
-            healthy: issues.length === 0,
-            issues,
+            healthy: issuesList.length === 0,
+            issues: issuesList,
         };
     }
     /**
-     * Retrieves the currently active persona.
+     * Suggest architectural repairs if performance is degrading
      */
-    async getActivePersona() {
-        const active = await this.db
-            .selectFrom(this.personasTable)
-            .selectAll()
-            .where('status', '=', 'active')
-            .executeTakeFirst();
-        if (!active)
-            return null;
-        return {
-            ...active,
-            metadata: typeof active.metadata === 'string'
-                ? JSON.parse(active.metadata)
-                : active.metadata || {},
+    async suggestRepairs() {
+        const ctx = {
+            db: this.db,
+            trx: this.db,
+            cortex: this.cortex,
+            config: this.config,
+            metricsTable: this.metricsTable,
+            policiesTable: this.policiesTable,
+            personasTable: this.personasTable,
+            skillsTable: this.skillsTable
         };
+        return this.maintenanceOracle.suggestRepairs(ctx);
     }
     /**
-     * Trigger autonomous remediation steps based on specific failure modes
+     * Quarantine a persona that is behaving outside safety parameters.
      */
-    async triggerRemediation(issues) {
-        for (const issue of issues) {
-            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('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();
-                }
-            }
-        }
+    async quarantinePersona(id, reason) {
+        const ctx = {
+            db: this.db,
+            trx: this.db,
+            cortex: this.cortex,
+            config: this.config,
+            metricsTable: this.metricsTable,
+            policiesTable: this.policiesTable,
+            personasTable: this.personasTable,
+            skillsTable: this.skillsTable
+        };
+        return this.personaAuditor.quarantinePersona(ctx, id, reason);
     }
     /**
-     * Suggest architectural repairs if performance is degrading
+     * Blacklist a skill that is causing systemic issues.
      */
-    async suggestRepairs() {
-        const repairs = [];
-        // 1. Check for chronic high latency
-        const latencyStats = await this.cortex.metrics.getMetricStats('query_latency');
-        if (latencyStats.avg > 500 && latencyStats.count > 10) {
-            repairs.push(`Average latency is high (${latencyStats.avg.toFixed(2)}ms). Suggesting index audit across hit tables.`);
-        }
-        // 2. Detect specific slow tables from recent metrics
-        const recentSlowQueries = await this.db
-            .selectFrom(this.metricsTable)
-            .select('metadata')
-            .where('metric_name', '=', 'query_latency')
-            .where('metric_value', '>', 1000)
-            .limit(20)
-            .execute();
-        const slowTables = new Set();
-        for (const q of recentSlowQueries) {
-            try {
-                const meta = typeof q.metadata === 'string'
-                    ? JSON.parse(q.metadata)
-                    : q.metadata || {};
-                if (meta.table)
-                    slowTables.add(meta.table);
-            }
-            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.`);
-        }
-        // 3. Check for high cost accumulation
-        const totalCost = await this.cortex.metrics.getAverageMetric('total_cost');
-        if (totalCost > 0.5) {
-            repairs.push('Average query cost is high. Suggesting prompt compression or model switching (e.g., to a smaller model).');
-        }
-        // 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
-            .selectFrom(sessionsTable)
-            .select((eb) => eb.fn.count('id').as('count'))
-            .where('created_at', '<', oldThreshold)
-            .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.`);
-        }
-        return repairs;
+    async quarantineSkill(name, reason) {
+        const ctx = {
+            db: this.db,
+            trx: this.db,
+            cortex: this.cortex,
+            config: this.config,
+            metricsTable: this.metricsTable,
+            policiesTable: this.policiesTable,
+            personasTable: this.personasTable,
+            skillsTable: this.skillsTable
+        };
+        return this.skillAuditor.quarantineSkill(ctx, name, reason);
+    }
+    /**
+     * Monitor cross-node behaviors and flag sudden spikes or malicious patterns.
+     */
+    async validateEmergentBehavior(trx) {
+        const ctx = {
+            db: this.db,
+            trx: trx || this.db,
+            cortex: this.cortex,
+            config: this.config,
+            metricsTable: this.metricsTable,
+            policiesTable: this.policiesTable,
+            personasTable: this.personasTable,
+            skillsTable: this.skillsTable
+        };
+        const result = await this.emergenceAuditor.audit(ctx);
+        return result.issues;
     }
 }

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

@@ -16,15 +16,19 @@ export declare class HiveLink {
      * Promote high-confidence local knowledge to global "Hive" knowledge.
      * This creates a new, session-agnostic entry or updates an existing global one.
      */
-    broadcastKnowledge(minConfidence?: number): Promise<number>;
+    broadcastKnowledge(options?: {
+        minConfidence?: number;
+        limit?: number;
+        offset?: number;
+    }): Promise<number>;
     /**
      * Strengthen knowledge related to a specific domain (tag).
      * 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.
+     * Propagate high-performing capabilities globally using the "Sovereign Draft" protocol.
+     * Uses Bayesian Convergence and Shadow Promotion to avoid deadlocks.
      */
     broadcastSkills(): Promise<number>;
     /**