noormme 1.2.0 → 1.2.2

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

@@ -38,11 +38,14 @@ class StrategicPlanner {
             .selectFrom(this.personasTable)
             .selectAll()
             .execute();
+        const allParsedPersonas = personas.map((p) => this.parsePersona(p));
+        const globalBlacklistDuration = this.config.strategy?.globalBlacklistDuration || 3600000; // 1 hour
+        const localBlacklistDuration = this.config.strategy?.localBlacklistDuration || 86400000; // 24 hours
         for (const p of personas) {
             const persona = this.parsePersona(p);
             // 1. Verification Monitor
             if (persona.metadata?.evolution_status === 'verifying') {
-                const result = await this.verifyEvolution(persona);
+                const result = await this.verifyEvolution(persona, allParsedPersonas);
                 if (result)
                     mutations.push(result);
                 continue;
@@ -52,20 +55,15 @@ class StrategicPlanner {
             const report = await this.analyzePersona(persona.id);
             // 3. Blacklist Check (Local & Global Phase 5)
             const lastMutation = persona.metadata?.last_failed_mutation;
-            const allPersonas = await this.typedDb
-                .selectFrom(this.personasTable)
-                .selectAll()
-                .execute();
-            const isGloballyBlacklisted = allPersonas.some((p) => {
-                const mp = this.parsePersona(p);
+            const isGloballyBlacklisted = allParsedPersonas.some((mp) => {
                 return (mp.metadata?.last_failed_mutation?.type === report.recommendation &&
                     Date.now() - (mp.metadata?.last_failed_mutation?.timestamp || 0) <
-                        3600000);
+                        globalBlacklistDuration);
             });
             if (isGloballyBlacklisted ||
                 (lastMutation &&
                     report.recommendation === lastMutation.type &&
-                    Date.now() - lastMutation.timestamp < 86400000)) {
+                    Date.now() - lastMutation.timestamp < localBlacklistDuration)) {
                 console.log(`[StrategicPlanner] Skipping blacklisted mutation ${report.recommendation} for persona ${persona.id} (Global=${isGloballyBlacklisted})`);
                 continue;
             }
@@ -111,15 +109,19 @@ class StrategicPlanner {
                     .filter((p) => (p.metadata?.evolution_status === 'stable' ||
                     !p.metadata?.evolution_status) &&
                     p.metadata?.mutation_reason?.includes(report.recommendation));
-                if (winningMutations.length > 0 && Math.random() > 0.5) {
-                    console.log(`[StrategicPlanner] Cross-Pollinating success from Persona ${winningMutations[0].id}`);
-                    updates = { role: winningMutations[0].role || persona.role };
+                if (winningMutations.length > 0) {
+                    // PRODUCTION HARDENING: Deterministic Alpha Selection
+                    // Instead of Math.random(), pick the variant with the highest anchored reliability
+                    const sorted = winningMutations.sort((a, b) => (b.metadata?.anchored_reliability || 0) - (a.metadata?.anchored_reliability || 0));
+                    const alphaMatch = sorted[0];
+                    console.log(`[StrategicPlanner] Cross-Pollinating success from Alpha Persona ${alphaMatch.id} (Reliability: ${alphaMatch.metadata?.anchored_reliability || 0})`);
+                    updates = { role: this.sanitizeRole(alphaMatch.role || persona.role || 'Agent') };
                 }
                 else {
                     switch (report.recommendation) {
                         case 'optimize_accuracy':
                             updates = {
-                                role: `${persona.role || ''} (Focus strictly on accuracy and detailed verification)`.trim(),
+                                role: this.sanitizeRole(`${persona.role || ''} (Focus strictly on accuracy and detailed verification)`),
                             };
                             break;
                         case 'optimize_efficiency':
@@ -139,6 +141,9 @@ class StrategicPlanner {
                     }
                 }
             }
+            if (updates.role) {
+                updates.role = this.sanitizeRole(updates.role);
+            }
             // 1. Predictive Conflict Detection (Pre-flight)
             const proposedState = { ...persona, ...updates };
             const contradictions = await this.cortex.reasoner.detectContradictions();
@@ -198,18 +203,13 @@ class StrategicPlanner {
      * Check if a persona in verification should be stabilized or rolled back.
      * Uses dynamic statistical variance and adaptive meta-tuning.
      */
-    async verifyEvolution(persona) {
+    async verifyEvolution(persona, allPersonas = []) {
         const report = await this.analyzePersona(persona.id);
         // Adaptive Meta-Tuning: Increase window based on rollback history (Phase 4)
         const rollbackHistory = persona.metadata?.rollbackHistory || [];
         const recentRollbacks = rollbackHistory.filter((ts) => Date.now() - ts < 604800000).length;
         // Hive-Mind Verification Speedups (Phase 5)
-        const allPersonas = await this.typedDb
-            .selectFrom(this.personasTable)
-            .selectAll()
-            .execute();
         const hiveTrusted = allPersonas
-            .map((p) => this.parsePersona(p))
             .filter((p) => p.metadata?.evolution_status === 'stable' &&
             p.metadata?.mutation_reason === persona.metadata?.mutation_reason).length;
         let sampleSizeThreshold = 10 + recentRollbacks * 10;
@@ -432,6 +432,13 @@ class StrategicPlanner {
             return `Rolled back mutation ${lastMutation.id} for persona ${id}`;
         });
     }
+    sanitizeRole(role) {
+        // Audit Phase 7: Semantic Security
+        // Truncate to prevent context-window exhaustion/bloat
+        const truncated = role.slice(0, 500).trim();
+        // Sanitize: remove potentially dangerous prompt-injection markers or control chars
+        return truncated.replace(/[\u0000-\u001F\u007F-\u009F]/g, '').replace(/<\|.*?\|>/g, '');
+    }
     parsePersona(p) {
         return {
             id: p.id,

package/dist/cjs/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/cjs/agentic/improvement/governance/AuditContext.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/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/cjs/agentic/improvement/governance/BudgetAuditor.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BudgetAuditor = void 0;
+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 }
+        };
+    }
+}
+exports.BudgetAuditor = BudgetAuditor;

package/dist/cjs/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/cjs/agentic/improvement/governance/EmergenceAuditor.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmergenceAuditor = void 0;
+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 }
+        };
+    }
+}
+exports.EmergenceAuditor = EmergenceAuditor;

package/dist/cjs/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[]>;
+}

package/dist/cjs/agentic/improvement/governance/MaintenanceOracle.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MaintenanceOracle = void 0;
+class MaintenanceOracle {
+    async suggestRepairs(ctx) {
+        const repairs = [];
+        // Fetch maintenance policies
+        const policies = (await ctx.db
+            .selectFrom(ctx.policiesTable)
+            .selectAll()
+            .where('is_enabled', '=', true)
+            .execute());
+        const getPolicyValue = (name, fallback) => {
+            const p = policies.find(p => p.name === name);
+            if (!p)
+                return fallback;
+            const def = typeof p.definition === 'string' ? JSON.parse(p.definition) : p.definition;
+            return def.threshold ?? def.limit ?? def.days ?? fallback;
+        };
+        const latencyPolicy = getPolicyValue('latency_repair_threshold', 500);
+        const costPolicy = getPolicyValue('high_cost_threshold', 0.5);
+        const storagePolicy = getPolicyValue('cold_storage_threshold', 30);
+        // 1. Check for chronic high latency
+        const latencyStats = await ctx.cortex.metrics.getMetricStats('query_latency');
+        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
+        const recentSlowQueries = await ctx.db
+            .selectFrom(ctx.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) { }
+        }
+        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
+        const totalCost = await ctx.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).');
+        }
+        // 4. Cold storage candidates
+        const oldThreshold = new Date(Date.now() - storagePolicy * 24 * 60 * 60 * 1000);
+        const sessionsTable = ctx.config.sessionsTable || 'agent_sessions';
+        const oldSessions = (await ctx.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.`);
+        }
+        return repairs;
+    }
+}
+exports.MaintenanceOracle = MaintenanceOracle;

package/dist/cjs/agentic/improvement/governance/PerformanceAuditor.d.ts

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

package/dist/cjs/agentic/improvement/governance/PerformanceAuditor.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PerformanceAuditor = void 0;
+class PerformanceAuditor {
+    async audit(ctx) {
+        const issues = [];
+        // Fetch safety policies for success rate
+        const policies = (await ctx.trx
+            .selectFrom(ctx.policiesTable)
+            .selectAll()
+            .where('is_enabled', '=', true)
+            .where((eb) => eb.or([
+            eb('name', '=', 'min_success_rate'),
+            eb('type', '=', 'safety')
+        ]))
+            .execute());
+        const getLimit = (name) => {
+            const p = policies.find(p => p.name === name);
+            if (!p)
+                return 0.8; // Default success floor
+            const def = typeof p.definition === 'string' ? JSON.parse(p.definition) : p.definition;
+            return def.threshold ?? def.limit ?? 0.8;
+        };
+        const minSuccess = getLimit('min_success_rate');
+        // Statistical Success Rate (last 100 events)
+        const recentSuccess = await ctx.trx
+            .selectFrom(ctx.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}%)`);
+        }
+        return {
+            issues,
+            metadata: { success, minSuccess }
+        };
+    }
+}
+exports.PerformanceAuditor = PerformanceAuditor;

package/dist/cjs/agentic/improvement/governance/PersonaAuditor.d.ts

@@ -0,0 +1,6 @@
+import type { AuditContext, AuditResult } from './AuditContext.js';
+export declare class PersonaAuditor {
+    audit(ctx: AuditContext): Promise<AuditResult>;
+    private getActivePersona;
+    quarantinePersona(ctx: AuditContext, id: string | number, reason: string): Promise<void>;
+}

package/dist/cjs/agentic/improvement/governance/PersonaAuditor.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PersonaAuditor = void 0;
+class PersonaAuditor {
+    async audit(ctx) {
+        const issues = [];
+        const activePersona = await this.getActivePersona(ctx);
+        if (activePersona) {
+            const quotaCheck = await ctx.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 ctx.cortex.quotas.checkQuota('swarm', swarmId);
+                if (!swarmCheck.allowed) {
+                    issues.push(`Swarm Quota Breach [${swarmId}]: ${swarmCheck.reason}`);
+                }
+            }
+        }
+        return {
+            issues,
+            metadata: { activePersona }
+        };
+    }
+    async getActivePersona(ctx) {
+        const active = await ctx.trx
+            .selectFrom(ctx.personasTable)
+            .selectAll()
+            .where('status', '=', 'active')
+            .executeTakeFirst();
+        if (!active)
+            return null;
+        return {
+            ...active,
+            metadata: typeof active.metadata === 'string'
+                ? JSON.parse(active.metadata)
+                : active.metadata || {},
+        };
+    }
+    async quarantinePersona(ctx, id, reason) {
+        console.warn(`[PersonaAuditor] QUARANTINING Persona ${id}: ${reason}`);
+        let query = ctx.db
+            .selectFrom(ctx.personasTable)
+            .selectAll()
+            .where('id', '=', id);
+        // SQLite doesn't support SELECT ... FOR UPDATE easily in Kysely without specific dialect support
+        // But we are in a transaction usually if passed ctx.trx. 
+        // Here we use ctx.db for the quarantine update if it's a standalone call.
+        const persona = await query.executeTakeFirst();
+        if (persona) {
+            const metadata = typeof persona.metadata === 'string'
+                ? JSON.parse(persona.metadata)
+                : persona.metadata || {};
+            await ctx.db
+                .updateTable(ctx.personasTable)
+                .set({
+                status: 'quarantined',
+                metadata: JSON.stringify({
+                    ...metadata,
+                    quarantine_reason: reason,
+                    quarantined_at: new Date(),
+                }),
+                updated_at: new Date(),
+            })
+                .where('id', '=', id)
+                .execute();
+            // Rollback most recent changes via strategy engine
+            await ctx.cortex.strategy.rollbackPersona(id);
+        }
+    }
+}
+exports.PersonaAuditor = PersonaAuditor;

package/dist/cjs/agentic/improvement/governance/RemediationEngine.d.ts

@@ -0,0 +1,5 @@
+import type { AuditContext } from './AuditContext.js';
+export declare class RemediationEngine {
+    triggerRemediation(ctx: AuditContext, issues: string[]): Promise<void>;
+    private remediateSkillFailure;
+}

package/dist/cjs/agentic/improvement/governance/RemediationEngine.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemediationEngine = void 0;
+class RemediationEngine {
+    async triggerRemediation(ctx, issues) {
+        for (const issue of issues) {
+            if (issue.includes('Budget Violations')) {
+                await ctx.cortex.rituals.scheduleRitual('Budget Remediation', 'compression', 'hourly', `Automated response to: ${issue}`, { priority: 'critical', enforce_limits: true });
+            }
+            if (issue.includes('Performance Degradation')) {
+                await ctx.cortex.rituals.scheduleRitual('Reliability Sweep', 'pruning', 'daily', `Sanitizing high-noise memories due to: ${issue}`, { priority: 'medium', target: 'longtail' });
+            }
+            if (issue.includes('Integrity Failure')) {
+                await this.remediateSkillFailure(ctx, issue);
+            }
+            if (issue.includes('Quota Breach') || issue.includes('Swarm Quota Breach')) {
+                await ctx.cortex.rituals.scheduleRitual('Resource Throttling', 'pruning', 'hourly', `Critical resource containment: ${issue}`, { priority: 'critical', active_containment: true });
+            }
+        }
+    }
+    async remediateSkillFailure(ctx, issue) {
+        const skillName = issue.match(/'([^']+)'/)?.[1];
+        if (!skillName)
+            return;
+        console.log(`[RemediationEngine] Demoting tainted skill out of verified pool: ${skillName}`);
+        // Use a fresh transaction for remediation if possible, or use ctx.trx
+        await ctx.db.transaction().execute(async (trx) => {
+            const skill = await trx
+                .selectFrom(ctx.skillsTable)
+                .select('id')
+                .where('name', '=', skillName)
+                .executeTakeFirst();
+            if (skill) {
+                await trx
+                    .updateTable(ctx.skillsTable)
+                    .set({ status: 'experimental', updated_at: new Date() })
+                    .where('id', '=', skill.id)
+                    .execute();
+            }
+        });
+    }
+}
+exports.RemediationEngine = RemediationEngine;

package/dist/cjs/agentic/improvement/governance/SkillAuditor.d.ts

@@ -0,0 +1,5 @@
+import type { AuditContext, AuditResult } from './AuditContext.js';
+export declare class SkillAuditor {
+    audit(ctx: AuditContext): Promise<AuditResult>;
+    quarantineSkill(ctx: AuditContext, name: string, reason: string): Promise<void>;
+}

package/dist/cjs/agentic/improvement/governance/SkillAuditor.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkillAuditor = void 0;
+class SkillAuditor {
+    async audit(ctx) {
+        const issues = [];
+        // Fetch integrity policies for reliability floor
+        const policies = (await ctx.trx
+            .selectFrom(ctx.policiesTable)
+            .selectAll()
+            .where('is_enabled', '=', true)
+            .where((eb) => eb.or([
+            eb('name', '=', 'reliability_floor'),
+            eb('type', '=', 'integrity')
+        ]))
+            .execute());
+        const getLimit = (name) => {
+            const p = policies.find(p => p.name === name);
+            if (!p)
+                return 0.7; // Default reliability floor
+            const def = typeof p.definition === 'string' ? JSON.parse(p.definition) : p.definition;
+            return def.threshold ?? def.limit ?? 0.7;
+        };
+        const reliabilityLimit = getLimit('reliability_floor');
+        const failingVerified = await ctx.trx
+            .selectFrom(ctx.skillsTable)
+            .select(['name', 'reliability'])
+            .where('status', '=', 'verified')
+            .where('reliability', '<', reliabilityLimit)
+            .execute();
+        for (const cap of failingVerified) {
+            issues.push(`Integrity Failure: Verified skill '${cap.name}' reliability (${cap.reliability.toFixed(2)}) dropped below floor (${reliabilityLimit})`);
+        }
+        return {
+            issues,
+            metadata: { reliabilityLimit, failingVerifiedCount: failingVerified.length }
+        };
+    }
+    async quarantineSkill(ctx, name, reason) {
+        console.warn(`[SkillAuditor] BLACKLISTING Skill ${name}: ${reason}`);
+        await ctx.db
+            .updateTable(ctx.skillsTable)
+            .set({
+            status: 'blacklisted',
+            metadata: JSON.stringify({ blacklist_reason: reason, blacklisted_at: new Date() }),
+            updated_at: new Date()
+        })
+            .where('name', '=', name)
+            .execute();
+    }
+}
+exports.SkillAuditor = SkillAuditor;

package/dist/cjs/agentic/telemetry/CognitiveSynthesizer.d.ts

@@ -22,5 +22,10 @@ export declare class CognitiveSynthesizer {
     private inferGoalFromContent;
     private detectStrategy;
     private calculateAutonomy;
+    /**
+     * Detect "Sentiment Drift" or Cognitive Friction in the input stream.
+     * Mirrors the agent's internal "frustration" or "flow" state.
+     */
+    private detectSentimentDrift;
     private parsePath;
 }