noormme 1.2.2 → 1.2.4

package/dist/esm/agentic/PersonaManager.js

@@ -17,14 +17,16 @@ export class PersonaManager {
     /**
      * Create or update a persona
      */
-    async upsertPersona(name, options = {}) {
-        return await this.db.transaction().execute(async (trx) => {
+    async upsertPersona(name, options = {}, trxOrDb = this.db) {
+        const runner = async (trx) => {
             let query = trx
                 .selectFrom(this.personasTable)
                 .selectAll()
                 .where('name', '=', name);
             // Audit Phase 13: Atomic identity lock (Skip for SQLite)
-            if (this.db.getExecutor().adapter?.constructor.name !== 'SqliteAdapter') {
+            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();
@@ -56,13 +58,19 @@ export class PersonaManager {
                 .returningAll()
                 .executeTakeFirstOrThrow();
             return this.parsePersona(created);
-        });
+        };
+        if (trxOrDb && trxOrDb !== this.db) {
+            return await runner(trxOrDb);
+        }
+        else {
+            return await this.db.transaction().execute(runner);
+        }
     }
     /**
      * Get a persona by name
      */
-    async getPersona(name) {
-        const persona = await this.typedDb
+    async getPersona(name, trxOrDb = this.db) {
+        const persona = await trxOrDb
             .selectFrom(this.personasTable)
             .selectAll()
             .where('name', '=', name)
@@ -72,8 +80,8 @@ export class PersonaManager {
     /**
      * Delete a persona by name
      */
-    async deletePersona(name) {
-        const result = await this.typedDb
+    async deletePersona(name, trxOrDb = this.db) {
+        const result = await trxOrDb
             .deleteFrom(this.personasTable)
             .where('name', '=', name)
             .executeTakeFirst();
@@ -82,8 +90,8 @@ export class PersonaManager {
     /**
      * List all personas
      */
-    async listPersonas() {
-        const list = await this.typedDb
+    async listPersonas(trxOrDb = this.db) {
+        const list = await trxOrDb
             .selectFrom(this.personasTable)
             .selectAll()
             .orderBy('name', 'asc')

package/dist/esm/agentic/PolicyEnforcer.d.ts

@@ -33,30 +33,26 @@ export declare class PolicyEnforcer {
     /**
      * Define or update a policy with robust validation.
      */
-    definePolicy(name: string, type: AgentPolicy['type'], definition: Record<string, any>, isEnabled?: boolean): Promise<AgentPolicy>;
+    definePolicy(name: string, type: AgentPolicy['type'], definition: Record<string, any>, isEnabled?: boolean, trxOrDb?: any): Promise<AgentPolicy>;
     /**
      * Comprehensive policy evaluation against a context value.
      * Supports thresholds, regex patterns, and cumulative budgets.
      */
-    /**
-     * Comprehensive policy evaluation against a context value.
-     * Supports thresholds, regex patterns, and cumulative budgets.
-     */
-    checkPolicy(name: string, value: any, visited?: Set<string>): Promise<{
+    checkPolicy(name: string, value: any, visited?: Set<string>, trxOrDb?: any): Promise<{
         allowed: boolean;
         reason?: string;
     }>;
     /**
      * Evaluate a full context (object) against all applicable policies.
      */
-    evaluateContext(context: Record<string, any>): Promise<{
+    evaluateContext(context: Record<string, any>, trxOrDb?: any): Promise<{
         allowed: boolean;
         violations: string[];
     }>;
     /**
      * Get all active policies.
      */
-    getActivePolicies(): Promise<AgentPolicy[]>;
+    getActivePolicies(trxOrDb?: any): Promise<AgentPolicy[]>;
     private getCumulativeMetric;
     private parsePolicy;
 }

package/dist/esm/agentic/PolicyEnforcer.js

@@ -21,14 +21,15 @@ export class PolicyEnforcer {
     /**
      * Define or update a policy with robust validation.
      */
-    async definePolicy(name, type, definition, isEnabled = true) {
-        return await this.db.transaction().execute(async (trx) => {
+    async definePolicy(name, type, definition, isEnabled = true, trxOrDb = this.db) {
+        const runner = async (trx) => {
             let query = trx
                 .selectFrom(this.policiesTable)
                 .select('id')
                 .where('name', '=', name);
-            // Audit Phase 16: Exclusive lock for provisioning (Skip for SQLite)
-            if (this.db.getExecutor().adapter?.constructor.name !== 'SqliteAdapter') {
+            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();
@@ -59,17 +60,19 @@ export class PolicyEnforcer {
                 .returningAll()
                 .executeTakeFirstOrThrow();
             return this.parsePolicy(created);
-        });
+        };
+        if (trxOrDb && trxOrDb !== this.db) {
+            return await runner(trxOrDb);
+        }
+        else {
+            return await this.db.transaction().execute(runner);
+        }
     }
     /**
      * Comprehensive policy evaluation against a context value.
      * Supports thresholds, regex patterns, and cumulative budgets.
      */
-    /**
-     * Comprehensive policy evaluation against a context value.
-     * Supports thresholds, regex patterns, and cumulative budgets.
-     */
-    async checkPolicy(name, value, visited = new Set()) {
+    async checkPolicy(name, value, visited = new Set(), trxOrDb = this.db) {
         // Audit Pass 6: Re-entrancy / Circular Dependency Detection
         if (visited.has(name)) {
             return {
@@ -78,7 +81,7 @@ export class PolicyEnforcer {
             };
         }
         visited.add(name);
-        const policy = await this.typedDb
+        const policy = await trxOrDb
             .selectFrom(this.policiesTable)
             .selectAll()
             .where('name', '=', name)
@@ -109,7 +112,7 @@ export class PolicyEnforcer {
             if (def.pattern.length > 500) {
                 return { allowed: false, reason: `Policy '${name}' regex pattern too long (potential ReDoS risk)` };
             }
-            const dangerousPatterns = /(\*|\+)\1|\(\.\*\)\*/;
+            const dangerousPatterns = /(\*|\+)\1|\(\.\*\)\*|\(\[.*\](\*|\+)\)(\*|\+)|\(.*\+\)\+/;
             if (dangerousPatterns.test(def.pattern)) {
                 return { allowed: false, reason: `Policy '${name}' contains potentially dangerous ReDoS pattern` };
             }
@@ -137,7 +140,7 @@ export class PolicyEnforcer {
         if (policy.type === 'budget' && def.metricName) {
             const period = def.period || 'daily';
             const limit = def.limit || 0;
-            const total = await this.getCumulativeMetric(def.metricName, period);
+            const total = await this.getCumulativeMetric(def.metricName, period, trxOrDb);
             if (total + (typeof value === 'number' ? value : 0) > limit) {
                 return {
                     allowed: false,
@@ -149,7 +152,7 @@ export class PolicyEnforcer {
         // Audit Pass 6: Moved from evaluateContext to checkPolicy for deeper nesting support
         if (def.dependsOn && Array.isArray(def.dependsOn)) {
             for (const depName of def.dependsOn) {
-                const result = await this.checkPolicy(depName, value, new Set(visited));
+                const result = await this.checkPolicy(depName, value, new Set(visited), trxOrDb);
                 if (!result.allowed) {
                     return { allowed: false, reason: `Composite block: ${name} -> ${result.reason}` };
                 }
@@ -160,19 +163,19 @@ export class PolicyEnforcer {
     /**
      * Evaluate a full context (object) against all applicable policies.
      */
-    async evaluateContext(context) {
-        const policies = await this.getActivePolicies();
+    async evaluateContext(context, trxOrDb = this.db) {
+        const policies = await this.getActivePolicies(trxOrDb);
         const violations = [];
         for (const policy of policies) {
             // If the context has a key matching the policy name, check it
             if (context[policy.name] !== undefined) {
-                const result = await this.checkPolicy(policy.name, context[policy.name]);
+                const result = await this.checkPolicy(policy.name, context[policy.name], new Set(), trxOrDb);
                 if (!result.allowed)
                     violations.push(result.reason);
             }
             // Check for type-specific global policies (e.g. all privacy policies)
             if (policy.type === 'privacy' && context.content) {
-                const result = await this.checkPolicy(policy.name, context.content);
+                const result = await this.checkPolicy(policy.name, context.content, new Set(), trxOrDb);
                 if (!result.allowed)
                     violations.push(result.reason);
             }
@@ -185,15 +188,15 @@ export class PolicyEnforcer {
     /**
      * Get all active policies.
      */
-    async getActivePolicies() {
-        const list = await this.typedDb
+    async getActivePolicies(trxOrDb = this.db) {
+        const list = await trxOrDb
             .selectFrom(this.policiesTable)
             .selectAll()
             .where('is_enabled', '=', true)
             .execute();
         return list.map((p) => this.parsePolicy(p));
     }
-    async getCumulativeMetric(metricName, period) {
+    async getCumulativeMetric(metricName, period, trxOrDb = this.db) {
         const cacheKey = `${metricName}:${period}`;
         const cached = this.metricCache.get(cacheKey);
         const now = new Date();
@@ -215,7 +218,7 @@ export class PolicyEnforcer {
         else if (period === 'hourly') {
             cutoff = new Date(now.getTime() - 3600000);
         }
-        const result = await this.typedDb
+        const result = await trxOrDb
             .selectFrom(this.metricsTable)
             .select((eb) => eb.fn.sum('metric_value').as('total'))
             .where('metric_name', '=', metricName)

package/dist/esm/agentic/improvement/AblationEngine.d.ts

@@ -14,22 +14,26 @@ export declare class AblationEngine {
     private linksTable;
     constructor(db: Kysely<any>, cortex: Cortex, config?: AgenticConfig);
     private get typedDb();
+    /**
+     * Helper to apply forUpdate only where supported (Skip for SQLite)
+     */
+    private withLock;
     /**
      * Identify "Zombies": Items that have never been retrieved/hit and are old.
      */
-    pruneZombies(thresholdDays?: number): Promise<number>;
+    pruneZombies(thresholdDays?: number, trxOrDb?: any): Promise<number>;
     /**
      * Monitor Performance and perform Intelligent Rollbacks.
      * Prioritizes recovery of items with highest historical hit counts.
      */
-    monitorAblationPerformance(): Promise<{
+    monitorAblationPerformance(trxOrDb?: any): Promise<{
         status: 'stable' | 'degraded';
         recoveredCount: number;
     }>;
     /**
      * Conduct an "Ablation Test": Temporarily disable a knowledge item.
      */
-    testAblation(id: string | number): Promise<boolean>;
+    testAblation(id: string | number, trxOrDb?: any): Promise<boolean>;
     /**
      * Restore an ablated knowledge item to its original state.
      */

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

@@ -21,16 +21,27 @@ export 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([
@@ -41,9 +52,8 @@ export 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 = [];
@@ -78,16 +88,22 @@ export 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.`);
@@ -115,20 +131,25 @@ export 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'
@@ -138,7 +159,7 @@ export 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({
@@ -153,19 +174,25 @@ export 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/esm/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/esm/agentic/improvement/ActionRefiner.js

@@ -17,12 +17,12 @@ export 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'))
@@ -41,11 +41,11 @@ export 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')
@@ -60,25 +60,29 @@ export 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', {
@@ -88,16 +92,22 @@ export 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);
     }
 }

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

@@ -62,7 +62,8 @@ export 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/esm/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/esm/agentic/improvement/EvolutionaryPilot.js

@@ -16,7 +16,7 @@ export 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;
@@ -28,7 +28,7 @@ export 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
@@ -41,14 +41,14 @@ export 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;
@@ -59,7 +59,7 @@ export 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;
             }
@@ -72,13 +72,13 @@ export 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');
@@ -89,11 +89,11 @@ export 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)
@@ -150,21 +150,19 @@ export 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 sql `PRAGMA optimize`.execute(this.db);
+            await 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;
     }