noormme 1.2.3 → 1.2.5

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

@@ -1,5 +1,9 @@
 /// <reference types="./KnowledgeDistiller.d.ts" />
-import { calculateSimilarity } from '../../util/similarity.js';
+import { FactDistiller } from './distillation/FactDistiller.js';
+import { ConflictChallenger } from './distillation/ConflictChallenger.js';
+import { RelationshipArchitect } from './distillation/RelationshipArchitect.js';
+import { KnowledgeConsolidator } from './distillation/KnowledgeConsolidator.js';
+import { withLock } from '../util/db-utils.js';
 /**
  * KnowledgeDistiller extracts structured "KnowledgeItems" from longtail history,
  * allowing agents to build a permanent, queryable knowledge base.
@@ -10,198 +14,102 @@ export class KnowledgeDistiller {
     knowledgeTable;
     linksTable;
     bloomFilter = new Set();
-    constructor(db, // accepting any Kysely but casting internally for our specific tables
-    config = {}) {
+    distiller;
+    challenger;
+    architect;
+    consolidator;
+    constructor(db, config = {}) {
         this.db = db;
         this.config = config;
         this.knowledgeTable = config.knowledgeTable || 'agent_knowledge_base';
         this.linksTable = 'agent_knowledge_links';
-    }
-    /**
-     * typedDb helper to cast the generic DB to our specific schema
-     */
-    get typedDb() {
-        return this.db;
+        this.distiller = new FactDistiller();
+        this.challenger = new ConflictChallenger();
+        this.architect = new RelationshipArchitect();
+        this.consolidator = new KnowledgeConsolidator();
     }
     /**
      * Add or update a knowledge item with robust merging and transaction support.
      */
     async distill(entity, fact, confidence, sourceSessionId, tags = [], metadata = {}, source = 'assistant') {
-        // Pass 6: Bloom filter Heuristic
-        // Lightweight de-duplication for ultra-scale throughput.
-        // If the fact matches a very recent pattern, skip expensive DB checks.
+        // Production Hardening: 32-bit Rolling Bloom Filter
         const factHash = this.bloomHash(`${entity}:${fact}`);
         if (this.bloomFilter.has(factHash)) {
-            // Likely a duplicate, but we'll do a quick check if it's "verified" to avoid re-distilling
-            console.log(`[KnowledgeDistiller] Bloom filter hit for ${entity}. Skipping redundant distillation.`);
             const quickMatch = await this.db
                 .selectFrom(this.knowledgeTable)
                 .select(['id', 'status'])
                 .where('entity', '=', entity)
                 .where('fact', '=', fact)
                 .executeTakeFirst();
-            if (quickMatch &&
-                quickMatch.status === 'verified' &&
-                source !== 'user') {
-                return (await this.getKnowledgeByEntity(entity)).find((k) => k.fact === fact);
+            if (quickMatch && quickMatch.status === 'verified' && source !== 'user') {
+                const results = await this.getKnowledgeByEntity(entity);
+                const match = results.find(k => k.fact === fact);
+                if (match)
+                    return match;
             }
         }
         this.bloomFilter.add(factHash);
-        if (this.bloomFilter.size > 1000)
-            this.bloomFilter.clear(); // Simple rolling window
+        if (this.bloomFilter.size > 2000)
+            this.bloomFilter.clear();
         return await this.db.transaction().execute(async (trx) => {
-            // Check for exact match first
-            const existing = await trx
-                .selectFrom(this.knowledgeTable)
-                .selectAll()
-                .where('entity', '=', entity)
-                .where('fact', '=', fact)
-                .executeTakeFirst();
-            if (existing) {
-                // Merge tags
-                const existingTags = existing.tags
-                    ? JSON.parse(existing.tags)
-                    : [];
-                const mergedTags = Array.from(new Set([...existingTags, ...tags]));
-                // Merge metadata
-                const existingMeta = existing.metadata
-                    ? JSON.parse(existing.metadata)
-                    : {};
-                // Hallucination Prevention: Tracking contributing sessions
-                const sessions = new Set(existingMeta.sessions || []);
-                if (sourceSessionId)
-                    sessions.add(sourceSessionId);
-                const mergedMeta = {
-                    ...existingMeta,
-                    ...metadata,
-                    sessions: Array.from(sessions),
-                    session_count: sessions.size,
-                };
-                // Source weighting: User verification boosts confidence faster
-                const boost = source === 'user' ? 0.2 : 0.05;
-                const finalConfidence = Math.min(1.0, existing.confidence + boost);
-                // Status Lifecycle: Auto-verify if source is user or if session count >= 3
-                let finalStatus = existing.status || 'proposed';
-                if (source === 'user' || mergedMeta.session_count >= 3) {
-                    finalStatus = 'verified';
-                }
-                const updated = await trx
-                    .updateTable(this.knowledgeTable)
-                    .set({
-                    confidence: finalConfidence,
-                    status: finalStatus,
-                    tags: JSON.stringify(mergedTags),
-                    metadata: JSON.stringify(mergedMeta),
-                    updated_at: new Date(),
-                    source_session_id: sourceSessionId ?? existing.source_session_id,
-                })
-                    .where('id', '=', existing.id)
-                    .returningAll()
-                    .executeTakeFirstOrThrow();
-                return this.parseKnowledge(updated);
-            }
-            // Conflict Detection: Check if a similar entity has a conflicting fact
-            // Audit Phase 11: Explicit transaction propagation
+            // 1. Check for Exact Match & Merge
+            let result = await this.distiller.distillExact(trx, this.knowledgeTable, entity, fact, confidence, sourceSessionId, tags, metadata, source);
+            if (result)
+                return this.parseKnowledge(result);
+            // 2. Conflict Detection (Contradiction Challenge)
             await this.challengeKnowledge(entity, fact, confidence, trx);
-            // Create new
-            const initialMeta = {
-                ...metadata,
-                source,
-                sessions: sourceSessionId ? [sourceSessionId] : [],
-                session_count: sourceSessionId ? 1 : 0,
-            };
-            const created = await trx
-                .insertInto(this.knowledgeTable)
-                .values({
-                entity,
-                fact,
-                confidence: source === 'user' ? Math.max(confidence, 0.8) : confidence,
-                status: source === 'user' ? 'verified' : 'proposed',
-                source_session_id: sourceSessionId ?? null,
-                tags: JSON.stringify(tags),
-                metadata: JSON.stringify(initialMeta),
-                created_at: new Date(),
-                updated_at: new Date(),
-            })
-                .returningAll()
-                .executeTakeFirstOrThrow();
+            // 3. Create New Item
+            const created = await this.distiller.createInitial(trx, this.knowledgeTable, entity, fact, confidence, sourceSessionId, tags, metadata, source);
             const parsed = this.parseKnowledge(created);
-            // Semantic Auto-Linking: Try to link to related entities
-            await this.autoLinkKnowledge(parsed, trx);
+            // 4. Semantic Auto-Linking
+            await this.architect.autoLink(parsed, trx, this.knowledgeTable, this.linksTable);
             return parsed;
         });
     }
+    /**
+     * Manually challenge an existing fact with competing information.
+     */
+    async challengeKnowledge(entity, fact, confidence, trxOrDb = this.db) {
+        await this.challenger.challenge(trxOrDb, this.knowledgeTable, entity, fact, confidence, (i) => this.parseKnowledge(i));
+    }
     /**
      * Verify and reinforce existing knowledge.
-     * Increases confidence if the fact matches.
      */
     async verifyKnowledge(id, reinforcement = 0.1) {
-        const existing = await this.typedDb
-            .selectFrom(this.knowledgeTable)
-            .selectAll()
-            .where('id', '=', id)
-            .executeTakeFirst();
-        if (!existing)
-            return null;
-        const metadata = typeof existing.metadata === 'string'
-            ? JSON.parse(existing.metadata)
-            : existing.metadata || {};
-        // Hallucination Guard: Cap confidence for non-user sources until cross-session verification
-        let maxConfidence = 1.0;
-        if (metadata.source !== 'user' && (metadata.session_count || 0) < 3) {
-            maxConfidence = 0.85;
-            console.log(`[KnowledgeDistiller] Confidence capped at 0.85 for item ${id} (Need 3+ sessions for total trust)`);
-        }
-        const newConfidence = Math.min(maxConfidence, existing.confidence + reinforcement);
-        // Promotion Lifecycle
-        let newStatus = existing.status || 'proposed';
-        if (newConfidence >= 0.9 || metadata.session_count >= 3) {
-            newStatus = 'verified';
-        }
-        const updated = await this.db
-            .updateTable(this.knowledgeTable)
-            .set({
-            confidence: newConfidence,
-            status: newStatus,
-            updated_at: new Date(),
-        })
-            .where('id', '=', id)
-            .returningAll()
-            .executeTakeFirstOrThrow();
-        return this.parseKnowledge(updated);
+        const updated = await this.distiller.verify(this.db, this.knowledgeTable, id, reinforcement);
+        return updated ? this.parseKnowledge(updated) : null;
     }
     /**
      * Search knowledge by entity with optional tag filtering.
-     * Records a "hit" for each retrieved item to track utility.
      */
     async getKnowledgeByEntity(entity, filterTags) {
-        let query = this.db
+        const items = await this.db
             .selectFrom(this.knowledgeTable)
             .selectAll()
             .where('entity', '=', entity)
-            .orderBy('confidence', 'desc');
-        const items = (await query.execute());
+            .orderBy('confidence', 'desc')
+            .execute();
         const parsed = items.map((i) => this.parseKnowledge(i));
         let filtered = parsed;
         if (filterTags && filterTags.length > 0) {
             filtered = parsed.filter((item) => item.tags?.some((tag) => filterTags.includes(tag)));
         }
-        // Record hits asynchronously
+        // Record hits asynchronously to hotspot optimization layer
         for (const item of filtered) {
-            this.recordHit(item.id).catch((err) => console.error(`[KnowledgeDistiller] Failed to record hit for ${item.id}:`, err));
+            this.recordHit(item.id).catch(() => { });
         }
         return filtered;
     }
     /**
-     * Record a retrieval hit for a knowledge item.
+     * Record a retrieval hit for a knowledge item and emit hotspot telemetry.
      */
     async recordHit(id) {
         await this.db.transaction().execute(async (trx) => {
-            const existing = await trx
+            const query = trx
                 .selectFrom(this.knowledgeTable)
-                .selectAll()
-                .where('id', '=', id)
-                .forUpdate() // Audit Phase 11: Atomic hit record
+                .select(['id', 'entity', 'metadata'])
+                .where('id', '=', id);
+            const existing = await withLock(query, trx)
                 .executeTakeFirst();
             if (!existing)
                 return;
@@ -218,7 +126,7 @@ export class KnowledgeDistiller {
             })
                 .where('id', '=', id)
                 .execute();
-            // Production Hardening: Emit a metric event for this hit to enable efficient hotspot detection
+            // Production Hardening: Real-time hotspots in metrics layer
             await trx
                 .insertInto(this.config.metricsTable || 'agent_metrics')
                 .values({
@@ -229,156 +137,11 @@ export class KnowledgeDistiller {
                 .execute();
         });
     }
-    /**
-     * Calculate the "Fitness" of a memory item.
-     * Score = (Confidence * 0.4) + (SignalToNoise * 0.4) + (SourceMultiplier * 0.2)
-     */
-    calculateFitness(item) {
-        const metadata = item.metadata || {};
-        const hitCount = metadata.hit_count || 0;
-        const createdAt = new Date(item.createdAt).getTime();
-        const ageInDays = Math.max(1, (Date.now() - createdAt) / (1000 * 60 * 60 * 24));
-        // Signal-to-Noise: Hits per day
-        const stn = Math.min(1.0, hitCount / ageInDays);
-        // Source Multiplier: User verified facts get 1.0, Assistant-generated 0.7
-        const sourceMult = metadata.source === 'user' ? 1.0 : 0.7;
-        return item.confidence * 0.4 + stn * 0.4 + sourceMult * 0.2;
-    }
-    /**
-     * Challenge existing knowledge with new evidence.
-     * If confidence of new fact is high and contradicts existing ones (same entity, different fact),
-     * we degrade the confidence of the old facts.
-     */
-    async challengeKnowledge(entity, competingFact, confidence, trxOrDb = this.db) {
-        // Audit Phase 11: Semantic sanitization of competing fact
-        const safeFact = competingFact.slice(0, 500).replace(/[\u0000-\u001F\u007F-\u009F]/g, '').replace(/<\|.*?\|>/g, '');
-        const query = trxOrDb
-            .selectFrom(this.knowledgeTable)
-            .selectAll()
-            .where('entity', '=', entity)
-            .orderBy('confidence', 'desc');
-        const existingItems = await query.execute();
-        for (const item of existingItems) {
-            // Parse for logic
-            const parsedItem = this.parseKnowledge(item);
-            if (parsedItem.fact === competingFact)
-                continue;
-            // Deep Hardening: Conflict detection using semantic similarity check
-            // If the entity is the same but the fact is different, we assess conflict
-            if (confidence > 0.8) {
-                let newMeta = { ...parsedItem.metadata };
-                let penalty = 0.2;
-                let newStatus = parsedItem.status;
-                if (parsedItem.confidence > 0.7) {
-                    newStatus = 'disputed';
-                    newMeta = {
-                        ...newMeta,
-                        status_reason: `Contradicted by: ${safeFact}`,
-                    };
-                    penalty = 0.1;
-                }
-                else {
-                    newStatus = 'deprecated';
-                    newMeta = {
-                        ...newMeta,
-                        status_reason: `Superseded by: ${safeFact}`,
-                    };
-                    penalty = 0.4;
-                }
-                const newConfidence = Math.max(0, parsedItem.confidence - penalty);
-                await trxOrDb
-                    .updateTable(this.knowledgeTable)
-                    .set({
-                    confidence: newConfidence,
-                    status: newStatus,
-                    metadata: JSON.stringify(newMeta),
-                    updated_at: new Date(),
-                })
-                    .where('id', '=', parsedItem.id)
-                    .execute();
-            }
-        }
-    }
-    /**
-     * Automatic Semantic Linking
-     * Scans for entity mentions in facts and creates links.
-     * Production Hardening: Uses batched cross-similarity and NER-style tokenization.
-     */
-    async autoLinkKnowledge(item, trx) {
-        // 1. Structural/Syntactic Extraction (NER-style tokenization)
-        // Extract capitalized phrases (potential entities), quoted strings, and CamelCase identifiers
-        const tokens = item.fact.match(/([A-Z][a-z]+(?:\s[A-Z][a-z]+)*)|("[^"]+")|([a-z]+[A-Z][a-z]+)/g) || [];
-        const potentialEntities = Array.from(new Set(tokens.map((t) => t.replace(/"/g, '').trim()))).filter((t) => t.length > 2 && t !== item.entity);
-        if (potentialEntities.length > 0) {
-            const matches = await trx
-                .selectFrom(this.knowledgeTable)
-                .select(['id', 'entity'])
-                .where('entity', 'in', potentialEntities)
-                .execute();
-            for (const match of matches) {
-                await this.linkKnowledge(item.id, match.id, 'mentions', { auto: true, source: 'structural_extraction' }, trx);
-            }
-        }
-        // 2. Semantic Similarity Pass (Vector/Cosine Approximation)
-        // We limit the search to items with high intrinsic fitness to avoid linking to "noise"
-        const candidates = await trx
-            .selectFrom(this.knowledgeTable)
-            .selectAll()
-            .where('id', '!=', item.id)
-            .where('confidence', '>', 0.4) // Only link to semi-reliable knowledge
-            .orderBy('updated_at', 'desc')
-            .limit(50) // Increased limit for better coverage
-            .execute();
-        // Batch similarity processing to reduce link churn
-        const linksToCreate = [];
-        for (const other of candidates) {
-            const parsedOther = this.parseKnowledge(other);
-            const sim = calculateSimilarity(item.fact, parsedOther.fact);
-            // High similarity threshold for auto-linking to prevent a "everything linked to everything" graph
-            if (sim > 0.75) {
-                linksToCreate.push({ targetId: parsedOther.id, sim });
-            }
-        }
-        // Apply links in batch
-        for (const link of linksToCreate) {
-            await this.linkKnowledge(item.id, link.targetId, 'semantically_related', { similarity: link.sim, version: '2.0' }, trx);
-        }
-    }
     /**
      * Link two knowledge items together with a relationship.
-     * Transaction-aware version.
      */
     async linkKnowledge(sourceId, targetId, relationship, metadata, trxOrDb = this.db) {
-        if (sourceId === targetId)
-            return;
-        const existing = await trxOrDb
-            .selectFrom(this.linksTable)
-            .select('id')
-            .where('source_id', '=', sourceId)
-            .where('target_id', '=', targetId)
-            .where('relationship', '=', relationship)
-            .executeTakeFirst();
-        if (existing) {
-            await trxOrDb
-                .updateTable(this.linksTable)
-                .set({
-                metadata: metadata ? JSON.stringify(metadata) : null,
-            })
-                .where('id', '=', existing.id)
-                .execute();
-        }
-        else {
-            await trxOrDb
-                .insertInto(this.linksTable)
-                .values({
-                source_id: sourceId,
-                target_id: targetId,
-                relationship,
-                metadata: metadata ? JSON.stringify(metadata) : null,
-                created_at: new Date(),
-            })
-                .execute();
-        }
+        return this.architect.link(sourceId, targetId, relationship, metadata, trxOrDb, this.linksTable);
     }
     /**
      * Get the "Knowledge Graph" for a specific entity (1-hop neighborhood).
@@ -414,77 +177,34 @@ export class KnowledgeDistiller {
             .deleteFrom(this.knowledgeTable)
             .where('confidence', '<', threshold)
             .executeTakeFirst();
-        return Number(result.numDeletedRows);
+        return Number(result.numDeletedRows || 0);
     }
     /**
      * Consolidate knowledge by merging similar facts for the same entity.
-     * Production Hardening: Iterative bucketed approach to avoid recursive stack issues.
      */
     async consolidateKnowledge() {
-        let totalMerged = 0;
-        // Find entities with multiple facts (Paginated to handle scale)
-        const candidates = await this.db
-            .selectFrom(this.knowledgeTable)
-            .select('entity')
-            .groupBy('entity')
-            .having((eb) => eb.fn.count('id'), '>', 1)
-            .limit(500) // Audit Phase 11: Chunked search
-            .execute();
-        for (const cand of candidates) {
-            const entity = cand.entity;
-            const items = await this.getKnowledgeByEntity(entity);
-            // Iterative merging inside the entity bucket (Paginated check)
-            const mergedIds = new Set();
-            const iterLimit = Math.min(items.length, 100);
-            for (let i = 0; i < iterLimit; i++) {
-                if (mergedIds.has(items[i].id))
-                    continue;
-                for (let j = i + 1; j < iterLimit; j++) {
-                    if (mergedIds.has(items[j].id))
-                        continue;
-                    const sim = calculateSimilarity(items[i].fact, items[j].fact);
-                    if (sim > 0.85) {
-                        await this.mergeItems(items[i], items[j]);
-                        mergedIds.add(items[j].id);
-                        totalMerged++;
-                    }
-                }
-            }
-        }
-        return totalMerged;
+        return this.consolidator.consolidate(this.db, this.knowledgeTable, (e) => this.getKnowledgeByEntity(e));
     }
-    async mergeItems(primary, secondary) {
-        const mergedMeta = {
-            ...secondary.metadata,
-            ...primary.metadata,
-            consolidated_from: secondary.id,
-            consolidated_at: new Date().toISOString(),
-        };
-        const mergedTags = Array.from(new Set([...(primary.tags || []), ...(secondary.tags || [])]));
-        await this.db.transaction().execute(async (trx) => {
-            // Update primary
-            await trx
-                .updateTable(this.knowledgeTable)
-                .set({
-                confidence: Math.max(primary.confidence, secondary.confidence),
-                metadata: JSON.stringify(mergedMeta),
-                tags: JSON.stringify(mergedTags),
-                updated_at: new Date(),
-            })
-                .where('id', '=', primary.id)
-                .execute();
-            // Delete secondary
-            await trx
-                .deleteFrom(this.knowledgeTable)
-                .where('id', '=', secondary.id)
-                .execute();
-        });
+    /**
+     * Calculate the "Fitness" of a knowledge item.
+     * Score = (Confidence * 0.4) + (SignalToNoise * 0.4) + (SourceMultiplier * 0.2)
+     */
+    calculateFitness(item) {
+        const metadata = item.metadata || {};
+        const hitCount = metadata.hit_count || 0;
+        const createdAt = new Date(item.createdAt).getTime();
+        const ageInDays = Math.max(1, (Date.now() - createdAt) / (1000 * 60 * 60 * 24));
+        // Signal-to-Noise: Hits per day
+        const stn = Math.min(1.0, hitCount / ageInDays);
+        // Source Multiplier: User verified facts get 1.0, Assistant-generated 0.7
+        const sourceMult = metadata.source === 'user' ? 1.0 : 0.7;
+        return item.confidence * 0.4 + stn * 0.4 + sourceMult * 0.2;
     }
     bloomHash(str) {
         let hash = 0;
         for (let i = 0; i < str.length; i++) {
             hash = (hash << 5) - hash + str.charCodeAt(i);
-            hash |= 0; // Format to 32bit int
+            hash |= 0;
         }
         return hash;
     }
@@ -497,9 +217,7 @@ export class KnowledgeDistiller {
             status: item.status || 'proposed',
             sourceSessionId: item.source_session_id,
             tags: typeof item.tags === 'string' ? JSON.parse(item.tags) : item.tags || [],
-            metadata: typeof item.metadata === 'string'
-                ? JSON.parse(item.metadata)
-                : item.metadata || {},
+            metadata: typeof item.metadata === 'string' ? JSON.parse(item.metadata) : item.metadata || {},
             createdAt: new Date(item.created_at),
             updatedAt: new Date(item.updated_at),
         };

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

@@ -16,7 +16,7 @@ export declare class QuotaManager {
     /**
      * Check if a quota is violated for a given target.
      */
-    checkQuota(targetType: 'persona' | 'swarm' | 'global', targetId?: string | null): Promise<{
+    checkQuota(targetType: 'persona' | 'swarm' | 'global', targetId?: string | null, trxOrDb?: any): Promise<{
         allowed: boolean;
         reason?: string;
     }>;

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

@@ -21,14 +21,14 @@ export class QuotaManager {
     /**
      * Check if a quota is violated for a given target.
      */
-    async checkQuota(targetType, targetId = null) {
-        const quotas = await this.getActiveQuotas(targetType, targetId);
+    async checkQuota(targetType, targetId = null, trxOrDb = this.db) {
+        const quotas = await this.getActiveQuotas(targetType, targetId, trxOrDb);
         for (const quota of quotas) {
-            const usage = await this.getCurrentUsage(quota);
+            const usage = await this.getCurrentUsage(quota, trxOrDb);
             // Currency Conversion Logic: Convert usage to target currency if specified
             let normalizedUsage = usage;
             if (quota.metric === 'cost' && quota.metadata?.currency && quota.metadata.currency !== 'USD') {
-                const rate = await this.getExchangeRate(quota.metadata.currency);
+                const rate = await this.getExchangeRate(quota.metadata.currency, trxOrDb);
                 normalizedUsage = usage * rate;
             }
             if (normalizedUsage >= quota.limit) {
@@ -46,10 +46,10 @@ export class QuotaManager {
     /**
      * Fetches active quotas for a given target.
      */
-    async getActiveQuotas(targetType, targetId) {
+    async getActiveQuotas(targetType, targetId, trxOrDb = this.db) {
         const quotas = [];
         // 1. Fetch from PolicyEnforcer (Global & Type-specific)
-        const policies = await this.cortex.policies.getActivePolicies();
+        const policies = await this.cortex.policies.getActivePolicies(trxOrDb);
         for (const policy of policies) {
             if (policy.type === 'budget' &&
                 (policy.definition.targetType === targetType ||
@@ -70,7 +70,7 @@ export class QuotaManager {
         }
         // 2. Fetch from Persona metadata (Specific override)
         if (targetType === 'persona' && targetId) {
-            const persona = await this.db
+            const persona = await trxOrDb
                 .selectFrom(this.config.personasTable || 'agent_personas')
                 .select('metadata')
                 .where('id', '=', targetId)
@@ -89,10 +89,10 @@ export class QuotaManager {
     /**
      * Calculates current usage for a specific quota window.
      */
-    async getCurrentUsage(quota) {
+    async getCurrentUsage(quota, trxOrDb = this.db) {
         const windowMs = this.getPeriodInMs(quota.period);
         const startTime = new Date(Date.now() - windowMs);
-        let query = this.db
+        let query = trxOrDb
             .selectFrom(this.resourcesTable)
             .where('created_at', '>', startTime);
         if (quota.targetType === 'persona' && quota.targetId) {
@@ -121,14 +121,14 @@ export class QuotaManager {
      * Resolves exchange rate via persistent metric store or live update.
      * Implements a true Oracle pattern for resource normalization.
      */
-    async getExchangeRate(currency) {
+    async getExchangeRate(currency, trxOrDb = this.db) {
         // 1. Check in-memory cache
         const cached = this.rateCache.get(currency);
         if (cached && Date.now() - cached.timestamp < this.CACHE_TTL) {
             return cached.rate;
         }
         // 2. Check persistent metric store
-        const record = await this.db
+        const record = await trxOrDb
             .selectFrom(this.metricsTable)
             .select(['metric_value', 'created_at'])
             .where('metric_name', '=', `exchange_rate_${currency}`)

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

@@ -15,21 +15,21 @@ export declare class RecursiveReasoner {
     /**
      * Find goals matching a pattern across all sessions
      */
-    analyzeGlobalProgress(pattern: string): Promise<AgentGoal[]>;
+    analyzeGlobalProgress(pattern: string, trxOrDb?: any): Promise<AgentGoal[]>;
     /**
      * Synthesize high-level lessons and cluster similar ones using Token-Weighted significance.
      * Pass 5: High-Throughput Semantic Analysis.
      */
-    synthesizeLessons(): Promise<Record<string, string[]>>;
+    synthesizeLessons(trxOrDb?: any): Promise<Record<string, string[]>>;
     /**
      * Pass 6: Goal Cross-Pollination
      * Distill successful persona mutations into global systemic goals.
      */
-    crossPollinateGoals(): Promise<number>;
+    crossPollinateGoals(trxOrDb?: any): Promise<number>;
     /**
      * Detect contradictions in goals (e.g., opposing objectives).
      */
-    detectContradictions(): Promise<string[]>;
+    detectContradictions(trxOrDb?: any): Promise<string[]>;
     /**
      * Register a new conflict pair (e.g. ['buy', 'sell'])
      */