noormme 1.2.3 → 1.2.5

package/dist/esm/agentic/improvement/distillation/FactDistiller.js

@@ -0,0 +1,112 @@
+/// <reference types="./FactDistiller.d.ts" />
+export class FactDistiller {
+    /**
+     * typedDb helper (internal use)
+     */
+    getTypedDb(db) {
+        return db;
+    }
+    async distillExact(trx, knowledgeTable, entity, fact, confidence, sourceSessionId, tags = [], metadata = {}, source = 'assistant') {
+        // Check for exact match
+        const existing = await trx
+            .selectFrom(knowledgeTable)
+            .selectAll()
+            .where('entity', '=', entity)
+            .where('fact', '=', fact)
+            .executeTakeFirst();
+        if (existing) {
+            // Merge tags
+            const existingTags = existing.tags ? JSON.parse(existing.tags) : [];
+            const mergedTags = Array.from(new Set([...existingTags, ...tags]));
+            // Merge metadata
+            const existingMeta = existing.metadata ? JSON.parse(existing.metadata) : {};
+            const sessions = new Set(existingMeta.sessions || []);
+            if (sourceSessionId)
+                sessions.add(sourceSessionId);
+            const mergedMeta = {
+                ...existingMeta,
+                ...metadata,
+                sessions: Array.from(sessions),
+                session_count: sessions.size,
+            };
+            // Source weighting
+            const boost = source === 'user' ? 0.2 : 0.05;
+            const finalConfidence = Math.min(1.0, existing.confidence + boost);
+            // Status Lifecycle
+            let finalStatus = existing.status || 'proposed';
+            if (source === 'user' || mergedMeta.session_count >= 3) {
+                finalStatus = 'verified';
+            }
+            return await trx
+                .updateTable(knowledgeTable)
+                .set({
+                confidence: finalConfidence,
+                status: finalStatus,
+                tags: JSON.stringify(mergedTags),
+                metadata: JSON.stringify(mergedMeta),
+                updated_at: new Date(),
+                source_session_id: sourceSessionId ?? existing.source_session_id,
+            })
+                .where('id', '=', existing.id)
+                .returningAll()
+                .executeTakeFirstOrThrow();
+        }
+        return null;
+    }
+    async createInitial(trx, knowledgeTable, entity, fact, confidence, sourceSessionId, tags = [], metadata = {}, source = 'assistant') {
+        const initialMeta = {
+            ...metadata,
+            source,
+            sessions: sourceSessionId ? [sourceSessionId] : [],
+            session_count: sourceSessionId ? 1 : 0,
+        };
+        return await trx
+            .insertInto(knowledgeTable)
+            .values({
+            entity,
+            fact,
+            confidence: source === 'user' ? Math.max(confidence, 0.8) : confidence,
+            status: source === 'user' ? 'verified' : 'proposed',
+            source_session_id: sourceSessionId ?? null,
+            tags: JSON.stringify(tags),
+            metadata: JSON.stringify(initialMeta),
+            created_at: new Date(),
+            updated_at: new Date(),
+        })
+            .returningAll()
+            .executeTakeFirstOrThrow();
+    }
+    async verify(db, knowledgeTable, id, reinforcement = 0.1) {
+        const existing = await db
+            .selectFrom(knowledgeTable)
+            .selectAll()
+            .where('id', '=', id)
+            .executeTakeFirst();
+        if (!existing)
+            return null;
+        const metadata = typeof existing.metadata === 'string'
+            ? JSON.parse(existing.metadata)
+            : existing.metadata || {};
+        // Hallucination Guard
+        let maxConfidence = 1.0;
+        if (metadata.source !== 'user' && (metadata.session_count || 0) < 3) {
+            maxConfidence = 0.85;
+        }
+        const newConfidence = Math.min(maxConfidence, existing.confidence + reinforcement);
+        // Promotion Lifecycle
+        let newStatus = existing.status || 'proposed';
+        if (newConfidence >= 0.9 || metadata.session_count >= 3) {
+            newStatus = 'verified';
+        }
+        return await db
+            .updateTable(knowledgeTable)
+            .set({
+            confidence: newConfidence,
+            status: newStatus,
+            updated_at: new Date(),
+        })
+            .where('id', '=', id)
+            .returningAll()
+            .executeTakeFirstOrThrow();
+    }
+}

package/dist/esm/agentic/improvement/distillation/KnowledgeConsolidator.d.ts

@@ -0,0 +1,6 @@
+import type { Kysely } from '../../../kysely.js';
+import type { KnowledgeItem } from '../../../types/index.js';
+export declare class KnowledgeConsolidator {
+    consolidate(db: Kysely<any>, knowledgeTable: string, getKnowledgeByEntityFn: (entity: string) => Promise<KnowledgeItem[]>): Promise<number>;
+    private mergeItems;
+}

package/dist/esm/agentic/improvement/distillation/KnowledgeConsolidator.js

@@ -0,0 +1,60 @@
+/// <reference types="./KnowledgeConsolidator.d.ts" />
+import { calculateSimilarity } from '../../../util/similarity.js';
+export class KnowledgeConsolidator {
+    async consolidate(db, knowledgeTable, getKnowledgeByEntityFn) {
+        let totalMerged = 0;
+        const candidates = await db
+            .selectFrom(knowledgeTable)
+            .select('entity')
+            .groupBy('entity')
+            .having((eb) => eb.fn.count('id'), '>', 1)
+            .limit(500)
+            .execute();
+        for (const cand of candidates) {
+            const entity = cand.entity;
+            const items = await getKnowledgeByEntityFn(entity);
+            const mergedIds = new Set();
+            const iterLimit = Math.min(items.length, 100);
+            for (let i = 0; i < iterLimit; i++) {
+                if (mergedIds.has(items[i].id))
+                    continue;
+                for (let j = i + 1; j < iterLimit; j++) {
+                    if (mergedIds.has(items[j].id))
+                        continue;
+                    const sim = calculateSimilarity(items[i].fact, items[j].fact);
+                    if (sim > 0.85) {
+                        await this.mergeItems(db, knowledgeTable, items[i], items[j]);
+                        mergedIds.add(items[j].id);
+                        totalMerged++;
+                    }
+                }
+            }
+        }
+        return totalMerged;
+    }
+    async mergeItems(db, knowledgeTable, primary, secondary) {
+        const mergedMeta = {
+            ...secondary.metadata,
+            ...primary.metadata,
+            consolidated_from: secondary.id,
+            consolidated_at: new Date().toISOString(),
+        };
+        const mergedTags = Array.from(new Set([...(primary.tags || []), ...(secondary.tags || [])]));
+        await db.transaction().execute(async (trx) => {
+            await trx
+                .updateTable(knowledgeTable)
+                .set({
+                confidence: Math.max(primary.confidence, secondary.confidence),
+                metadata: JSON.stringify(mergedMeta),
+                tags: JSON.stringify(mergedTags),
+                updated_at: new Date(),
+            })
+                .where('id', '=', primary.id)
+                .execute();
+            await trx
+                .deleteFrom(knowledgeTable)
+                .where('id', '=', secondary.id)
+                .execute();
+        });
+    }
+}

package/dist/esm/agentic/improvement/distillation/RelationshipArchitect.d.ts

@@ -0,0 +1,6 @@
+import type { Transaction } from '../../../kysely.js';
+import type { KnowledgeItem } from '../../../types/index.js';
+export declare class RelationshipArchitect {
+    autoLink(item: KnowledgeItem, trx: Transaction<any>, knowledgeTable: string, linksTable: string): Promise<void>;
+    link(sourceId: number | string, targetId: number | string, relationship: string, metadata: Record<string, any> | undefined, trxOrDb: any, linksTable: string): Promise<void>;
+}

package/dist/esm/agentic/improvement/distillation/RelationshipArchitect.js

@@ -0,0 +1,70 @@
+/// <reference types="./RelationshipArchitect.d.ts" />
+import { calculateSimilarity } from '../../../util/similarity.js';
+export class RelationshipArchitect {
+    async autoLink(item, trx, knowledgeTable, linksTable) {
+        // 1. Structural Extraction (NER-style)
+        const tokens = item.fact.match(/([A-Z][a-z]+(?:\s[A-Z][a-z]+)*)|("[^"]+")|([a-z]+[A-Z][a-z]+)/g) || [];
+        const potentialEntities = Array.from(new Set(tokens.map((t) => t.replace(/"/g, '').trim())))
+            .filter((t) => t.length > 2 && t !== item.entity);
+        if (potentialEntities.length > 0) {
+            const matches = await trx
+                .selectFrom(knowledgeTable)
+                .select(['id', 'entity'])
+                .where('entity', 'in', potentialEntities)
+                .execute();
+            for (const match of matches) {
+                await this.link(item.id, match.id, 'mentions', { auto: true, source: 'structural_extraction' }, trx, linksTable);
+            }
+        }
+        // 2. Semantic Similarity Pass
+        const candidates = await trx
+            .selectFrom(knowledgeTable)
+            .selectAll()
+            .where('id', '!=', item.id)
+            .where('confidence', '>', 0.4)
+            .orderBy('updated_at', 'desc')
+            .limit(50)
+            .execute();
+        const linksToCreate = [];
+        for (const other of candidates) {
+            const otherFact = other.fact;
+            const sim = calculateSimilarity(item.fact, otherFact);
+            if (sim > 0.75) {
+                linksToCreate.push({ targetId: other.id, sim });
+            }
+        }
+        for (const l of linksToCreate) {
+            await this.link(item.id, l.targetId, 'semantically_related', { similarity: l.sim, version: '2.0' }, trx, linksTable);
+        }
+    }
+    async link(sourceId, targetId, relationship, metadata, trxOrDb, linksTable) {
+        if (sourceId === targetId)
+            return;
+        const existing = await trxOrDb
+            .selectFrom(linksTable)
+            .select('id')
+            .where('source_id', '=', sourceId)
+            .where('target_id', '=', targetId)
+            .where('relationship', '=', relationship)
+            .executeTakeFirst();
+        if (existing) {
+            await trxOrDb
+                .updateTable(linksTable)
+                .set({ metadata: metadata ? JSON.stringify(metadata) : null })
+                .where('id', '=', existing.id)
+                .execute();
+        }
+        else {
+            await trxOrDb
+                .insertInto(linksTable)
+                .values({
+                source_id: sourceId,
+                target_id: targetId,
+                relationship,
+                metadata: metadata ? JSON.stringify(metadata) : null,
+                created_at: new Date(),
+            })
+                .execute();
+        }
+    }
+}

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

@@ -3,7 +3,7 @@ export class MaintenanceOracle {
     async suggestRepairs(ctx) {
         const repairs = [];
         // Fetch maintenance policies
-        const policies = (await ctx.db
+        const policies = (await ctx.trx
             .selectFrom(ctx.policiesTable)
             .selectAll()
             .where('is_enabled', '=', true)
@@ -19,12 +19,12 @@ export class MaintenanceOracle {
         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');
+        const latencyStats = await ctx.cortex.metrics.getMetricStats('query_latency', {}, ctx.trx);
         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
+        const recentSlowQueries = await ctx.trx
             .selectFrom(ctx.metricsTable)
             .select('metadata')
             .where('metric_name', '=', 'query_latency')
@@ -44,14 +44,14 @@ export class MaintenanceOracle {
             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');
+        const totalCost = await ctx.cortex.metrics.getAverageMetric('total_cost', ctx.trx);
         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
+        const oldSessions = (await ctx.trx
             .selectFrom(sessionsTable)
             .select((eb) => eb.fn.count('id').as('count'))
             .where('created_at', '<', oldThreshold)

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

@@ -1,17 +1,18 @@
 /// <reference types="./PersonaAuditor.d.ts" />
+import { withLock } from '../../util/db-utils.js';
 export 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);
+            const quotaCheck = await ctx.cortex.quotas.checkQuota('persona', activePersona.id, ctx.trx);
             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);
+                const swarmCheck = await ctx.cortex.quotas.checkQuota('swarm', swarmId, ctx.trx);
                 if (!swarmCheck.allowed) {
                     issues.push(`Swarm Quota Breach [${swarmId}]: ${swarmCheck.reason}`);
                 }
@@ -41,17 +42,12 @@ export class PersonaAuditor {
         console.warn(`[PersonaAuditor] QUARANTINING Persona ${id}: ${reason}`);
         // Use the provided transaction or start a new one to ensure atomicity
         const runner = async (trx) => {
-            let query = trx
+            const query = trx
                 .selectFrom(ctx.personasTable)
                 .selectAll()
                 .where('id', '=', id);
-            // Audit Phase 16: Exclusive lock for containment (Skip for SQLite)
-            const executor = ctx.db.getExecutor();
-            const adapterName = executor?.adapter?.constructor?.name || executor?.dialect?.constructor?.name || '';
-            if (!adapterName.toLowerCase().includes('sqlite')) {
-                query = query.forUpdate();
-            }
-            const persona = await query.executeTakeFirst();
+            const persona = await withLock(query, trx)
+                .executeTakeFirst();
             if (persona) {
                 const metadata = typeof persona.metadata === 'string'
                     ? JSON.parse(persona.metadata)
@@ -70,7 +66,7 @@ export class PersonaAuditor {
                     .where('id', '=', id)
                     .execute();
                 // Rollback most recent changes via strategy engine
-                await ctx.cortex.strategy.rollbackPersona(id);
+                await ctx.cortex.strategy.rollbackPersona(id, trx);
             }
         };
         if (ctx.trx && ctx.trx !== ctx.db) {

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

@@ -21,8 +21,7 @@ export class RemediationEngine {
         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 runner = async (trx) => {
             const skill = await trx
                 .selectFrom(ctx.skillsTable)
                 .select('id')
@@ -35,6 +34,12 @@ export class RemediationEngine {
                     .where('id', '=', skill.id)
                     .execute();
             }
-        });
+        };
+        if (ctx.trx && ctx.trx !== ctx.db) {
+            await runner(ctx.trx);
+        }
+        else {
+            await ctx.db.transaction().execute((trx) => runner(trx));
+        }
     }
 }

package/dist/esm/agentic/improvement/hive/DomainMaster.d.ts

@@ -0,0 +1,4 @@
+import type { Kysely } from '../../../kysely.js';
+export declare class DomainMaster {
+    boostDomain(db: Kysely<any>, knowledgeTable: string, domainTag: string, boostFactor?: number): Promise<number>;
+}

package/dist/esm/agentic/improvement/hive/DomainMaster.js

@@ -0,0 +1,16 @@
+/// <reference types="./DomainMaster.d.ts" />
+import { sql } from '../../../raw-builder/sql.js';
+export class DomainMaster {
+    async boostDomain(db, knowledgeTable, domainTag, boostFactor = 0.05) {
+        const result = await db
+            .updateTable(knowledgeTable)
+            .set({
+            confidence: sql `MIN(1.0, confidence + ${boostFactor})`,
+            updated_at: new Date(),
+        })
+            .where('tags', 'like', `%"${domainTag}"%`)
+            .where('confidence', '<', 1.0)
+            .execute();
+        return Number(result[0]?.numUpdatedRows ?? 1);
+    }
+}

package/dist/esm/agentic/improvement/hive/KnowledgePromoter.d.ts

@@ -0,0 +1,6 @@
+import type { Kysely } from '../../../kysely.js';
+import type { AgenticConfig, KnowledgeItem } from '../../../types/index.js';
+import type { Cortex } from '../../Cortex.js';
+export declare class KnowledgePromoter {
+    promote(db: Kysely<any>, cortex: Cortex, config: AgenticConfig, knowledgeTable: string, item: KnowledgeItem): Promise<boolean>;
+}

package/dist/esm/agentic/improvement/hive/KnowledgePromoter.js

@@ -0,0 +1,54 @@
+/// <reference types="./KnowledgePromoter.d.ts" />
+import { withLock } from '../../util/db-utils.js';
+export class KnowledgePromoter {
+    async promote(db, cortex, config, knowledgeTable, item) {
+        return await db.transaction().execute(async (trx) => {
+            // Check if a global version already exists
+            const query = trx
+                .selectFrom(knowledgeTable)
+                .selectAll()
+                .where('entity', '=', item.entity)
+                .where('fact', '=', item.fact)
+                .where('source_session_id', 'is', null);
+            const existingGlobal = await withLock(query, trx) // Prevent concurrent promotion duplication
+                .executeTakeFirst();
+            if (existingGlobal) {
+                // Reinforce existing global knowledge
+                const newConfidence = Math.min(0.99, Math.max(existingGlobal.confidence, item.confidence) + 0.01);
+                await trx
+                    .updateTable(knowledgeTable)
+                    .set({
+                    confidence: newConfidence,
+                    updated_at: new Date(),
+                })
+                    .where('id', '=', existingGlobal.id)
+                    .execute();
+                return false;
+            }
+            else {
+                // Create new global knowledge
+                const tags = item.tags ? [...item.tags] : [];
+                if (!tags.includes('hive_mind'))
+                    tags.push('hive_mind');
+                await trx
+                    .insertInto(knowledgeTable)
+                    .values({
+                    entity: item.entity,
+                    fact: item.fact,
+                    confidence: item.confidence,
+                    source_session_id: null,
+                    tags: JSON.stringify(tags),
+                    metadata: JSON.stringify({
+                        ...item.metadata,
+                        promoted_from: item.id,
+                        promoted_at: new Date(),
+                    }),
+                    created_at: new Date(),
+                    updated_at: new Date(),
+                })
+                    .execute();
+                return true;
+            }
+        });
+    }
+}

package/dist/esm/agentic/improvement/hive/SkillPropagator.d.ts

@@ -0,0 +1,6 @@
+import type { Kysely } from '../../../kysely.js';
+import type { AgenticConfig } from '../../../types/index.js';
+import type { Cortex } from '../../Cortex.js';
+export declare class SkillPropagator {
+    propagate(db: Kysely<any>, cortex: Cortex, config: AgenticConfig): Promise<number>;
+}

package/dist/esm/agentic/improvement/hive/SkillPropagator.js

@@ -0,0 +1,88 @@
+/// <reference types="./SkillPropagator.d.ts" />
+export class SkillPropagator {
+    async propagate(db, cortex, config) {
+        let broadcastCount = 0;
+        const capTable = config.capabilitiesTable || 'agent_capabilities';
+        // 1. Regular Skill Propagation (Verified Alpha/Shadow)
+        const verifiedSkills = await cortex.capabilities.getCapabilities('verified');
+        const lineageGroups = new Map();
+        for (const skill of verifiedSkills) {
+            const meta = typeof skill.metadata === 'string' ? JSON.parse(skill.metadata) : (skill.metadata || {});
+            const lineage = meta.lineage || skill.name;
+            if (!lineageGroups.has(lineage))
+                lineageGroups.set(lineage, []);
+            lineageGroups.get(lineage).push({ skill, meta });
+        }
+        for (const [_, variants] of lineageGroups.entries()) {
+            const alphaCandidate = variants.reduce((prev, curr) => {
+                const getScore = (v) => {
+                    const r = v.skill.reliability ?? 0.5;
+                    const n = (typeof v.meta === 'string' ? JSON.parse(v.meta) : v.meta)?.usages ?? 1;
+                    const K = 5;
+                    const prior = 0.5;
+                    return (r * n + K * prior) / (n + K);
+                };
+                return getScore(curr) > getScore(prev) ? curr : prev;
+            });
+            await db.transaction().execute(async (trx) => {
+                const currentMeta = alphaCandidate.meta || {};
+                const updatedMeta = {
+                    ...currentMeta,
+                    is_alpha: true,
+                    broadcasted: true,
+                    broadcasted_at: new Date()
+                };
+                await trx
+                    .updateTable(capTable)
+                    .set({ metadata: JSON.stringify(updatedMeta) })
+                    .where('id', '=', alphaCandidate.skill.id)
+                    .execute();
+                const shadowIds = variants
+                    .filter(v => v.skill.id !== alphaCandidate.skill.id)
+                    .map(v => v.skill.id);
+                for (const sid of shadowIds) {
+                    const sMatch = variants.find(v => v.skill.id === sid);
+                    const sMeta = sMatch?.meta || {};
+                    await trx.updateTable(capTable)
+                        .set({
+                        metadata: JSON.stringify({ ...sMeta, is_alpha: false, is_shadow: true }),
+                        status: 'experimental'
+                    })
+                        .where('id', '=', sid)
+                        .execute();
+                }
+            });
+            broadcastCount++;
+        }
+        // 2. Blacklisted Skill Propagation (Immune Prophet)
+        const blacklisted = await cortex.capabilities.getCapabilities('blacklisted');
+        const blackIDs = blacklisted
+            .filter(s => {
+            const meta = typeof s.metadata === 'string' ? JSON.parse(s.metadata) : (s.metadata || {});
+            return !meta.broadcasted || !meta.hive_blacklisted;
+        })
+            .map(s => s.id);
+        if (blackIDs.length > 0) {
+            await db.transaction().execute(async (trx) => {
+                for (const bid of blackIDs) {
+                    const skill = await trx.selectFrom(capTable)
+                        .select('metadata')
+                        .where('id', '=', bid)
+                        .executeTakeFirst();
+                    if (skill) {
+                        const meta = typeof skill.metadata === 'string' ? JSON.parse(skill.metadata) : (skill.metadata || {});
+                        await trx.updateTable(capTable)
+                            .set({
+                            metadata: JSON.stringify({ ...meta, broadcasted: true, hive_blacklisted: true }),
+                            updated_at: new Date()
+                        })
+                            .where('id', '=', bid)
+                            .execute();
+                    }
+                }
+            });
+            broadcastCount += blackIDs.length;
+        }
+        return broadcastCount;
+    }
+}

package/dist/esm/agentic/improvement/strategy/EvolutionVerificator.d.ts

@@ -0,0 +1,6 @@
+import type { AgentPersona } from '../../../types/index.js';
+import type { Cortex } from '../../Cortex.js';
+import type { PerformanceReport } from '../StrategicPlanner.js';
+export declare class EvolutionVerificator {
+    verify(trxOrDb: any, cortex: Cortex, personasTable: string, persona: AgentPersona, report: PerformanceReport, allPersonas: AgentPersona[], rollbackFn: (id: string | number, trx: any) => Promise<string>): Promise<string | null>;
+}

package/dist/esm/agentic/improvement/strategy/EvolutionVerificator.js

@@ -0,0 +1,45 @@
+/// <reference types="./EvolutionVerificator.d.ts" />
+export class EvolutionVerificator {
+    async verify(trxOrDb, cortex, personasTable, persona, report, allPersonas, rollbackFn) {
+        const rollbackHistory = persona.metadata?.rollbackHistory || [];
+        const recentRollbacks = rollbackHistory.filter((ts) => Date.now() - ts < 604800000).length;
+        const hiveTrusted = allPersonas.filter((p) => p.metadata?.evolution_status === 'stable' && p.metadata?.mutation_reason === persona.metadata?.mutation_reason).length;
+        let sampleSizeThreshold = 10 + recentRollbacks * 10;
+        const baseline = persona.metadata?.verification_baseline || { successRate: 0.8, averageLatency: 500 };
+        // Accelerated Stabilization
+        const earlyZ = (report.successRate - baseline.successRate) / 0.1;
+        if (earlyZ > 3.0 && report.sampleSize >= 5)
+            sampleSizeThreshold = 5;
+        if (hiveTrusted >= 3)
+            sampleSizeThreshold = Math.max(5, Math.floor(sampleSizeThreshold / 2));
+        if (report.sampleSize < sampleSizeThreshold)
+            return null;
+        // Dynamic Variance
+        const recentMetrics = await cortex.metrics.getRecentMetrics(100, trxOrDb);
+        const values = recentMetrics.filter((m) => m.metricName === 'success_rate').map((m) => Number(m.metricValue));
+        const mean = values.reduce((a, b) => a + b, 0) / (values.length || 1);
+        const variance = values.reduce((a, b) => a + Math.pow(b - mean, 2), 0) / (values.length || 1);
+        const stdDev = Math.sqrt(variance) || 0.1;
+        const zScore = (report.successRate - baseline.successRate) / (stdDev || 1);
+        if (zScore < -2.0)
+            return await rollbackFn(persona.id, trxOrDb);
+        if (report.sampleSize >= sampleSizeThreshold * 2 && zScore >= -0.5) {
+            if (persona.metadata?.mutation_reason?.includes('optimize_efficiency')) {
+                await cortex.rules.defineRule('all', 'all', 'audit', {
+                    condition: 'latency > 500',
+                    priority: 10,
+                    metadata: { reason: `Distilled from successful persona ${persona.id} optimization` },
+                }, trxOrDb);
+            }
+            await trxOrDb.updateTable(personasTable)
+                .set({ metadata: JSON.stringify({ ...persona.metadata, evolution_status: 'stable' }) })
+                .where('id', '=', persona.id)
+                .execute();
+            return `Evolution stabilized for persona ${persona.id}`;
+        }
+        const timeInVerification = (Date.now() - (persona.metadata?.verification_started_at || 0)) / 1000;
+        if (timeInVerification > 86400 * 3)
+            return await rollbackFn(persona.id, trxOrDb);
+        return null;
+    }
+}

package/dist/esm/agentic/improvement/strategy/MutationEngine.d.ts

@@ -0,0 +1,10 @@
+import type { Kysely } from '../../../kysely.js';
+import type { AgentPersona } from '../../../types/index.js';
+import type { Cortex } from '../../Cortex.js';
+import type { PerformanceReport } from '../StrategicPlanner.js';
+export declare class MutationEngine {
+    private personasTable;
+    constructor(personasTable: string);
+    applyMutation(db: Kysely<any>, cortex: Cortex, persona: AgentPersona, report: PerformanceReport, failures: string[] | undefined, sanitizeRoleFn: (role: string) => string, parsePersonaFn: (p: any) => AgentPersona): Promise<string | null>;
+    rollback(db: Kysely<any>, id: string | number, parsePersonaFn: (p: any) => AgentPersona): Promise<string>;
+}