noormme 1.2.0 → 1.2.1

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

@@ -25,91 +25,122 @@ class GovernanceManager {
      */
     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;
-        };
-        // 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. 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.`);
-            // 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}`);
+        return await this.db.transaction().execute(async (trx) => {
+            // 0. Emergent Behavior Validation (Phase 2 Safety)
+            const emergentIssues = await this.validateEmergentBehavior(trx);
+            issues.push(...emergentIssues);
+            // Fetch active policies within transaction
+            const policies = (await trx
+                .selectFrom(this.policiesTable)
+                .selectAll()
+                .where('is_enabled', '=', true)
+                .execute());
+            const getPolicyValue = (name, type, strict = true) => {
+                const p = policies.find((p) => p.name === name || p.type === type);
+                if (!p) {
+                    if (strict)
+                        throw new Error(`Governance Violation: Required policy '${name}' or type '${type}' not found.`);
+                    return null;
+                }
+                const def = typeof p.definition === 'string'
+                    ? JSON.parse(p.definition)
+                    : p.definition;
+                return def.threshold ?? def.limit ?? 0;
+            };
+            try {
+                // 1. Budgetary Governance: Check for cost spikes in various windows
+                const hourlyLimit = getPolicyValue('hourly_budget', 'budget');
+                const dailyLimit = getPolicyValue('daily_budget', 'budget');
+                const getCostInWindow = async (ms) => {
+                    const result = await trx
+                        .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 && hourlyLimit > 0) {
+                    issues.push(`Budget Violations: Hourly cost ($${hCost.toFixed(2)}) exceeded policy ($${hourlyLimit.toFixed(2)})`);
+                }
+                const dCost = await getCostInWindow(86400000);
+                if (dCost > dailyLimit && dailyLimit > 0) {
+                    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');
+                // Statistical Success Rate (last 100 events)
+                const recentSuccess = await trx
+                    .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}%)`);
+                }
+                // 2b. Swarm Quota Governance: Real-time quota validation
+                const activePersona = await this.getActivePersona(trx);
+                if (activePersona) {
+                    const quotaCheck = await this.cortex.quotas.checkQuota('persona', activePersona.id);
+                    if (!quotaCheck.allowed) {
+                        issues.push(`Quota Breach: ${quotaCheck.reason}`);
+                    }
+                    // Check for swarm-level quotas if part of a swarm
+                    const swarmId = activePersona.metadata?.swarm_id;
+                    if (swarmId) {
+                        const swarmCheck = await this.cortex.quotas.checkQuota('swarm', swarmId);
+                        if (!swarmCheck.allowed) {
+                            issues.push(`Swarm Quota Breach [${swarmId}]: ${swarmCheck.reason}`);
+                        }
+                    }
+                }
+                // 3. Infrastructure Integrity: Reliability of Verified Skills
+                const reliabiltyLimit = getPolicyValue('reliability_floor', 'integrity');
+                const failingVerified = await trx
+                    .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.`);
+                    // Phase 1: Emergency Rollbacks
+                    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}`);
+                    }
+                    // Phase 2: Systemic Reflections
+                    await this.cortex.reflections.reflect(null, 'failure', 'Governance Compliance Audit', issues);
+                    // Phase 3: Remediation Rituals (Transactional)
+                    await this.triggerRemediation(issues, trx);
+                }
+                return {
+                    healthy: issues.length === 0,
+                    issues,
+                };
             }
-            // Phase 2: Systemic Reflections
-            await this.cortex.reflections.reflect(null, 'failure', 'Governance Compliance Audit', issues);
-            // Phase 3: Remediation Rituals
-            await this.triggerRemediation(issues);
-        }
+            catch (e) {
+                console.error(`[GovernanceManager] STRICT AUDIT FAILURE: ${String(e)}`);
+                issues.push(`Strict Mode Failure: ${String(e)}`);
+                return { healthy: false, issues };
+            }
+        });
         return {
             healthy: issues.length === 0,
             issues,
         };
     }
-    /**
-     * Retrieves the currently active persona.
-     */
-    async getActivePersona() {
-        const active = await this.db
+    async getActivePersona(trx) {
+        const db = trx || this.db;
+        const active = await db
             .selectFrom(this.personasTable)
             .selectAll()
             .where('status', '=', 'active')
@@ -124,9 +155,93 @@ class GovernanceManager {
         };
     }
     /**
-     * Trigger autonomous remediation steps based on specific failure modes
+     * Quarantine a persona that is behaving outside safety parameters.
+     */
+    async quarantinePersona(id, reason) {
+        console.warn(`[GovernanceManager] QUARANTINING Persona ${id}: ${reason}`);
+        await this.db.transaction().execute(async (trx) => {
+            let query = trx
+                .selectFrom(this.personasTable)
+                .selectAll()
+                .where('id', '=', id);
+            // Audit Phase 13: Atomic identity lock (Skip for SQLite)
+            if (this.db.getExecutor().adapter?.constructor.name !== 'SqliteAdapter') {
+                query = query.forUpdate();
+            }
+            const persona = await query.executeTakeFirst();
+            if (persona) {
+                const metadata = typeof persona.metadata === 'string'
+                    ? JSON.parse(persona.metadata)
+                    : persona.metadata || {};
+                await trx
+                    .updateTable(this.personasTable)
+                    .set({
+                    status: 'quarantined',
+                    metadata: JSON.stringify({
+                        ...metadata,
+                        quarantine_reason: reason,
+                        quarantined_at: new Date(),
+                    }),
+                    updated_at: new Date(),
+                })
+                    .where('id', '=', id)
+                    .execute();
+                // Phase 3: Rollback most recent changes
+                await this.cortex.strategy.rollbackPersona(id);
+            }
+        });
+    }
+    /**
+     * Blacklist a skill that is causing systemic issues.
+     */
+    async quarantineSkill(name, reason) {
+        const capTable = this.config.capabilitiesTable || 'agent_capabilities';
+        console.warn(`[GovernanceManager] BLACKLISTING Skill ${name}: ${reason}`);
+        await this.db
+            .updateTable(capTable)
+            .set({
+            status: 'blacklisted',
+            metadata: JSON.stringify({ blacklist_reason: reason, blacklisted_at: new Date() }),
+            updated_at: new Date()
+        })
+            .where('name', '=', name)
+            .execute();
+    }
+    /**
+     * Monitor cross-node behaviors and flag sudden spikes or malicious patterns.
      */
-    async triggerRemediation(issues) {
+    async validateEmergentBehavior(trx) {
+        const issues = [];
+        const db = trx || this.db;
+        // 1. Check for rapid propagation of new skills (Potential poisoning)
+        const capTable = this.config.capabilitiesTable || 'agent_capabilities';
+        const recentSkills = await db
+            .selectFrom(capTable)
+            .select(['name', 'created_at'])
+            .where('created_at', '>', new Date(Date.now() - 3600000)) // Last hour
+            .execute();
+        if (recentSkills.length > 10) {
+            issues.push(`Emergent Warning: Rapid skill propagation detected (${recentSkills.length} new skills in 1hr). Potential rogue behavior.`);
+        }
+        // 2. Check for high variance in task success across swarm
+        const recentTaskMetrics = await db
+            .selectFrom(this.metricsTable)
+            .select(['metric_value', 'metadata'])
+            .where('metric_name', '=', 'task_success_rate')
+            .where('created_at', '>', new Date(Date.now() - 1800000)) // Last 30m
+            .execute();
+        if (recentTaskMetrics.length >= 5) {
+            const values = recentTaskMetrics.map((m) => Number(m.metric_value));
+            const mean = values.reduce((a, b) => a + b, 0) / values.length;
+            const variance = values.reduce((a, b) => a + Math.pow(b - mean, 2), 0) / values.length;
+            if (variance > 0.2) {
+                issues.push(`Emergent Warning: High variance in swarm success rate (${(variance * 100).toFixed(1)}%). Potential node instability.`);
+            }
+        }
+        return issues;
+    }
+    async triggerRemediation(issues, trx) {
+        const db = trx || this.db;
         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 });
@@ -135,17 +250,36 @@ class GovernanceManager {
                 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
+                // Audit Phase 10: Atomic demotion lock
                 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();
+                    const remediationStep = async (t) => {
+                        const skill = await t
+                            .selectFrom(this.config.capabilitiesTable || 'agent_capabilities')
+                            .select('id')
+                            .where('name', '=', skillName)
+                            .forUpdate() // Lock the skill row
+                            .executeTakeFirst();
+                        if (skill) {
+                            await t
+                                .updateTable(this.config.capabilitiesTable || 'agent_capabilities')
+                                .set({ status: 'experimental', updated_at: new Date() })
+                                .where('id', '=', skill.id)
+                                .execute();
+                        }
+                    };
+                    if (trx) {
+                        await remediationStep(trx);
+                    }
+                    else {
+                        await this.db.transaction().execute(remediationStep);
+                    }
                 }
             }
+            if (issue.includes('Quota Breach') || issue.includes('Swarm Quota Breach')) {
+                await this.cortex.rituals.scheduleRitual('Resource Throttling', 'pruning', 'hourly', `Critical resource containment: ${issue}`, { priority: 'critical', active_containment: true });
+            }
         }
     }
     /**
@@ -155,7 +289,13 @@ class GovernanceManager {
         const repairs = [];
         // 1. Check for chronic high latency
         const latencyStats = await this.cortex.metrics.getMetricStats('query_latency');
-        if (latencyStats.avg > 500 && latencyStats.count > 10) {
+        const latencyThreshold = (await this.cortex.policies.checkPolicy('query_latency_threshold', 0)).reason ? 500 : 500; // Logic to pull from policy if possible, else 500
+        // PRODUCTION HARDENING: Pull thresholds from explicit governance policies
+        const policies = await this.cortex.policies.getActivePolicies();
+        const latencyPolicy = policies.find(p => p.name === 'latency_repair_threshold')?.definition?.threshold || 500;
+        const costPolicy = policies.find(p => p.name === 'high_cost_threshold')?.definition?.threshold || 0.5;
+        const storagePolicy = policies.find(p => p.name === 'cold_storage_threshold')?.definition?.days || 30;
+        if (latencyStats.avg > latencyPolicy && 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
@@ -163,7 +303,7 @@ class GovernanceManager {
             .selectFrom(this.metricsTable)
             .select('metadata')
             .where('metric_name', '=', 'query_latency')
-            .where('metric_value', '>', 1000)
+            .where('metric_value', '>', latencyPolicy * 2)
             .limit(20)
             .execute();
         const slowTables = new Set();
@@ -184,19 +324,19 @@ class GovernanceManager {
         }
         // 3. Check for high cost accumulation
         const totalCost = await this.cortex.metrics.getAverageMetric('total_cost');
-        if (totalCost > 0.5) {
+        if (totalCost > costPolicy) {
             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 oldThreshold = new Date(Date.now() - storagePolicy * 24 * 60 * 60 * 1000);
         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.`);
+            repairs.push(`[STORAGE OPTIMIZATION] Found ${oldSessions.count} sessions older than ${storagePolicy} days. Consider moving to cold storage to reduce primary database size and improve backup speed.`);
         }
         return repairs;
     }

package/dist/cjs/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>;
     /**