noormme 1.2.3 → 1.2.5

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

@@ -44,8 +44,8 @@ class RecursiveReasoner {
     /**
      * Find goals matching a pattern across all sessions
      */
-    async analyzeGlobalProgress(pattern) {
-        const goals = (await this.typedDb
+    async analyzeGlobalProgress(pattern, trxOrDb = this.db) {
+        const goals = (await trxOrDb
             .selectFrom(this.goalsTable)
             .selectAll()
             .where('description', 'like', `%${pattern}%`)
@@ -57,10 +57,10 @@ class RecursiveReasoner {
      * Synthesize high-level lessons and cluster similar ones using Token-Weighted significance.
      * Pass 5: High-Throughput Semantic Analysis.
      */
-    async synthesizeLessons() {
+    async synthesizeLessons(trxOrDb = this.db) {
         console.log('[RecursiveReasoner] Performing high-throughput weighted token clustering...');
         const reflectionsTable = this.config.reflectionsTable || 'agent_reflections';
-        const results = (await this.typedDb
+        const results = (await trxOrDb
             .selectFrom(reflectionsTable)
             .select('lessons_learned')
             .where('lessons_learned', 'is not', null)
@@ -100,12 +100,12 @@ class RecursiveReasoner {
      * Pass 6: Goal Cross-Pollination
      * Distill successful persona mutations into global systemic goals.
      */
-    async crossPollinateGoals() {
+    async crossPollinateGoals(trxOrDb = this.db) {
         console.log('[RecursiveReasoner] Cross-pollinating successful persona breakthroughs into global goals...');
         const personasTable = this.config.personasTable || 'agent_personas';
         const goalsTable = this.config.goalsTable || 'agent_goals';
         // Find personas with 'stable' evolution status (proven breakthroughs)
-        const breakthroughs = await this.typedDb
+        const breakthroughs = await trxOrDb
             .selectFrom(personasTable)
             .selectAll()
             .where('metadata', 'like', '%"evolution_status":"stable"%')
@@ -120,7 +120,7 @@ class RecursiveReasoner {
             .filter(Boolean);
         if (descriptions.length === 0)
             return 0;
-        const existingGoals = await this.typedDb
+        const existingGoals = await trxOrDb
             .selectFrom(goalsTable)
             .select('description')
             .where('description', 'in', descriptions)
@@ -130,7 +130,7 @@ class RecursiveReasoner {
         for (const desc of descriptions) {
             if (!existingSet.has(desc)) {
                 console.log(`[RecursiveReasoner] Distilling breakthrough into Global Goal: ${desc.slice(0, 50)}...`);
-                await this.typedDb
+                await trxOrDb
                     .insertInto(goalsTable)
                     .values({
                     session_id: 0, // System-level goal
@@ -152,9 +152,9 @@ class RecursiveReasoner {
     /**
      * Detect contradictions in goals (e.g., opposing objectives).
      */
-    async detectContradictions() {
+    async detectContradictions(trxOrDb = this.db) {
         console.log('[RecursiveReasoner] Detecting logical contradictions in systemic goals...');
-        const activeGoals = (await this.typedDb
+        const activeGoals = (await trxOrDb
             .selectFrom(this.goalsTable)
             .selectAll()
             .where('status', '=', 'active')

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

@@ -1,5 +1,5 @@
 import type { Kysely } from '../../kysely.js';
-import type { AgenticConfig, AgentReflection } from '../../types/index.js';
+import type { AgentReflection, AgenticConfig } from '../../types/index.js';
 /**
  * ReflectionEngine enables agents to perform "post-mortems" on sessions,
  * storing lessons learned and evaluating outcomes to improve future performance.
@@ -12,7 +12,7 @@ export declare class ReflectionEngine {
     /**
      * Record a reflection for a session
      */
-    reflect(sessionId: string | number, outcome: AgentReflection['outcome'], lessonsLearned: string, suggestedActions?: string[], metadata?: Record<string, any>): Promise<AgentReflection>;
+    reflect(sessionId: string | number, outcome: AgentReflection['outcome'], lessonsLearned: string, suggestedActions?: string[], metadata?: Record<string, any>, trxOrDb?: any): Promise<AgentReflection>;
     /**
      * Get reflections for a specific session
      */

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

@@ -17,8 +17,8 @@ class ReflectionEngine {
     /**
      * Record a reflection for a session
      */
-    async reflect(sessionId, outcome, lessonsLearned, suggestedActions, metadata) {
-        const reflection = (await this.db
+    async reflect(sessionId, outcome, lessonsLearned, suggestedActions, metadata, trxOrDb = this.db) {
+        const reflection = (await trxOrDb
             .insertInto(this.reflectionsTable)
             .values({
             session_id: sessionId,

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

@@ -1,5 +1,5 @@
 import type { Kysely } from '../../kysely.js';
-import type { AgenticConfig, AgentRitual } from '../../types/index.js';
+import type { AgentRitual, AgenticConfig } from '../../types/index.js';
 import type { Cortex } from '../Cortex.js';
 /**
  * RitualOrchestrator handles the periodic execution of background tasks
@@ -18,11 +18,11 @@ export declare class RitualOrchestrator {
     /**
      * Run all pending rituals that are due
      */
-    runPendingRituals(): Promise<number>;
+    runPendingRituals(trxOrDb?: any): Promise<number>;
     /**
      * Execute a specific ritual
      */
-    executeRitual(ritual: AgentRitual): Promise<void>;
+    executeRitual(ritual: AgentRitual, trxOrDb?: any): Promise<void>;
     /**
      * Calculate next run with Adaptive Backoff for failures
      */

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

@@ -39,10 +39,10 @@ class RitualOrchestrator {
     /**
      * Run all pending rituals that are due
      */
-    async runPendingRituals() {
+    async runPendingRituals(trxOrDb = this.db) {
         const now = new Date();
         const lockTimeout = new Date(now.getTime() + 600000); // 10 min lock by default
-        const pending = await this.db.transaction().execute(async (trx) => {
+        const runner = async (trx) => {
             const due = (await trx
                 .selectFrom(this.ritualsTable)
                 .selectAll()
@@ -64,20 +64,23 @@ class RitualOrchestrator {
                     .execute();
             }
             return due;
-        });
+        };
+        const pending = (trxOrDb !== this.db)
+            ? await runner(trxOrDb)
+            : await this.db.transaction().execute(runner);
         if (pending.length === 0)
             return 0;
         console.log(`[RitualOrchestrator] Found ${pending.length} pending rituals due. Locking for execution...`);
         for (const ritual of pending) {
-            // Execute out-of-transaction to avoid long-held locks if sub-tasks are slow
-            await this.executeRitual(ritual);
+            // Execute with the same trxOrDb context
+            await this.executeRitual(ritual, trxOrDb);
         }
         return pending.length;
     }
     /**
      * Execute a specific ritual
      */
-    async executeRitual(ritual) {
+    async executeRitual(ritual, trxOrDb = this.db) {
         console.log(`[RitualOrchestrator] Executing ritual: ${ritual.name} (${ritual.type})`);
         const ritualMetadata = {
             ...ritual.metadata,
@@ -94,7 +97,7 @@ class RitualOrchestrator {
                     let offset = 0;
                     const batchSize = 100; // Audit Phase 17: Paginated session processing
                     while (true) {
-                        const activeSessions = await this.db
+                        const activeSessions = await trxOrDb
                             .selectFrom(sessionsTable)
                             .select('id')
                             .where('status', '=', 'active')
@@ -104,7 +107,7 @@ class RitualOrchestrator {
                         if (activeSessions.length === 0)
                             break;
                         for (const session of activeSessions) {
-                            const countResult = (await this.db
+                            const countResult = (await trxOrDb
                                 .selectFrom(messagesTable)
                                 .select((eb) => eb.fn.countAll().as('count'))
                                 .where('session_id', '=', session.id)
@@ -152,7 +155,7 @@ class RitualOrchestrator {
             // Update ritual status, unlock, and schedule next run
             const frequency = ritual.frequency || 'daily';
             const nextRun = this.calculateNextRun(frequency, success ? 0 : ritualMetadata.failureCount);
-            await this.db
+            await trxOrDb
                 .updateTable(this.ritualsTable)
                 .set({
                 status: success ? 'success' : 'failure',

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

@@ -25,7 +25,7 @@ export declare class SelfEvolution {
     evolve(ddl: string, options?: {
         name?: string;
         metadata?: Record<string, any>;
-    }): Promise<void>;
+    }, trxOrDb?: any): Promise<void>;
     /**
      * Regenerate and write types to file if configured.
      */

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

@@ -61,28 +61,27 @@ class SelfEvolution {
      * Ensure core agentic tables have telemetry columns like 'accessed_at'
      */
     async ensureTelemetryColumns() {
-        const tables = [
+        const tableNames = [
             this.config.agentic?.sessionsTable || 'agent_sessions',
             this.config.agentic?.messagesTable || 'agent_messages',
             this.config.agentic?.memoriesTable || 'agent_memories',
             this.config.agentic?.goalsTable || 'agent_goals',
             this.config.agentic?.knowledgeTable || 'agent_knowledge_base',
         ];
-        for (const table of tables) {
-            try {
-                const introspector = this.db.introspection;
-                const tableInfo = await introspector
-                    .getTables()
-                    .then((ts) => ts.find((t) => t.name === table));
+        try {
+            const introspector = this.db.introspection;
+            const allTables = await introspector.getTables();
+            for (const tableName of tableNames) {
+                const tableInfo = allTables.find((t) => t.name === tableName);
                 if (tableInfo &&
                     !tableInfo.columns.some((c) => c.name === 'accessed_at')) {
-                    console.log(`[SelfEvolution] Adding 'accessed_at' column to ${table}`);
-                    await (0, sql_js_1.sql) `ALTER TABLE ${sql_js_1.sql.table(table)} ADD COLUMN accessed_at TIMESTAMP`.execute(this.db);
+                    console.log(`[SelfEvolution] Adding 'accessed_at' column to ${tableName}`);
+                    await (0, sql_js_1.sql) `ALTER TABLE ${sql_js_1.sql.table(tableName)} ADD COLUMN accessed_at TIMESTAMP`.execute(this.db);
                 }
             }
-            catch (e) {
-                console.warn(`[SelfEvolution] Failed to add telemetry column to ${table}:`, e);
-            }
+        }
+        catch (e) {
+            console.warn(`[SelfEvolution] Failed to add telemetry columns:`, e);
         }
     }
     /**
@@ -133,12 +132,10 @@ class SelfEvolution {
     /**
      * Apply a schema suggestion and instantly regenerate types
      */
-    async evolve(ddl, options = {}) {
+    async evolve(ddl, options = {}, trxOrDb = this.db) {
         console.log(`[SelfEvolution] Applying structural change: ${ddl}`);
-        await this.db.transaction().execute(async (trx) => {
+        const runner = async (trx) => {
             // 1. Apply the DDL change
-            // Pass transaction to evolution helper if it supports it, 
-            // otherwise use trx.execute() directly for the DDL
             await trx.execute(sql_js_1.sql.raw(ddl));
             // 1b. Log for potential rollback
             await trx
@@ -155,7 +152,13 @@ class SelfEvolution {
                 created_at: new Date(),
             })
                 .execute();
-        });
+        };
+        if (trxOrDb && trxOrDb !== this.db) {
+            await runner(trxOrDb);
+        }
+        else {
+            await this.db.transaction().execute(runner);
+        }
         // 2. Regenerate types
         await this.regenerateTypes();
         console.log(`[SelfEvolution] Schema evolved successfully.`);
@@ -274,7 +277,7 @@ class SelfEvolution {
             return `ALTER TABLE ${addColumnMatch[1]} DROP COLUMN ${addColumnMatch[2]}`;
         }
         // Match patterns like: ALTER TABLE "table_name" DROP [COLUMN] "column_name"
-        const dropColumnMatch = d.match(/ALTER TABLE\s+([^\s]+)\s+DROP\s+(?:COLUMN\s+)?([^\s\(\)]+)/i);
+        const dropColumnMatch = d.match(/ALTER TABLE\s+([^\s]+)\s+DROP\s+(?:COLUMN\s+)?([^\s\(\)]+)\s+([^\s]+)/i);
         if (dropColumnMatch) {
             // Note: Data is lost, but we can restore the structure
             return `ALTER TABLE ${dropColumnMatch[1]} ADD COLUMN ${dropColumnMatch[2]} TEXT`; // Default to TEXT if unknown

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

@@ -17,7 +17,7 @@ export declare class SelfTestRegistry {
     /**
      * Run all registered probes
      */
-    runAllProbes(): Promise<{
+    runAllProbes(trxOrDb?: any): Promise<{
         name: string;
         success: boolean;
         error?: string;

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SelfTestRegistry = void 0;
+const db_utils_js_1 = require("../util/db-utils.js");
 /**
  * SelfTestRegistry allows agents to self-register verification probes
  * that ensure autonomous changes don't violate core logic.
@@ -36,8 +37,8 @@ class SelfTestRegistry {
     /**
      * Run all registered probes
      */
-    async runAllProbes() {
-        const probes = (await this.db
+    async runAllProbes(trxOrDb = this.db) {
+        const probes = (await trxOrDb
             .selectFrom('agent_logic_probes')
             .selectAll()
             .execute());
@@ -47,22 +48,21 @@ class SelfTestRegistry {
             try {
                 let success = false;
                 if (probe.script.startsWith('audit:')) {
-                    success = await this.runAuditAction(probe.script.split(':')[1]);
+                    success = await this.runAuditAction(probe.script.split(':')[1], trxOrDb);
                 }
                 else {
                     // Master Sentinel Pass: Dynamic Probe Evaluation
                     // If not a hardcoded audit, use LLM to interpret the script against DB state
-                    success = await this.dynamicEvaluation(probe);
+                    success = await this.dynamicEvaluation(probe, trxOrDb);
                 }
                 results.push({ name: probe.name, success });
-                await this.db.transaction().execute(async (trx) => {
+                const updateRunner = async (trx) => {
                     // Audit Phase 13: Lock row before updating last_status
-                    await trx
+                    const query = trx
                         .selectFrom('agent_logic_probes')
                         .select('id')
-                        .where('id', '=', probe.id)
-                        .forUpdate()
-                        .executeTakeFirst();
+                        .where('id', '=', probe.id);
+                    await (0, db_utils_js_1.withLock)(query, trx).executeTakeFirst();
                     await trx
                         .updateTable('agent_logic_probes')
                         .set({
@@ -71,7 +71,15 @@ class SelfTestRegistry {
                     })
                         .where('id', '=', probe.id)
                         .execute();
-                });
+                };
+                if (trxOrDb && trxOrDb !== this.db) {
+                    await updateRunner(trxOrDb);
+                }
+                else {
+                    await this.db.transaction().execute(async (trx) => {
+                        await updateRunner(trx);
+                    });
+                }
             }
             catch (e) {
                 results.push({ name: probe.name, success: false, error: String(e) });
@@ -79,7 +87,7 @@ class SelfTestRegistry {
         }
         return results;
     }
-    async runAuditAction(action) {
+    async runAuditAction(action, trxOrDb = this.db) {
         switch (action) {
             case 'check_schema_consistency':
                 const tables = await this.db.introspection.getTables();
@@ -95,7 +103,7 @@ class SelfTestRegistry {
                 return missing.length === 0;
             case 'check_memory_integrity':
                 const memoriesTable = this.config.memoriesTable || 'agent_memories';
-                const invalidMemories = await this.db
+                const invalidMemories = await trxOrDb
                     .selectFrom(memoriesTable)
                     .select('id')
                     .where('embedding', 'is', null)
@@ -104,7 +112,7 @@ class SelfTestRegistry {
             case 'check_session_coherence':
                 const sessionsTable = this.config.sessionsTable || 'agent_sessions';
                 const messagesTable = this.config.messagesTable || 'agent_messages';
-                const emptySessions = await this.db
+                const emptySessions = await trxOrDb
                     .selectFrom(sessionsTable)
                     .leftJoin(messagesTable, `${sessionsTable}.id`, `${messagesTable}.session_id`)
                     .select(`${sessionsTable}.id as sid`)
@@ -115,7 +123,7 @@ class SelfTestRegistry {
                 const knowledgeTable = this.config.knowledgeTable || 'agent_knowledge_base';
                 const actionsTable = this.config.actionsTable || 'agent_actions';
                 const sessionsTbl = this.config.sessionsTable || 'agent_sessions';
-                const orphanedKnowledge = await this.db
+                const orphanedKnowledge = await trxOrDb
                     .selectFrom(knowledgeTable)
                     .where('source_session_id', 'is not', null)
                     .where((eb) => eb.not(eb.exists(eb
@@ -123,7 +131,7 @@ class SelfTestRegistry {
                     .select('id')
                     .whereRef(`${knowledgeTable}.source_session_id`, '=', `${sessionsTbl}.id`))))
                     .execute();
-                const orphanedActions = await this.db
+                const orphanedActions = await trxOrDb
                     .selectFrom(actionsTable)
                     .where((eb) => eb.not(eb.exists(eb
                     .selectFrom(sessionsTbl)
@@ -133,7 +141,7 @@ class SelfTestRegistry {
                 return orphanedKnowledge.length === 0 && orphanedActions.length === 0;
             case 'check_performance_drift':
                 const metricsTbl = this.config.metricsTable || 'agent_metrics';
-                const recentMetrics = (await this.db
+                const recentMetrics = (await trxOrDb
                     .selectFrom(metricsTbl)
                     .select('execution_time')
                     .orderBy('created_at', 'desc')
@@ -142,7 +150,7 @@ class SelfTestRegistry {
                 if (recentMetrics.length < 5)
                     return true;
                 const avgRecent = recentMetrics.reduce((sum, m) => sum + (m.execution_time || 0), 0) / recentMetrics.length;
-                const baselineMetrics = (await this.db
+                const baselineMetrics = (await trxOrDb
                     .selectFrom(metricsTbl)
                     .select('execution_time')
                     .orderBy('created_at', 'desc')
@@ -160,12 +168,12 @@ class SelfTestRegistry {
     /**
      * Interpret custom probe logic by providing the LLM with relevant database snapshots.
      */
-    async dynamicEvaluation(probe) {
+    async dynamicEvaluation(probe, trxOrDb = this.db) {
         const model = this.cortex.llmFast || this.cortex.llm;
         if (!model)
             return true; // Safety fallback if no AI is available
         // Provide a small sample of metrics and actions to allow for semantic reasoning
-        const sampleMetrics = await this.db.selectFrom(this.config.metricsTable || 'agent_metrics').limit(10).execute();
+        const sampleMetrics = await trxOrDb.selectFrom(this.config.metricsTable || 'agent_metrics').limit(10).execute();
         const prompt = `
         You are a Logic Verification Engine for NOORMME.
         TESTRUN: "${probe.name}"

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

@@ -37,30 +37,30 @@ export declare class SovereignMetrics {
         agentId?: string;
         unit?: string;
         metadata?: Record<string, any>;
-    }): Promise<AgentMetric>;
+    }, trxOrDb?: any): Promise<AgentMetric>;
     /**
      * Get average value of a metric over time
      */
-    getAverageMetric(metricName: string): Promise<number>;
+    getAverageMetric(metricName: string, trxOrDb?: any): Promise<number>;
     /**
      * Get comprehensive stats for a metric (min, max, avg, count).
      */
     getMetricStats(metricName: string, options?: {
         agentId?: string;
         sessionId?: string | number;
-    }): Promise<MetricStats>;
+    }, trxOrDb?: any): Promise<MetricStats>;
     /**
      * Get recent metrics for analysis
      */
-    getRecentMetrics(limit?: number): Promise<AgentMetric[]>;
+    getRecentMetrics(limit?: number, trxOrDb?: any): Promise<AgentMetric[]>;
     /**
      * Get metrics filtered by agent ID.
      */
-    getMetricsByAgent(agentId: string, limit?: number): Promise<AgentMetric[]>;
+    getMetricsByAgent(agentId: string, limit?: number, trxOrDb?: any): Promise<AgentMetric[]>;
     /**
      * Get metrics filtered by session ID.
      */
-    getMetricsBySession(sessionId: string | number, limit?: number): Promise<AgentMetric[]>;
+    getMetricsBySession(sessionId: string | number, limit?: number, trxOrDb?: any): Promise<AgentMetric[]>;
     private parseMetric;
 }
 export {};

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

@@ -20,8 +20,8 @@ class SovereignMetrics {
     /**
      * Record a metric point
      */
-    async recordMetric(metricName, metricValue, options = {}) {
-        const metric = (await this.db
+    async recordMetric(metricName, metricValue, options = {}, trxOrDb = this.db) {
+        const metric = (await trxOrDb
             .insertInto(this.metricsTable)
             .values({
             session_id: options.sessionId ?? null,
@@ -39,8 +39,8 @@ class SovereignMetrics {
     /**
      * Get average value of a metric over time
      */
-    async getAverageMetric(metricName) {
-        const result = await this.typedDb
+    async getAverageMetric(metricName, trxOrDb = this.db) {
+        const result = await trxOrDb
             .selectFrom(this.metricsTable)
             .select((eb) => eb.fn.avg('metric_value').as('avgValue'))
             .where('metric_name', '=', metricName)
@@ -50,8 +50,8 @@ class SovereignMetrics {
     /**
      * Get comprehensive stats for a metric (min, max, avg, count).
      */
-    async getMetricStats(metricName, options = {}) {
-        let query = this.typedDb
+    async getMetricStats(metricName, options = {}, trxOrDb = this.db) {
+        let query = trxOrDb
             .selectFrom(this.metricsTable)
             .select((eb) => [
             eb.fn.min('metric_value').as('min'),
@@ -77,8 +77,8 @@ class SovereignMetrics {
     /**
      * Get recent metrics for analysis
      */
-    async getRecentMetrics(limit = 50) {
-        const list = (await this.typedDb
+    async getRecentMetrics(limit = 50, trxOrDb = this.db) {
+        const list = (await trxOrDb
             .selectFrom(this.metricsTable)
             .selectAll()
             .orderBy('created_at', 'desc')
@@ -89,8 +89,8 @@ class SovereignMetrics {
     /**
      * Get metrics filtered by agent ID.
      */
-    async getMetricsByAgent(agentId, limit = 50) {
-        const list = (await this.typedDb
+    async getMetricsByAgent(agentId, limit = 50, trxOrDb = this.db) {
+        const list = (await trxOrDb
             .selectFrom(this.metricsTable)
             .selectAll()
             .where('agent_id', '=', agentId)
@@ -102,8 +102,8 @@ class SovereignMetrics {
     /**
      * Get metrics filtered by session ID.
      */
-    async getMetricsBySession(sessionId, limit = 50) {
-        const list = (await this.typedDb
+    async getMetricsBySession(sessionId, limit = 50, trxOrDb = this.db) {
+        const list = (await trxOrDb
             .selectFrom(this.metricsTable)
             .selectAll()
             .where('session_id', '=', sessionId)

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

@@ -1,28 +1,6 @@
 import type { Kysely } from '../../kysely.js';
 import type { AgenticConfig, AgentPersona } from '../../types/index.js';
 import type { Cortex } from '../Cortex.js';
-interface PersonaTable {
-    id: number | string;
-    name: string;
-    role: string | null;
-    capabilities: string | null;
-    policies: string | null;
-    metadata: string | null;
-    created_at: string | Date;
-    updated_at: string | Date;
-}
-export interface MetricTable {
-    id: number | string;
-    metric_name: string;
-    metric_value: number;
-    unit: string | null;
-    metadata: string | null;
-    created_at: string | Date;
-}
-export interface StrategyDatabase {
-    agent_personas: PersonaTable;
-    agent_metrics: MetricTable;
-}
 export interface PerformanceReport {
     personaId: string | number;
     successRate: number;
@@ -30,14 +8,6 @@ export interface PerformanceReport {
     sampleSize: number;
     recommendation: 'maintain' | 'optimize_efficiency' | 'optimize_accuracy' | 'critical_intervention';
 }
-export interface PersonaMutation {
-    id: string;
-    timestamp: number;
-    type: 'role_update' | 'policy_update' | 'capability_update';
-    previousState: Partial<AgentPersona>;
-    newState: Partial<AgentPersona>;
-    reason: string;
-}
 /**
  * StrategicPlanner proactively suggests mutation to agent personas
  * based on performance trends observed in SovereignMetrics.
@@ -48,40 +18,26 @@ export declare class StrategicPlanner {
     private config;
     private personasTable;
     private metricsTable;
+    private analyst;
+    private engine;
+    private verificator;
     constructor(db: Kysely<any>, cortex: Cortex, config?: AgenticConfig);
-    private get typedDb();
     /**
      * Analyze performance for all personas and apply mutations where necessary.
      */
-    mutateStrategy(): Promise<string[]>;
-    /**
-     * Directly mutate a persona and put it into 'verifying' status.
-     * Performs a pre-flight conflict check and injects distilled lessons.
-     */
-    private applyDirectMutation;
+    mutateStrategy(trxOrDb?: any): Promise<string[]>;
     /**
-     * Check if a persona in verification should be stabilized or rolled back.
-     * Uses dynamic statistical variance and adaptive meta-tuning.
+     * Directly mutate a persona.
      */
-    private verifyEvolution;
+    evolvePersona(persona: AgentPersona, report: PerformanceReport, trxOrDb?: any): Promise<string | null>;
     /**
-     * Analyze recent actions for specific failure patterns.
-     */
-    private analyzeFailurePatterns;
-    /**
-     * Generate a performance report for a specific persona.
-     * Uses dynamic satisfaction thresholds based on global population stats (Phase 6).
-     */
-    analyzePersona(id: string | number): Promise<PerformanceReport>;
-    /**
-     * Evolve a persona directly based on performance.
+     * Revert the last mutation for a persona.
      */
-    evolvePersona(persona: AgentPersona, report: PerformanceReport): Promise<string | null>;
+    rollbackPersona(id: string | number, trxOrDb?: any): Promise<string>;
     /**
-     * Revert the last mutation for a persona.
+     * Analyze a persona's performance report.
      */
-    rollbackPersona(id: string | number): Promise<string>;
+    analyzePersona(id: string | number, trxOrDb?: any): Promise<PerformanceReport>;
     private sanitizeRole;
     private parsePersona;
 }
-export {};