noormme 1.2.2 → 1.2.4

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

@@ -23,16 +23,27 @@ class AblationEngine {
     get typedDb() {
         return this.db;
     }
+    /**
+     * Helper to apply forUpdate only where supported (Skip for SQLite)
+     */
+    withLock(query, trx) {
+        const executor = trx.getExecutor();
+        const adapterName = executor?.adapter?.constructor?.name || executor?.dialect?.constructor?.name || '';
+        if (adapterName.toLowerCase().includes('sqlite')) {
+            return query;
+        }
+        return query.forUpdate();
+    }
     /**
      * Identify "Zombies": Items that have never been retrieved/hit and are old.
      */
-    async pruneZombies(thresholdDays = 30) {
+    async pruneZombies(thresholdDays = 30, trxOrDb = this.db) {
         const cutoff = new Date(Date.now() - thresholdDays * 24 * 3600000);
         let totalPruned = 0;
-        return await this.db.transaction().execute(async (trx) => {
+        const runner = async (trx) => {
             // 1. Prune Knowledge (with dependency check and pagination)
             // Audit Phase 9: Paginated selection to prevent OOM
-            const knowledgeToPrune = await trx
+            const query = trx
                 .selectFrom(this.knowledgeTable)
                 .selectAll()
                 .where((eb) => eb.or([
@@ -43,9 +54,8 @@ class AblationEngine {
                 .where('updated_at', '<', cutoff)
                 .where('id', 'not in', (eb) => eb.selectFrom(this.linksTable).select('source_id'))
                 .where('id', 'not in', (eb) => eb.selectFrom(this.linksTable).select('target_id'))
-                .limit(500) // Audit Phase 9: Batch limit
-                .forUpdate() // Audit Phase 9: Lock candidates
-                .execute();
+                .limit(500); // Audit Phase 9: Batch limit
+            const knowledgeToPrune = await this.withLock(query, trx).execute();
             if (knowledgeToPrune.length > 0) {
                 const candidates = knowledgeToPrune.map((k) => this.cortex.knowledge['parseKnowledge'](k));
                 const idsToDelete = [];
@@ -80,16 +90,22 @@ class AblationEngine {
                 console.log(`[AblationEngine] Pruned ${totalPruned} zombie items older than ${thresholdDays} days.`);
             }
             return totalPruned;
-        });
+        };
+        if (trxOrDb && trxOrDb !== this.db) {
+            return await runner(trxOrDb);
+        }
+        else {
+            return await this.db.transaction().execute(runner);
+        }
     }
     /**
      * Monitor Performance and perform Intelligent Rollbacks.
      * Prioritizes recovery of items with highest historical hit counts.
      */
-    async monitorAblationPerformance() {
-        return await this.db.transaction().execute(async (trx) => {
-            const baseline = await this.cortex.metrics.getAverageMetric('success_rate');
-            const stats = await this.cortex.metrics.getMetricStats('success_rate');
+    async monitorAblationPerformance(trxOrDb = this.db) {
+        const runner = async (trx) => {
+            const baseline = await this.cortex.metrics.getAverageMetric('success_rate', trx);
+            const stats = await this.cortex.metrics.getMetricStats('success_rate', {}, trx);
             // If current average is significantly lower than overall average
             if (stats.count > 10 && stats.avg < baseline * 0.8) {
                 console.warn(`[AblationEngine] PERFORMANCE DEGRADATION DETECTED (Avg: ${stats.avg}, Baseline: ${baseline}). Triggering targeted recovery.`);
@@ -117,20 +133,25 @@ class AblationEngine {
                 return { status: 'degraded', recoveredCount };
             }
             return { status: 'stable', recoveredCount: 0 };
-        });
+        };
+        if (trxOrDb && trxOrDb !== this.db) {
+            return await runner(trxOrDb);
+        }
+        else {
+            return await this.db.transaction().execute(runner);
+        }
     }
     /**
      * Conduct an "Ablation Test": Temporarily disable a knowledge item.
      */
-    async testAblation(id) {
+    async testAblation(id, trxOrDb = this.db) {
         console.log(`[AblationEngine] Conducting ablation test on item ${id}`);
-        return await this.db.transaction().execute(async (trx) => {
-            const item = (await trx
+        const runner = async (trx) => {
+            const query = trx
                 .selectFrom(this.knowledgeTable)
                 .selectAll()
-                .where('id', '=', id)
-                .forUpdate() // Audit Phase 9: Atomic lock for test initiation
-                .executeTakeFirst());
+                .where('id', '=', id);
+            const item = (await this.withLock(query, trx).executeTakeFirst());
             if (!item)
                 return false;
             const metadata = typeof item.metadata === 'string'
@@ -140,7 +161,7 @@ class AblationEngine {
                 `Temporary confidence reduction to evaluate reasoning impact.`,
                 `Original confidence: ${item.confidence}`,
                 `Historical hits: ${metadata.hit_count || 0}`
-            ]);
+            ], undefined, trx);
             await trx
                 .updateTable(this.knowledgeTable)
                 .set({
@@ -155,19 +176,25 @@ class AblationEngine {
                 .where('id', '=', id)
                 .execute();
             return true;
-        });
+        };
+        if (trxOrDb && trxOrDb !== this.db) {
+            await runner(trxOrDb);
+        }
+        else {
+            await this.db.transaction().execute(runner);
+        }
+        return true;
     }
     /**
      * Restore an ablated knowledge item to its original state.
      */
     async recoverAblatedItem(id, trx) {
         const recoveryStep = async (t) => {
-            const item = (await t
+            const query = t
                 .selectFrom(this.knowledgeTable)
                 .selectAll()
-                .where('id', '=', id)
-                .forUpdate() // Audit Phase 9: Atomic lock for restoration
-                .executeTakeFirst());
+                .where('id', '=', id);
+            const item = (await this.withLock(query, t).executeTakeFirst());
             if (!item)
                 return false;
             const metadata = typeof item.metadata === 'string'

package/dist/cjs/agentic/improvement/ActionRefiner.d.ts

@@ -14,7 +14,7 @@ export declare class ActionRefiner {
     /**
      * Analyze recent actions and propose improvements
      */
-    refineActions(): Promise<string[]>;
+    refineActions(trxOrDb?: any): Promise<string[]>;
     /**
      * Propose a rule to reflect on a specific tool usage
      */

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

@@ -19,12 +19,12 @@ class ActionRefiner {
     /**
      * Analyze recent actions and propose improvements
      */
-    async refineActions() {
+    async refineActions(trxOrDb = this.db) {
         const recommendations = [];
         // 1. Find tools with high failure rates (Last 24h Window)
         // Audit Phase 14: Sliding window to prevent global table scans
         const windowStart = new Date(Date.now() - 24 * 60 * 60 * 1000);
-        const failureStats = (await this.db
+        const failureStats = (await trxOrDb
             .selectFrom(this.actionsTable)
             .select('tool_name')
             .select((eb) => eb.fn.count('id').as('total'))
@@ -43,11 +43,11 @@ class ActionRefiner {
             if (rate > failureRateThreshold && total > minActionBatch) {
                 recommendations.push(`Tool '${stat.tool_name}' has a ${Math.round(rate * 100)}% failure rate. Suggesting automatic reflection rule.`);
                 // Automatically propose a rule to reflect on this tool's usage
-                await this.proposeReflectionRule(stat.tool_name);
+                await this.proposeReflectionRule(stat.tool_name, trxOrDb);
             }
         }
         // 2. Discover missing capabilities based on error patterns (Last 24h)
-        const missingCapabilities = (await this.db
+        const missingCapabilities = (await trxOrDb
             .selectFrom(this.actionsTable)
             .select('tool_name')
             .where('status', '=', 'failure')
@@ -62,25 +62,29 @@ class ActionRefiner {
             .execute());
         for (const row of missingCapabilities) {
             recommendations.push(`Detected repeated access/existence failures for tool '${row.tool_name}'. Proposing capability expansion.`);
-            await this.proposeCapabilityUpdate(row.tool_name);
+            await this.proposeCapabilityUpdate(row.tool_name, trxOrDb);
         }
         return recommendations;
     }
     /**
      * Propose a rule to reflect on a specific tool usage
      */
-    async proposeReflectionRule(toolName) {
+    async proposeReflectionRule(toolName, trxOrDb = this.db) {
         // Audit Phase 19: Atomic rule proposal via transaction + existence check
-        await this.db.transaction().execute(async (trx) => {
+        const runner = async (trx) => {
             const rulesTable = this.cortex.config.rulesTable || 'agent_rules';
-            const existing = await trx
+            let query = trx
                 .selectFrom(rulesTable)
                 .select('id')
-                .where('tableName', '=', 'agent_actions')
+                .where('table_name', '=', 'agent_actions')
                 .where('operation', '=', 'insert')
-                .where('metadata', 'like', `%\"targetTool\":\"${toolName}\"%`)
-                .forUpdate() // Lock to prevent concurrent proposals
-                .executeTakeFirst();
+                .where('metadata', 'like', `%\"targetTool\":\"${toolName}\"%`);
+            const executor = trx.getExecutor();
+            const adapterName = executor?.adapter?.constructor?.name || executor?.dialect?.constructor?.name || '';
+            if (!adapterName.toLowerCase().includes('sqlite')) {
+                query = query.forUpdate();
+            }
+            const existing = await query.executeTakeFirst();
             if (!existing) {
                 console.log(`[ActionRefiner] Proposing reflection rule for tool: ${toolName}`);
                 await this.cortex.rules.defineRule('agent_actions', 'insert', 'audit', {
@@ -90,17 +94,23 @@ class ActionRefiner {
                     },
                 }, trx); // Pass transaction object
             }
-        });
+        };
+        if (trxOrDb && trxOrDb !== this.db) {
+            await runner(trxOrDb);
+        }
+        else {
+            await this.db.transaction().execute((trx) => runner(trx));
+        }
     }
     /**
      * Propose an update to capabilities
      */
-    async proposeCapabilityUpdate(toolName) {
+    async proposeCapabilityUpdate(toolName, trxOrDb = this.db) {
         console.log(`[ActionRefiner] Proposing capability expansion for tool: ${toolName}`);
         await this.cortex.reflections.reflect('system', 'failure', `Architectural Gap: Missing Capability for '${toolName}'`, [
             `Identified repeated failures using tool '${toolName}'.`,
             `Resolution: Inspect permission sets and ensure the tool is correctly registered in the CapabilityManager.`,
-        ]);
+        ], undefined, trxOrDb);
     }
 }
 exports.ActionRefiner = ActionRefiner;

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

@@ -64,7 +64,8 @@ class EvolutionRitual {
         // Find domains that are currently "hot" (high density of recent knowledge)
         // Refactored Phase 13: Paginated scanning to handle large knowledge bursts
         const domainScores = new Map();
-        const cutoff = new Date(Date.now() - 24 * 60 * 60 * 1000);
+        const lookbackHours = this.config.evolutionLookbackHours || 24;
+        const cutoff = new Date(Date.now() - lookbackHours * 60 * 60 * 1000);
         let offset = 0;
         const limit = 1000;
         while (true) {

package/dist/cjs/agentic/improvement/EvolutionaryPilot.d.ts

@@ -13,7 +13,7 @@ export declare class EvolutionaryPilot {
     /**
      * Run a self-improvement cycle based on dynamic baselining
      */
-    runSelfImprovementCycle(): Promise<{
+    runSelfImprovementCycle(trxOrDb?: any): Promise<{
         evolved: boolean;
         changes: string[];
     }>;

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

@@ -18,7 +18,7 @@ class EvolutionaryPilot {
     /**
      * Run a self-improvement cycle based on dynamic baselining
      */
-    async runSelfImprovementCycle() {
+    async runSelfImprovementCycle(trxOrDb = this.db) {
         console.log('[EvolutionaryPilot] Initiating self-improvement cycle with full-spectrum baselining...');
         const changes = [];
         let evolved = false;
@@ -30,7 +30,7 @@ class EvolutionaryPilot {
             'trust_signal',
         ];
         const samplingCount = this.config.evolution?.samplingCount || 100;
-        const recentMetrics = await this.cortex.metrics.getRecentMetrics(samplingCount);
+        const recentMetrics = await this.cortex.metrics.getRecentMetrics(samplingCount, trxOrDb);
         for (const metricName of metrics) {
             // Audit Phase 17: Bounded metric slice for scale-safe baselining
             const values = recentMetrics
@@ -43,14 +43,14 @@ class EvolutionaryPilot {
             const minSamples = this.config.evolution?.minSamples || 5;
             if (values.length < minSamples)
                 continue;
-            const policies = await this.cortex.policies.getActivePolicies();
+            const policies = await this.cortex.policies.getActivePolicies(trxOrDb);
             const latencyZ = policies.find(p => p.name === 'latency_drift_z')?.definition?.threshold || 2.0;
             const latencyMean = policies.find(p => p.name === 'latency_mean_ceiling')?.definition?.threshold || 1000;
             console.log(`[EvolutionaryPilot] Baselining ${metricName}: Mean=${stats.mean.toFixed(2)}, StdDev=${stats.stdDev.toFixed(2)}, Current=${stats.current.toFixed(2)}, Z-Score=${stats.zScore.toFixed(2)}`);
             // 2. Trigger Evolution based on metric-specific thresholds
             if (metricName === 'query_latency' &&
                 (stats.zScore > latencyZ || stats.mean > latencyMean)) {
-                const result = await this.optimizeLatency();
+                const result = await this.optimizeLatency(trxOrDb);
                 if (result) {
                     changes.push(...result);
                     evolved = true;
@@ -61,7 +61,7 @@ class EvolutionaryPilot {
             if (metricName === 'success_rate' &&
                 (stats.zScore < successZ || stats.mean < successMean)) {
                 console.warn(`[EvolutionaryPilot] Success rate collapse detected (${stats.mean.toFixed(2)}). Triggering strategic mutation.`);
-                const strategies = await this.cortex.strategy.mutateStrategy();
+                const strategies = await this.cortex.strategy.mutateStrategy(trxOrDb);
                 changes.push(...strategies);
                 evolved = true;
             }
@@ -74,13 +74,13 @@ class EvolutionaryPilot {
             }
         }
         // 3. Meta-Meta Evolution Tuning
-        const tuned = await this.tuneEmergentSkillHyperparameters(recentMetrics);
+        const tuned = await this.tuneEmergentSkillHyperparameters(recentMetrics, trxOrDb);
         if (tuned) {
             changes.push('Self-tuned emergent skill hyperparameters (Meta-Meta Evolution)');
             evolved = true;
         }
         // 4. Verify: Perform an audit
-        const audit = await this.cortex.governor.performAudit();
+        const audit = await this.cortex.governor.performAudit(trxOrDb);
         if (!audit.healthy) {
             console.warn('[EvolutionaryPilot] Evolution resulted in unhealthy state. Reverting may be required.');
             changes.push('WARNING: Unhealthy state detected after evolution');
@@ -91,11 +91,11 @@ class EvolutionaryPilot {
      * Meta-Meta Evolution: Adjusts the hyperparameters of the SkillSynthesizer
      * based on the systemic success or failure of recently verified skills.
      */
-    async tuneEmergentSkillHyperparameters(recentMetrics) {
+    async tuneEmergentSkillHyperparameters(recentMetrics, trxOrDb = this.db) {
         console.log(`[EvolutionaryPilot] Running Meta-Meta Evolution tuning...`);
         // Count how many skills are currently blacklisted vs verified
-        const blacklisted = await this.cortex.capabilities.getCapabilities('blacklisted');
-        const verified = await this.cortex.capabilities.getCapabilities('verified');
+        const blacklisted = await this.cortex.capabilities.getCapabilities('blacklisted', trxOrDb);
+        const verified = await this.cortex.capabilities.getCapabilities('verified', trxOrDb);
         let tuned = false;
         const config = this.config.evolution;
         if (!config)
@@ -152,21 +152,19 @@ class EvolutionaryPilot {
         const zScore = stdDev === 0 ? 0 : (current - mean) / stdDev;
         return { mean, stdDev, current, zScore };
     }
-    async optimizeLatency() {
+    async optimizeLatency(trxOrDb = this.db) {
         const changes = [];
         console.log(`[EvolutionaryPilot] Triggering latency optimization...`);
-        const dialect = this.db.getExecutor().dialect;
-        const isSqlite = this.db
-            .getExecutor()
-            .adapter.constructor.name.toLowerCase()
-            .includes('sqlite') ||
-            (dialect && dialect.constructor.name.toLowerCase().includes('sqlite'));
+        const executor = trxOrDb.getExecutor();
+        const adapterName = executor?.adapter?.constructor?.name || executor?.dialect?.constructor?.name || '';
+        const isSqlite = adapterName.toLowerCase().includes('sqlite');
         if (isSqlite) {
-            await (0, sql_js_1.sql) `PRAGMA optimize`.execute(this.db);
+            await (0, sql_js_1.sql) `PRAGMA optimize`.execute(trxOrDb);
             changes.push('Applied PRAGMA optimize');
         }
         const messagesTable = this.config.messagesTable || 'agent_messages';
-        await this.cortex.evolution.evolve(`CREATE INDEX IF NOT EXISTS idx_agent_msg_session_time ON ${messagesTable}(session_id, created_at)`);
+        // NOTE: cortex.evolution.evolve should be transaction-aware
+        await this.cortex.evolution.evolve(`CREATE INDEX IF NOT EXISTS idx_agent_msg_session_time ON ${messagesTable}(session_id, created_at)`, {}, trxOrDb);
         changes.push(`Applied composite index to ${messagesTable}`);
         return changes;
     }

package/dist/cjs/agentic/improvement/GovernanceManager.d.ts

@@ -26,24 +26,24 @@ export declare class GovernanceManager {
     /**
      * Perform a "Panic Check" - looking for critical failures or cost overruns
      */
-    performAudit(): Promise<{
+    performAudit(trxOrDb?: any): Promise<{
         healthy: boolean;
         issues: string[];
     }>;
     /**
      * Suggest architectural repairs if performance is degrading
      */
-    suggestRepairs(): Promise<string[]>;
+    suggestRepairs(trxOrDb?: any): Promise<string[]>;
     /**
      * Quarantine a persona that is behaving outside safety parameters.
      */
-    quarantinePersona(id: string | number, reason: string): Promise<void>;
+    quarantinePersona(id: string | number, reason: string, trxOrDb?: any): Promise<void>;
     /**
      * Blacklist a skill that is causing systemic issues.
      */
-    quarantineSkill(name: string, reason: string): Promise<void>;
+    quarantineSkill(name: string, reason: string, trxOrDb?: any): Promise<void>;
     /**
      * Monitor cross-node behaviors and flag sudden spikes or malicious patterns.
      */
-    validateEmergentBehavior(trx?: any): Promise<string[]>;
+    validateEmergentBehavior(trxOrDb?: any): Promise<string[]>;
 }

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

@@ -48,13 +48,13 @@ class GovernanceManager {
     /**
      * Perform a "Panic Check" - looking for critical failures or cost overruns
      */
-    async performAudit() {
+    async performAudit(trxOrDb = this.db) {
         const issuesList = [];
         let auditMetadata = {};
         // Execute core audit gathering phase
         const ctx = {
             db: this.db,
-            trx: this.db,
+            trx: trxOrDb,
             cortex: this.cortex,
             config: this.config,
             metricsTable: this.metricsTable,
@@ -92,21 +92,11 @@ class GovernanceManager {
             // 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');
+                await this.personaAuditor.quarantinePersona(ctx, 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);
+            await this.cortex.reflections.reflect('system', 'failure', 'Governance Compliance Audit', issuesList, undefined, trxOrDb);
             // 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 {
@@ -117,10 +107,10 @@ class GovernanceManager {
     /**
      * Suggest architectural repairs if performance is degrading
      */
-    async suggestRepairs() {
+    async suggestRepairs(trxOrDb = this.db) {
         const ctx = {
             db: this.db,
-            trx: this.db,
+            trx: trxOrDb,
             cortex: this.cortex,
             config: this.config,
             metricsTable: this.metricsTable,
@@ -133,10 +123,10 @@ class GovernanceManager {
     /**
      * Quarantine a persona that is behaving outside safety parameters.
      */
-    async quarantinePersona(id, reason) {
+    async quarantinePersona(id, reason, trxOrDb = this.db) {
         const ctx = {
             db: this.db,
-            trx: this.db,
+            trx: trxOrDb,
             cortex: this.cortex,
             config: this.config,
             metricsTable: this.metricsTable,
@@ -149,10 +139,10 @@ class GovernanceManager {
     /**
      * Blacklist a skill that is causing systemic issues.
      */
-    async quarantineSkill(name, reason) {
+    async quarantineSkill(name, reason, trxOrDb = this.db) {
         const ctx = {
             db: this.db,
-            trx: this.db,
+            trx: trxOrDb,
             cortex: this.cortex,
             config: this.config,
             metricsTable: this.metricsTable,
@@ -165,10 +155,10 @@ class GovernanceManager {
     /**
      * Monitor cross-node behaviors and flag sudden spikes or malicious patterns.
      */
-    async validateEmergentBehavior(trx) {
+    async validateEmergentBehavior(trxOrDb = this.db) {
         const ctx = {
             db: this.db,
-            trx: trx || this.db,
+            trx: trxOrDb,
             cortex: this.cortex,
             config: this.config,
             metricsTable: this.metricsTable,

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

@@ -10,11 +10,13 @@ export declare class HiveLink {
     private cortex;
     private config;
     private knowledgeTable;
+    private promoter;
+    private propagator;
+    private domainMaster;
     constructor(db: Kysely<any>, cortex: Cortex, config?: AgenticConfig);
     private get typedDb();
     /**
      * Promote high-confidence local knowledge to global "Hive" knowledge.
-     * This creates a new, session-agnostic entry or updates an existing global one.
      */
     broadcastKnowledge(options?: {
         minConfidence?: number;
@@ -23,12 +25,10 @@ export declare class HiveLink {
     }): 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 using the "Sovereign Draft" protocol.
-     * Uses Bayesian Convergence and Shadow Promotion to avoid deadlocks.
      */
     broadcastSkills(): Promise<number>;
     /**