noormme 1.2.3 → 1.2.5

package/dist/esm/agentic/PersonaManager.js

@@ -1,4 +1,5 @@
 /// <reference types="./PersonaManager.d.ts" />
+import { withLock } from './util/db-utils.js';
 /**
  * PersonaManager handles persistent agent identities that bridge multiple sessions.
  */
@@ -17,17 +18,14 @@ export class PersonaManager {
     /**
      * Create or update a persona
      */
-    async upsertPersona(name, options = {}) {
-        return await this.db.transaction().execute(async (trx) => {
-            let query = trx
+    async upsertPersona(name, options = {}, trxOrDb = this.db) {
+        const runner = async (trx) => {
+            const baseQuery = 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') {
-                query = query.forUpdate();
-            }
-            const existing = await query.executeTakeFirst();
+            const existing = await withLock(baseQuery, trx)
+                .executeTakeFirst();
             const values = {
                 name,
                 role: options.role || null,
@@ -56,13 +54,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 +76,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 +86,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

@@ -1,4 +1,5 @@
 /// <reference types="./PolicyEnforcer.d.ts" />
+import { withLock } from './util/db-utils.js';
 /**
  * PolicyEnforcer stores and validates agent autonomous guardrails,
  * such as budgets, safety constraints, and privacy rules.
@@ -21,17 +22,14 @@ 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) => {
-            let query = trx
+    async definePolicy(name, type, definition, isEnabled = true, trxOrDb = this.db) {
+        const runner = async (trx) => {
+            const 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') {
-                query = query.forUpdate();
-            }
-            const existing = await query.executeTakeFirst();
+            const existing = await withLock(query, trx)
+                .executeTakeFirst();
             if (existing) {
                 const updated = await trx
                     .updateTable(this.policiesTable)
@@ -59,17 +57,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 +78,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 +109,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 +137,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 +149,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 +160,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 +185,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 +215,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/ResourceMonitor.js

@@ -1,4 +1,5 @@
 /// <reference types="./ResourceMonitor.d.ts" />
+import { sql } from '../raw-builder/sql.js';
 /**
  * ResourceMonitor tracks token usage and costs across sessions.
  */
@@ -98,7 +99,7 @@ export class ResourceMonitor {
             .select([
             'model_name',
             (eb) => eb.fn
-                .sum(eb('input_tokens', '+', 'output_tokens'))
+                .sum(sql `input_tokens + output_tokens`)
                 .as('totalTokens'),
             (eb) => eb.fn.sum('cost').as('totalCost'),
         ])

package/dist/esm/agentic/SessionManager.js

@@ -1,4 +1,5 @@
 /// <reference types="./SessionManager.d.ts" />
+import { withLock } from './util/db-utils.js';
 /**
  * SessionManager handles the lifecycle of agentic sessions, including
  * message history, goal tracking, and memory persistence.
@@ -132,12 +133,12 @@ export class SessionManager {
     async upsertGoal(sessionId, description, options = {}) {
         const { status = 'pending', priority = 0, parentId, metadata } = options;
         return await this.db.transaction().execute(async (trx) => {
-            const existing = await trx
+            const query = trx
                 .selectFrom(this.goalsTable)
                 .selectAll()
                 .where('session_id', '=', sessionId)
-                .where('description', '=', description)
-                .forUpdate() // Audit Phase 13: Atomic goal lock
+                .where('description', '=', description);
+            const existing = await withLock(query, trx) // Audit Phase 13: Atomic goal lock
                 .executeTakeFirst();
             if (existing) {
                 const updated = await trx
@@ -208,11 +209,11 @@ export class SessionManager {
         // We avoid the Read-Modify-Write race condition by letting the DB handle the merge
         // or by using a strict transaction if the DB doesn't support JSON patching natively.
         const updated = await this.db.transaction().execute(async (trx) => {
-            const message = await trx
+            const query = trx
                 .selectFrom(this.messagesTable)
                 .select('metadata')
-                .where('id', '=', messageId)
-                .forUpdate() // Lock the row for the duration of the transaction
+                .where('id', '=', messageId);
+            const message = await withLock(query, trx) // Lock the row for the duration of the transaction
                 .executeTakeFirstOrThrow();
             const metadata = typeof message.metadata === 'string'
                 ? JSON.parse(message.metadata)

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

@@ -17,19 +17,19 @@ export declare class AblationEngine {
     /**
      * 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

@@ -1,4 +1,5 @@
 /// <reference types="./AblationEngine.d.ts" />
+import { withLock } from '../util/db-utils.js';
 /**
  * AblationEngine identifies and removes unused or redundant data
  * to keep the agent's context window and database lean.
@@ -24,13 +25,13 @@ export class AblationEngine {
     /**
      * 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 +42,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 withLock(query, trx).execute();
             if (knowledgeToPrune.length > 0) {
                 const candidates = knowledgeToPrune.map((k) => this.cortex.knowledge['parseKnowledge'](k));
                 const idsToDelete = [];
@@ -78,16 +78,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 +121,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 withLock(query, trx).executeTakeFirst());
             if (!item)
                 return false;
             const metadata = typeof item.metadata === 'string'
@@ -138,7 +149,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 +164,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 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

@@ -1,4 +1,5 @@
 /// <reference types="./ActionRefiner.d.ts" />
+import { withLock } from '../util/db-utils.js';
 /**
  * ActionRefiner analyzes the ActionJournal to find patterns in failures
  * and suggests new CognitiveRules to improve agent performance.
@@ -17,12 +18,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 +42,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 +61,24 @@ 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
+            const 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 existing = await withLock(query, trx).executeTakeFirst();
             if (!existing) {
                 console.log(`[ActionRefiner] Proposing reflection rule for tool: ${toolName}`);
                 await this.cortex.rules.defineRule('agent_actions', 'insert', 'audit', {
@@ -88,16 +88,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/ConflictResolver.js

@@ -1,5 +1,6 @@
 /// <reference types="./ConflictResolver.d.ts" />
 import { calculateSimilarity } from '../../util/similarity.js';
+import { withLock } from '../util/db-utils.js';
 /**
  * ConflictResolver identifies and resolves logical inconsistencies
  * in the agent's cognitive rules and behavior policies.
@@ -83,14 +84,14 @@ export class ConflictResolver {
     async resolveConflict(tableName, operation) {
         console.log(`[ConflictResolver] Resolving conflict for ${tableName}:${operation}`);
         return await this.db.transaction().execute(async (trx) => {
-            const rules = (await trx
+            const query = trx
                 .selectFrom(this.rulesTable)
                 .selectAll()
                 .where('table_name', '=', tableName)
                 .where('operation', '=', operation)
                 .where('is_enabled', '=', true)
-                .orderBy('created_at', 'desc')
-                .forUpdate() // Audit Phase 10: Atomic resolution lock
+                .orderBy('created_at', 'desc');
+            const rules = (await withLock(query, trx) // Audit Phase 10: Atomic resolution lock
                 .execute());
             if (rules.length <= 1)
                 return;

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[];
     }>;