noormme 1.2.3 → 1.2.5

package/dist/cjs/agentic/improvement/strategy/MutationEngine.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MutationEngine = void 0;
+class MutationEngine {
+    personasTable;
+    constructor(personasTable) {
+        this.personasTable = personasTable;
+    }
+    async applyMutation(db, cortex, persona, report, failures = [], sanitizeRoleFn, parsePersonaFn) {
+        return await db.transaction().execute(async (trx) => {
+            const reason = failures.length > 0 ? `Failure Patterns: ${failures.join(', ')}` : report.recommendation;
+            let updates = {};
+            let mutationType = 'role_update';
+            if (failures.length > 0) {
+                const lessons = await cortex.reasoner.synthesizeLessons(trx);
+                const relevantLessons = (lessons['general'] || []).slice(0, 2);
+                updates = {
+                    role: `${persona.role || ''} (Optimized for: ${failures.join(', ')}. Patterns: ${relevantLessons.join('; ')})`.trim(),
+                };
+            }
+            else {
+                const allPersonas = await trx.selectFrom(this.personasTable).selectAll().execute();
+                const winningMutations = allPersonas
+                    .map((p) => parsePersonaFn(p))
+                    .filter((p) => (p.metadata?.evolution_status === 'stable' || !p.metadata?.evolution_status) && p.metadata?.mutation_reason?.includes(report.recommendation));
+                if (winningMutations.length > 0) {
+                    const sorted = winningMutations.sort((a, b) => (b.metadata?.anchored_reliability || 0) - (a.metadata?.anchored_reliability || 0));
+                    const alphaMatch = sorted[0];
+                    updates = { role: sanitizeRoleFn(alphaMatch.role || persona.role || 'Agent') };
+                }
+                else {
+                    switch (report.recommendation) {
+                        case 'optimize_accuracy':
+                            updates = { role: sanitizeRoleFn(`${persona.role || ''} (Focus strictly on accuracy and detailed verification)`) };
+                            break;
+                        case 'optimize_efficiency':
+                            updates = { policies: [...(persona.policies || []), 'timeout_reduction', 'concise_output'] };
+                            mutationType = 'policy_update';
+                            break;
+                        case 'critical_intervention':
+                            return await this.rollback(db, persona.id, parsePersonaFn);
+                        default:
+                            return null;
+                    }
+                }
+            }
+            if (updates.role)
+                updates.role = sanitizeRoleFn(updates.role);
+            // Conflict Detection
+            const contradictions = await cortex.reasoner.detectContradictions(trx);
+            for (const contradiction of contradictions) {
+                if (updates.role && contradiction.includes(updates.role.slice(0, 20)))
+                    return null;
+            }
+            const mutation = {
+                id: `mut_${Date.now()}`,
+                timestamp: Date.now(),
+                type: mutationType,
+                previousState: { role: persona.role, policies: persona.policies, capabilities: persona.capabilities },
+                newState: { ...updates },
+                reason: `Auto-mutation triggered by ${report.recommendation}`,
+            };
+            const history = [...(persona.metadata?.mutationHistory || []), mutation].slice(-5);
+            const newMetadata = {
+                ...persona.metadata,
+                mutationHistory: history,
+                evolution_status: 'verifying',
+                mutation_reason: report.recommendation,
+                verification_started_at: Date.now(),
+                verification_baseline: { successRate: report.successRate, averageLatency: report.averageLatency },
+            };
+            await trx.updateTable(this.personasTable)
+                .set({
+                role: updates.role || persona.role,
+                policies: updates.policies ? JSON.stringify(updates.policies) : undefined,
+                capabilities: updates.capabilities ? JSON.stringify(updates.capabilities) : undefined,
+                metadata: JSON.stringify(newMetadata),
+                updated_at: new Date(),
+            })
+                .where('id', '=', persona.id)
+                .execute();
+            return `Persona ${persona.id} mutated and entering verification window.`;
+        });
+    }
+    async rollback(db, id, parsePersonaFn) {
+        return await db.transaction().execute(async (trx) => {
+            const current = await trx.selectFrom(this.personasTable).selectAll().where('id', '=', id).executeTakeFirst();
+            if (!current)
+                throw new Error(`Persona ${id} not found`);
+            const persona = parsePersonaFn(current);
+            const history = persona.metadata?.mutationHistory || [];
+            const lastMutation = history.pop();
+            if (!lastMutation)
+                return `No mutations to rollback for persona ${id}`;
+            const previous = lastMutation.previousState;
+            const rollbackHistory = [...(persona.metadata?.rollbackHistory || []), Date.now()];
+            const newMetadata = {
+                ...persona.metadata,
+                mutationHistory: history,
+                rollbackHistory: rollbackHistory,
+                last_failed_mutation: { type: lastMutation.type, timestamp: Date.now() },
+                evolution_status: 'stable',
+                lastRollback: Date.now(),
+            };
+            await trx.updateTable(this.personasTable)
+                .set({
+                role: previous.role,
+                policies: previous.policies ? JSON.stringify(previous.policies) : undefined,
+                capabilities: previous.capabilities ? JSON.stringify(previous.capabilities) : undefined,
+                metadata: JSON.stringify(newMetadata),
+                updated_at: new Date(),
+            })
+                .where('id', '=', id)
+                .execute();
+            return `Rolled back mutation ${lastMutation.id} for persona ${id}`;
+        });
+    }
+}
+exports.MutationEngine = MutationEngine;

package/dist/cjs/agentic/improvement/strategy/PerformanceAnalyst.d.ts

@@ -0,0 +1,6 @@
+import type { Cortex } from '../../Cortex.js';
+import type { PerformanceReport } from '../StrategicPlanner.js';
+export declare class PerformanceAnalyst {
+    analyzeFailurePatterns(cortex: Cortex, personaId: string | number, trxOrDb?: any): Promise<string[]>;
+    analyze(trxOrDb: any, cortex: Cortex, metricsTable: string, id: string | number): Promise<PerformanceReport>;
+}

package/dist/cjs/agentic/improvement/strategy/PerformanceAnalyst.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PerformanceAnalyst = void 0;
+const sql_js_1 = require("../../../raw-builder/sql.js");
+class PerformanceAnalyst {
+    async analyzeFailurePatterns(cortex, personaId, trxOrDb = cortex.db) {
+        const patterns = [];
+        try {
+            // NOTE: cortex.actions.getFailureReport might need to be transaction-aware too
+            const failureReport = await cortex.actions.getFailureReport(trxOrDb);
+            const frequentFailures = failureReport.filter((f) => f.failureCount > 1);
+            for (const fail of frequentFailures) {
+                patterns.push(`tool_failure_${fail.toolName}`);
+            }
+        }
+        catch (e) {
+            // Fallback handled by orchestrator
+        }
+        return patterns;
+    }
+    async analyze(trxOrDb, cortex, metricsTable, id) {
+        const recentMetrics = await trxOrDb
+            .selectFrom(metricsTable)
+            .selectAll()
+            .where((eb) => eb.or([
+            eb((0, sql_js_1.sql) `json_extract(metadata, '$.persona_id')`, '=', id),
+            eb((0, sql_js_1.sql) `metadata->>'persona_id'`, '=', String(id)),
+        ]))
+            .orderBy('created_at', 'desc')
+            .limit(50)
+            .execute();
+        const globalMetrics = await cortex.metrics.getRecentMetrics(200, trxOrDb);
+        const calcStats = (metricName) => {
+            const vals = globalMetrics
+                .filter((m) => m.metricName === metricName)
+                .map((m) => Number(m.metricValue));
+            if (vals.length < 10)
+                return { mean: metricName === 'query_latency' ? 500 : 0.9, stdDev: 0.1 };
+            const mean = vals.reduce((a, b) => a + b, 0) / vals.length;
+            const variance = vals.reduce((a, b) => a + Math.pow(b - mean, 2), 0) / vals.length;
+            return { mean, stdDev: Math.sqrt(variance) || 0.05 };
+        };
+        const successStats = calcStats('task_success_rate');
+        const latencyStats = calcStats('query_latency');
+        if (recentMetrics.length === 0) {
+            return {
+                personaId: id,
+                successRate: successStats.mean,
+                averageLatency: latencyStats.mean,
+                sampleSize: 0,
+                recommendation: 'maintain',
+            };
+        }
+        const successMetrics = recentMetrics.filter((m) => m.metric_name === 'task_success_rate');
+        const latencyMetrics = recentMetrics.filter((m) => m.metric_name === 'query_latency');
+        const avgSuccess = successMetrics.length > 0
+            ? successMetrics.reduce((sum, m) => sum + Number(m.metric_value), 0) / successMetrics.length
+            : successStats.mean;
+        const avgLatency = latencyMetrics.length > 0
+            ? latencyMetrics.reduce((sum, m) => sum + Number(m.metric_value), 0) / latencyMetrics.length
+            : latencyStats.mean;
+        let recommendation = 'maintain';
+        const criticalThreshold = successStats.mean - 2.5 * successStats.stdDev;
+        const accuracyThreshold = successStats.mean - 1.0 * successStats.stdDev;
+        const efficiencyThreshold = latencyStats.mean + 2.0 * latencyStats.stdDev;
+        if (avgSuccess < criticalThreshold) {
+            recommendation = 'critical_intervention';
+        }
+        else if (avgSuccess < accuracyThreshold) {
+            recommendation = 'optimize_accuracy';
+        }
+        else if (avgLatency > efficiencyThreshold) {
+            recommendation = 'optimize_efficiency';
+        }
+        return {
+            personaId: id,
+            successRate: avgSuccess,
+            averageLatency: avgLatency,
+            sampleSize: recentMetrics.length,
+            recommendation,
+        };
+    }
+}
+exports.PerformanceAnalyst = PerformanceAnalyst;

package/dist/cjs/agentic/util/db-utils.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Utility function to apply a "FOR UPDATE" lock only where supported (Not in SQLite)
+ */
+export declare function withLock(query: any, trx: any): any;

package/dist/cjs/agentic/util/db-utils.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withLock = withLock;
+/**
+ * Utility function to apply a "FOR UPDATE" lock only where supported (Not in SQLite)
+ */
+function withLock(query, trx) {
+    if (!trx || typeof trx.getExecutor !== 'function') {
+        // If we're using a mock or a version of Kysely without getExecutor
+        // we default to no lock to prevent failures in tests
+        return query;
+    }
+    try {
+        const executor = trx.getExecutor();
+        const adapterName = executor?.adapter?.constructor?.name ||
+            executor?.dialect?.constructor?.name ||
+            '';
+        if (adapterName.toLowerCase().includes('sqlite')) {
+            return query;
+        }
+    }
+    catch (error) {
+        // Fallback if execution fails for some reason
+        return query;
+    }
+    return query.forUpdate();
+}

package/dist/cjs/helpers/agent-schema.js

@@ -119,6 +119,7 @@ class AgentSchemaHelper {
             .addColumn('tool_name', 'text', (col) => col.notNull())
             .addColumn('arguments', 'text', (col) => col.notNull())
             .addColumn('outcome', 'text')
+            .addColumn('error', 'text')
             .addColumn('status', 'text', (col) => col.notNull().defaultTo('pending'))
             .addColumn('duration_ms', 'integer')
             .addColumn('metadata', 'text')

package/dist/cjs/testing/test-utils.js

@@ -94,6 +94,8 @@ async function setupTestSchema(db) {
         .on('comments')
         .column('user_id')
         .execute();
+    // Initialize agent schema
+    await db.agent.schema.initializeSchema();
     // Initialize NOORMME to discover the schema
     // Temporarily enable warnings to see discovery errors
     const originalWarn = console.warn;

package/dist/cjs/types/index.d.ts

@@ -385,6 +385,14 @@ export interface AgentPersona {
     createdAt: Date;
     updatedAt: Date;
 }
+export interface PersonaMutation {
+    id: string;
+    timestamp: number;
+    type: 'role_update' | 'policy_update' | 'capability_update';
+    previousState: Partial<AgentPersona>;
+    newState: Partial<AgentPersona>;
+    reason: string;
+}
 export interface AgentQuota {
     id: string | number;
     targetType: 'persona' | 'swarm' | 'global';

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

@@ -1,5 +1,5 @@
 import type { Kysely } from '../kysely.js';
-import type { AgenticConfig, AgentAction } from '../types/index.js';
+import type { AgentAction, AgenticConfig } from '../types/index.js';
 import type { TelemetryOrchestrator } from './telemetry/TelemetryOrchestrator.js';
 export interface ActionTable {
     id: number | string;
@@ -30,26 +30,26 @@ export declare class ActionJournal {
     /**
      * Log an action (tool call)
      */
-    logAction(sessionId: string | number, toolName: string, args: Record<string, any>, messageId?: string | number): Promise<AgentAction>;
+    logAction(sessionId: string | number, toolName: string, args: Record<string, any>, messageId?: string | number, trxOrDb?: any): Promise<AgentAction>;
     /**
      * Update action with outcome
      */
-    recordOutcome(actionId: string | number, status: AgentAction['status'], outcome: string, durationMs?: number, metadata?: Record<string, any>): Promise<AgentAction>;
+    recordOutcome(actionId: string | number, status: AgentAction['status'], outcome: string, durationMs?: number, metadata?: Record<string, any>, trxOrDb?: any): Promise<AgentAction>;
     /**
      * Get actions for a session with pagination
      */
     getSessionActions(sessionId: string | number, options?: {
         limit?: number;
         cursor?: string | number;
-    }): Promise<AgentAction[]>;
+    }, trxOrDb?: any): Promise<AgentAction[]>;
     /**
      * Get actions by tool name across all sessions.
      */
-    getActionsByTool(toolName: string, limit?: number): Promise<AgentAction[]>;
+    getActionsByTool(toolName: string, limit?: number, trxOrDb?: any): Promise<AgentAction[]>;
     /**
      * Generate a report of tool failures.
      */
-    getFailureReport(): Promise<{
+    getFailureReport(trxOrDb?: any): Promise<{
         toolName: string;
         failureCount: number;
         lastFailure: string;

package/dist/esm/agentic/ActionJournal.js

@@ -20,8 +20,8 @@ export class ActionJournal {
     /**
      * Log an action (tool call)
      */
-    async logAction(sessionId, toolName, args, messageId) {
-        const action = await this.typedDb
+    async logAction(sessionId, toolName, args, messageId, trxOrDb = this.db) {
+        const action = await trxOrDb
             .insertInto(this.actionsTable)
             .values({
             session_id: sessionId,
@@ -43,8 +43,8 @@ export class ActionJournal {
     /**
      * Update action with outcome
      */
-    async recordOutcome(actionId, status, outcome, durationMs, metadata) {
-        const action = await this.typedDb
+    async recordOutcome(actionId, status, outcome, durationMs, metadata, trxOrDb = this.db) {
+        const action = await trxOrDb
             .updateTable(this.actionsTable)
             .set({
             status,
@@ -67,9 +67,9 @@ export class ActionJournal {
     /**
      * Get actions for a session with pagination
      */
-    async getSessionActions(sessionId, options = {}) {
+    async getSessionActions(sessionId, options = {}, trxOrDb = this.db) {
         const { limit = 100, cursor } = options;
-        let query = this.typedDb
+        let query = trxOrDb
             .selectFrom(this.actionsTable)
             .selectAll()
             .where('session_id', '=', sessionId)
@@ -84,8 +84,8 @@ export class ActionJournal {
     /**
      * Get actions by tool name across all sessions.
      */
-    async getActionsByTool(toolName, limit = 50) {
-        const actions = await this.typedDb
+    async getActionsByTool(toolName, limit = 50, trxOrDb = this.db) {
+        const actions = await trxOrDb
             .selectFrom(this.actionsTable)
             .selectAll()
             .where('tool_name', '=', toolName)
@@ -97,10 +97,10 @@ export class ActionJournal {
     /**
      * Generate a report of tool failures.
      */
-    async getFailureReport() {
+    async getFailureReport(trxOrDb = this.db) {
         // Audit Phase 19: Sliding window (default 7 days) to prevent OOM/slow scans
         const windowStart = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
-        const results = await this.typedDb
+        const results = await trxOrDb
             .selectFrom(this.actionsTable)
             .select([
             'tool_name',

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

@@ -30,24 +30,24 @@ export declare class CapabilityManager {
     /**
      * Register or update a capability (skill)
      */
-    registerCapability(name: string, version: string, description?: string, metadata?: Record<string, any>): Promise<AgentCapability>;
+    registerCapability(name: string, version: string, description?: string, metadata?: Record<string, any>, trxOrDb?: any): Promise<AgentCapability>;
     /**
      * Update reliability based on action outcome using a damped moving average.
      * Manages the lifecycle of emergent skills (sandbox -> verified / blacklisted).
      */
-    reportOutcome(name: string, success: boolean): Promise<void>;
+    reportOutcome(name: string, success: boolean, trxOrDb?: any): Promise<void>;
     /**
      * Get reliability score for a capability.
      */
-    getReliability(name: string): Promise<number>;
+    getReliability(name: string, trxOrDb?: any): Promise<number>;
     /**
      * Get all registered capabilities, optionally filtered by status
      */
-    getCapabilities(status?: AgentCapability['status']): Promise<AgentCapability[]>;
+    getCapabilities(status?: AgentCapability['status'], trxOrDb?: any): Promise<AgentCapability[]>;
     /**
      * Validate if a persona has access to a specific capability (Sandbox Enforcement).
      */
-    validateCapabilityAccess(personaId: string | number, capabilityName: string): Promise<{
+    validateCapabilityAccess(personaId: string | number, capabilityName: string, trxOrDb?: any): Promise<{
         allowed: boolean;
         reason?: string;
     }>;

package/dist/esm/agentic/CapabilityManager.js

@@ -1,4 +1,5 @@
 /// <reference types="./CapabilityManager.d.ts" />
+import { withLock } from './util/db-utils.js';
 /**
  * CapabilityManager tracks the skills (tools) available to an agent
  * and their historical reliability.
@@ -28,8 +29,8 @@ export class CapabilityManager {
     /**
      * Register or update a capability (skill)
      */
-    async registerCapability(name, version, description, metadata = {}) {
-        return await this.db.transaction().execute(async (trx) => {
+    async registerCapability(name, version, description, metadata = {}, trxOrDb = this.db) {
+        const runner = async (trx) => {
             const existing = await trx
                 .selectFrom(this.capabilitiesTable)
                 .selectAll()
@@ -72,24 +73,27 @@ export class CapabilityManager {
                 .returningAll()
                 .executeTakeFirstOrThrow();
             return this.parseCapability(created);
-        });
+        };
+        if (trxOrDb && trxOrDb !== this.db) {
+            return await runner(trxOrDb);
+        }
+        else {
+            return await this.db.transaction().execute(runner);
+        }
     }
     /**
      * Update reliability based on action outcome using a damped moving average.
      * Manages the lifecycle of emergent skills (sandbox -> verified / blacklisted).
      */
-    async reportOutcome(name, success) {
-        await this.db.transaction().execute(async (trx) => {
-            let query = trx
+    async reportOutcome(name, success, trxOrDb = this.db) {
+        const runner = async (trx) => {
+            const baseQuery = trx
                 .selectFrom(this.capabilitiesTable)
                 .selectAll()
                 .where('name', '=', name)
                 .orderBy('updated_at', 'desc');
-            // PRODUCTION HARDENING: Lock row to prevent RMW race (Skip for SQLite)
-            if (this.db.getExecutor().adapter?.constructor.name !== 'SqliteAdapter') {
-                query = query.forUpdate();
-            }
-            const capability = await query.executeTakeFirst();
+            const capability = await withLock(baseQuery, trx)
+                .executeTakeFirst();
             if (capability) {
                 const cap = capability;
                 const metadata = typeof cap.metadata === 'string'
@@ -187,13 +191,19 @@ export class CapabilityManager {
                     .where('id', '=', cap.id)
                     .execute();
             }
-        });
+        };
+        if (trxOrDb && trxOrDb !== this.db) {
+            await runner(trxOrDb);
+        }
+        else {
+            await this.db.transaction().execute(runner);
+        }
     }
     /**
      * Get reliability score for a capability.
      */
-    async getReliability(name) {
-        const cap = await this.typedDb
+    async getReliability(name, trxOrDb = this.db) {
+        const cap = await trxOrDb
             .selectFrom(this.capabilitiesTable)
             .select('reliability')
             .where('name', '=', name)
@@ -204,8 +214,8 @@ export class CapabilityManager {
     /**
      * Get all registered capabilities, optionally filtered by status
      */
-    async getCapabilities(status) {
-        let query = this.typedDb
+    async getCapabilities(status, trxOrDb = this.db) {
+        let query = trxOrDb
             .selectFrom(this.capabilitiesTable)
             .selectAll();
         if (status) {
@@ -221,9 +231,10 @@ export class CapabilityManager {
         // Filter to latest/best variants if many versions exist
         const unique = new Map();
         for (const c of list) {
-            const meta = typeof c.metadata === 'string' ? JSON.parse(c.metadata) : (c.metadata || {});
-            if (!unique.has(c.name) || meta.is_alpha) {
-                unique.set(c.name, c);
+            const cap = c;
+            const meta = typeof cap.metadata === 'string' ? JSON.parse(cap.metadata) : (cap.metadata || {});
+            if (!unique.has(cap.name) || meta.is_alpha) {
+                unique.set(cap.name, cap);
             }
         }
         return Array.from(unique.values()).map((c) => this.parseCapability(c));
@@ -231,13 +242,13 @@ export class CapabilityManager {
     /**
      * Validate if a persona has access to a specific capability (Sandbox Enforcement).
      */
-    async validateCapabilityAccess(personaId, capabilityName) {
-        const persona = await this.cortex.personas.getPersona(String(personaId)) ||
-            await this.typedDb.selectFrom(this.config.personasTable || 'agent_personas')
+    async validateCapabilityAccess(personaId, capabilityName, trxOrDb = this.db) {
+        const persona = await this.cortex.personas.getPersona(String(personaId), trxOrDb) ||
+            await trxOrDb.selectFrom(this.config.personasTable || 'agent_personas')
                 .selectAll()
                 .where('id', '=', personaId)
                 .executeTakeFirst()
-                .then(p => p ? this.cortex.personas.parsePersona(p) : null);
+                .then((p) => p ? this.cortex.personas.parsePersona(p) : null);
         if (!persona) {
             return { allowed: false, reason: `Persona ${personaId} not found.` };
         }
@@ -249,7 +260,7 @@ export class CapabilityManager {
             };
         }
         // Check if capability is blacklisted globally
-        const cap = await this.typedDb
+        const cap = await trxOrDb
             .selectFrom(this.capabilitiesTable)
             .select(['status', 'reliability'])
             .where('name', '=', capabilityName)

package/dist/esm/agentic/Cortex.js

@@ -131,23 +131,22 @@ export class Cortex {
         this.executionLock = true;
         console.log('[Cortex] Initiating Autonomous Soul-Searching Loop v2 (Deep Hardening Pass)...');
         try {
-            // 1. Audit health & Run self-tests
-            await this.#runIsolated('Audit', () => this.governor.performAudit());
-            await this.#runIsolated('Self-Tests', () => this.tests.runAllProbes());
-            // 2. Run background rituals (optimization, compression)
-            await this.#runIsolated('Rituals', () => this.rituals.runPendingRituals());
-            // 3. Learn from actions & Prune dead data
-            await this.#runIsolated('Action Refinement', () => this.refiner.refineActions());
-            await this.#runIsolated('Zombie Pruning', () => this.ablation.pruneZombies());
-            await this.#runIsolated('Ablation Monitoring', () => this.ablation.monitorAblationPerformance());
-            // 4. Mutation & Strategy
+            await this.db.transaction().execute(async (trx) => {
+                // 1. Audit health & Run self-tests
+                await this.#runIsolated('Audit', () => this.governor.performAudit(trx));
+                await this.#runIsolated('Self-Tests', () => this.tests.runAllProbes(trx));
+                // 2. Run background rituals (optimization, compression)
+                await this.#runIsolated('Rituals', () => this.rituals.runPendingRituals(trx));
+                // 3. Learn from actions & Prune dead data
+                await this.#runIsolated('Action Refinement', () => this.refiner.refineActions(trx));
+                await this.#runIsolated('Zombie Pruning', () => this.ablation.pruneZombies(30, trx));
+                await this.#runIsolated('Ablation Monitoring', () => this.ablation.monitorAblationPerformance(trx));
+            });
+            // These are often long-running or have their own internal transaction boundaries
             await this.#runIsolated('Strategy Mutation', () => this.strategy.mutateStrategy());
-            // 5. High-Throughput Evolution Pulse
             await this.#runIsolated('Evolution Pulse', () => this.evolutionRitual.execute());
-            // 6. Broadcast knowledge & skills
             await this.#runIsolated('Knowledge Broadcast', () => this.hive.broadcastKnowledge());
             await this.#runIsolated('Skill Synthesis', () => this.skillSynthesizer.discoverAndSynthesize());
-            // 7. Evolutionary pulse
             await this.#runIsolated('Improvement Cycle', () => this.pilot.runSelfImprovementCycle());
             console.log('[Cortex] Soul-Searching loop completed.');
         }

package/dist/esm/agentic/EpisodicMemory.js

@@ -1,4 +1,5 @@
 /// <reference types="./EpisodicMemory.d.ts" />
+import { withLock } from './util/db-utils.js';
 /**
  * EpisodicMemory groups interactions into semantic chunks (episodes),
  * allowing agents to recall specific scenarios and their outcomes.
@@ -37,11 +38,11 @@ export class EpisodicMemory {
      */
     async completeEpisode(episodeId, summary, metadata) {
         return await this.db.transaction().execute(async (trx) => {
-            const existing = await trx
+            const query = trx
                 .selectFrom(this.episodesTable)
                 .selectAll()
-                .where('id', '=', episodeId)
-                .forUpdate() // Audit Phase 12: Atomic completion lock
+                .where('id', '=', episodeId);
+            const existing = await withLock(query, trx) // Audit Phase 12: Atomic completion lock
                 .executeTakeFirst();
             if (!existing)
                 throw new Error(`Episode with ID ${episodeId} not found`);

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

@@ -30,18 +30,18 @@ export declare class PersonaManager {
         capabilities?: string[];
         policies?: string[];
         metadata?: Record<string, any>;
-    }): Promise<AgentPersona>;
+    }, trxOrDb?: any): Promise<AgentPersona>;
     /**
      * Get a persona by name
      */
-    getPersona(name: string): Promise<AgentPersona | null>;
+    getPersona(name: string, trxOrDb?: any): Promise<AgentPersona | null>;
     /**
      * Delete a persona by name
      */
-    deletePersona(name: string): Promise<boolean>;
+    deletePersona(name: string, trxOrDb?: any): Promise<boolean>;
     /**
      * List all personas
      */
-    listPersonas(): Promise<AgentPersona[]>;
+    listPersonas(trxOrDb?: any): Promise<AgentPersona[]>;
     private parsePersona;
 }