noormme 1.2.1 → 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,325 +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 = [];
-        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,
-                };
+        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
+        };
+        // 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
             }
-            catch (e) {
-                console.error(`[GovernanceManager] STRICT AUDIT FAILURE: ${String(e)}`);
-                issues.push(`Strict Mode Failure: ${String(e)}`);
-                return { healthy: false, issues };
+        };
+        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
+            if (activePersona && (success < 0.4 || hCost > hourlyLimit * 1.5)) {
+                console.error(`[GovernanceManager] CRITICAL THRESHOLD BREACH. Initiating emergency containment 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}`);
             }
-        });
+            await this.cortex.reflections.reflect(null, 'failure', 'Governance Compliance Audit', issuesList);
+            // Phase 3: Remediation Rituals
+            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,
         };
     }
-    async getActivePersona(trx) {
-        const db = trx || this.db;
-        const active = await 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 || {},
+    /**
+     * Suggest architectural repairs if performance is degrading
+     */
+    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);
     }
     /**
      * 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);
-            }
-        });
+        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);
     }
     /**
      * 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();
+        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 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 });
-            }
-            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')) {
-                // Audit Phase 10: Atomic demotion lock
-                const skillName = issue.match(/'([^']+)'/)?.[1];
-                if (skillName) {
-                    console.log(`[GovernanceManager] Demoting tainted skill out of verified pool: ${skillName}`);
-                    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 });
-            }
-        }
-    }
-    /**
-     * Suggest architectural repairs if performance is degrading
-     */
-    async suggestRepairs() {
-        const repairs = [];
-        // 1. Check for chronic high latency
-        const latencyStats = await this.cortex.metrics.getMetricStats('query_latency');
-        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
-        const recentSlowQueries = await this.db
-            .selectFrom(this.metricsTable)
-            .select('metadata')
-            .where('metric_name', '=', 'query_latency')
-            .where('metric_value', '>', latencyPolicy * 2)
-            .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 > 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() - 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 ${storagePolicy} days. Consider moving to cold storage to reduce primary database size and improve backup speed.`);
-        }
-        return repairs;
+        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/QuotaManager.js

@@ -59,7 +59,7 @@ export class QuotaManager {
                     targetType: targetType,
                     targetId: targetId,
                     metric: policy.definition.metric || 'cost',
-                    limit: policy.definition.limit || 0,
+                    limit: policy.definition.limit ?? policy.definition.threshold ?? 0,
                     period: policy.definition.period || 'hourly',
                     currentUsage: 0,
                     createdAt: policy.createdAt,

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

@@ -80,6 +80,7 @@ export class SelfEvolution {
             .addColumn('evolution_path', 'text') // JSON array of pivots
             .addColumn('autonomy_level', 'integer')
             .addColumn('status', 'text') // success, abandoned, pivoted
+            .addColumn('metadata', 'text') // JSON - used by CognitiveSynthesizer
             .addColumn('updated_at', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`))
             .execute();
         // 3. Research Metrics (The Alchemist's Output)

package/dist/esm/agentic/improvement/governance/AuditContext.d.ts

@@ -0,0 +1,17 @@
+import type { Kysely } from '../../../kysely.js';
+import type { AgenticConfig } from '../../../types/index.js';
+import type { Cortex } from '../../Cortex.js';
+export interface AuditContext {
+    db: Kysely<any>;
+    trx: Kysely<any>;
+    cortex: Cortex;
+    config: AgenticConfig;
+    metricsTable: string;
+    policiesTable: string;
+    personasTable: string;
+    skillsTable: string;
+}
+export interface AuditResult {
+    issues: string[];
+    metadata: Record<string, any>;
+}

package/dist/esm/agentic/improvement/governance/AuditContext.js

@@ -0,0 +1,2 @@
+/// <reference types="./AuditContext.d.ts" />
+export {};

package/dist/esm/agentic/improvement/governance/BudgetAuditor.d.ts

@@ -0,0 +1,4 @@
+import type { AuditContext, AuditResult } from './AuditContext.js';
+export declare class BudgetAuditor {
+    audit(ctx: AuditContext): Promise<AuditResult>;
+}

package/dist/esm/agentic/improvement/governance/BudgetAuditor.js

@@ -0,0 +1,47 @@
+/// <reference types="./BudgetAuditor.d.ts" />
+export class BudgetAuditor {
+    async audit(ctx) {
+        const issues = [];
+        // Fetch budget policies
+        const policies = (await ctx.trx
+            .selectFrom(ctx.policiesTable)
+            .selectAll()
+            .where('is_enabled', '=', true)
+            .where((eb) => eb.or([
+            eb('name', '=', 'hourly_budget'),
+            eb('name', '=', 'daily_budget'),
+            eb('type', '=', 'budget')
+        ]))
+            .execute());
+        const getLimit = (name) => {
+            const p = policies.find(p => p.name === name);
+            if (!p)
+                return 0;
+            const def = typeof p.definition === 'string' ? JSON.parse(p.definition) : p.definition;
+            return def.threshold ?? def.limit ?? 0;
+        };
+        const hourlyLimit = getLimit('hourly_budget');
+        const dailyLimit = getLimit('daily_budget');
+        const getCostInWindow = async (ms) => {
+            const result = await ctx.trx
+                .selectFrom(ctx.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)})`);
+        }
+        return {
+            issues,
+            metadata: { hCost, hourlyLimit, dCost, dailyLimit }
+        };
+    }
+}

package/dist/esm/agentic/improvement/governance/EmergenceAuditor.d.ts

@@ -0,0 +1,4 @@
+import type { AuditContext, AuditResult } from './AuditContext.js';
+export declare class EmergenceAuditor {
+    audit(ctx: AuditContext): Promise<AuditResult>;
+}

package/dist/esm/agentic/improvement/governance/EmergenceAuditor.js

@@ -0,0 +1,34 @@
+/// <reference types="./EmergenceAuditor.d.ts" />
+export class EmergenceAuditor {
+    async audit(ctx) {
+        const issues = [];
+        // 1. Check for rapid propagation of new skills (Potential poisoning)
+        const recentSkills = await ctx.trx
+            .selectFrom(ctx.skillsTable)
+            .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 ctx.trx
+            .selectFrom(ctx.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,
+            metadata: { recentSkillCount: recentSkills.length, successVariance: recentTaskMetrics.length >= 5 ? issues.length > 0 : null }
+        };
+    }
+}

package/dist/esm/agentic/improvement/governance/MaintenanceOracle.d.ts

@@ -0,0 +1,4 @@
+import type { AuditContext } from './AuditContext.js';
+export declare class MaintenanceOracle {
+    suggestRepairs(ctx: AuditContext): Promise<string[]>;
+}