noormme 1.2.0 → 1.2.2

package/dist/cjs/agentic/PolicyEnforcer.js

@@ -10,6 +10,7 @@ class PolicyEnforcer {
     config;
     policiesTable;
     metricsTable;
+    metricCache = new Map();
     constructor(db, config = {}) {
         this.db = db;
         this.config = config;
@@ -24,11 +25,15 @@ class PolicyEnforcer {
      */
     async definePolicy(name, type, definition, isEnabled = true) {
         return await this.db.transaction().execute(async (trx) => {
-            const existing = await trx
+            let query = trx
                 .selectFrom(this.policiesTable)
                 .select('id')
-                .where('name', '=', name)
-                .executeTakeFirst();
+                .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();
             if (existing) {
                 const updated = await trx
                     .updateTable(this.policiesTable)
@@ -62,7 +67,19 @@ class PolicyEnforcer {
      * Comprehensive policy evaluation against a context value.
      * Supports thresholds, regex patterns, and cumulative budgets.
      */
-    async checkPolicy(name, value) {
+    /**
+     * Comprehensive policy evaluation against a context value.
+     * Supports thresholds, regex patterns, and cumulative budgets.
+     */
+    async checkPolicy(name, value, visited = new Set()) {
+        // Audit Pass 6: Re-entrancy / Circular Dependency Detection
+        if (visited.has(name)) {
+            return {
+                allowed: false,
+                reason: `Circular policy dependency detected: ${Array.from(visited).join(' -> ')} -> ${name}`,
+            };
+        }
+        visited.add(name);
         const policy = await this.typedDb
             .selectFrom(this.policiesTable)
             .selectAll()
@@ -89,18 +106,33 @@ class PolicyEnforcer {
         }
         // 2. Pattern Check (String/Regex)
         if (typeof value === 'string' && def.pattern) {
-            const regex = new RegExp(def.pattern, 'i');
-            if (def.mustMatch && !regex.test(value)) {
-                return {
-                    allowed: false,
-                    reason: `Value does not match required pattern for policy '${name}'`,
-                };
+            // PRODUCTION HARDENING: ReDoS Prevention
+            // Sanitize regex: check for dangerous nested quantifiers and length
+            if (def.pattern.length > 500) {
+                return { allowed: false, reason: `Policy '${name}' regex pattern too long (potential ReDoS risk)` };
             }
-            if (!def.mustMatch && regex.test(value)) {
-                return {
-                    allowed: false,
-                    reason: `Value contains forbidden pattern for policy '${name}'`,
-                };
+            const dangerousPatterns = /(\*|\+)\1|\(\.\*\)\*/;
+            if (dangerousPatterns.test(def.pattern)) {
+                return { allowed: false, reason: `Policy '${name}' contains potentially dangerous ReDoS pattern` };
+            }
+            const flags = def.flags || 'i';
+            try {
+                const regex = new RegExp(def.pattern, flags);
+                if (def.mustMatch && !regex.test(value)) {
+                    return {
+                        allowed: false,
+                        reason: `Value does not match required pattern for policy '${name}'`,
+                    };
+                }
+                if (!def.mustMatch && regex.test(value)) {
+                    return {
+                        allowed: false,
+                        reason: `Value contains forbidden pattern for policy '${name}'`,
+                    };
+                }
+            }
+            catch (e) {
+                return { allowed: false, reason: `Invalid regex in policy '${name}': ${String(e)}` };
             }
         }
         // 3. Budget Check (Cumulative)
@@ -115,6 +147,16 @@ class PolicyEnforcer {
                 };
             }
         }
+        // 4. Composite Policy Check: Recursive evaluation of dependencies
+        // 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));
+                if (!result.allowed) {
+                    return { allowed: false, reason: `Composite block: ${name} -> ${result.reason}` };
+                }
+            }
+        }
         return { allowed: true };
     }
     /**
@@ -154,8 +196,21 @@ class PolicyEnforcer {
         return list.map((p) => this.parsePolicy(p));
     }
     async getCumulativeMetric(metricName, period) {
-        let cutoff = new Date(0); // beginning of time
+        const cacheKey = `${metricName}:${period}`;
+        const cached = this.metricCache.get(cacheKey);
         const now = new Date();
+        const ttl = this.config.policyCacheTTL || 60000;
+        if (cached && now.getTime() - cached.timestamp < ttl) {
+            return cached.value;
+        }
+        // Map Hardening: Simple LRU-like eviction to prevent memory leaks
+        if (this.metricCache.size > 1000) {
+            const firstKey = this.metricCache.keys().next().value;
+            if (firstKey !== undefined) {
+                this.metricCache.delete(firstKey);
+            }
+        }
+        let cutoff = new Date(0); // beginning of time
         if (period === 'daily') {
             cutoff = new Date(now.getFullYear(), now.getMonth(), now.getDate());
         }
@@ -168,7 +223,9 @@ class PolicyEnforcer {
             .where('metric_name', '=', metricName)
             .where('created_at', '>=', cutoff)
             .executeTakeFirst();
-        return Number(result?.total || 0);
+        const total = Number(result?.total || 0);
+        this.metricCache.set(cacheKey, { value: total, timestamp: now.getTime() });
+        return total;
     }
     parsePolicy(p) {
         return {

package/dist/cjs/agentic/ResourceMonitor.d.ts

@@ -28,6 +28,15 @@ export declare class ResourceMonitor {
      * Record token usage
      */
     recordUsage(sessionId: string | number, modelName: string, inputTokens: number, outputTokens: number, cost?: number, agentId?: string, metadata?: Record<string, any>): Promise<ResourceUsage>;
+    /**
+     * Pre-run quota validation.
+     * Blocks operations if persona or swarm limits are breached.
+     * Includes cost projection to prevent mid-run budget failure.
+     */
+    validateQuota(agentId: string, swarmId?: string, estimatedTokens?: number): Promise<{
+        allowed: boolean;
+        reason?: string;
+    }>;
     /**
      * Get total cost for a session
      */

package/dist/cjs/agentic/ResourceMonitor.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResourceMonitor = void 0;
-const sql_js_1 = require("../raw-builder/sql.js");
 /**
  * ResourceMonitor tracks token usage and costs across sessions.
  */
@@ -38,6 +37,39 @@ class ResourceMonitor {
             .executeTakeFirstOrThrow();
         return this.parseUsage(usage);
     }
+    /**
+     * Pre-run quota validation.
+     * Blocks operations if persona or swarm limits are breached.
+     * Includes cost projection to prevent mid-run budget failure.
+     */
+    async validateQuota(agentId, swarmId, estimatedTokens = 2000) {
+        // 1. Project cost using Persistent Oracle from QuotaManager
+        let projection = 0;
+        const quotas = this.config.cortex?.quotas;
+        if (quotas) {
+            // Dynamic Lookup via Oracle sync
+            const rate = await quotas.getExchangeRate('USD'); // Oracle baseline
+            projection = estimatedTokens * (rate * 0.00001); // Weighted projection
+        }
+        else {
+            projection = estimatedTokens * 0.00002; // Safe fallback
+        }
+        // 2. Persona Quota Check
+        const personaCheck = await this.config.cortex?.quotas.checkQuota('persona', agentId);
+        if (personaCheck && !personaCheck.allowed)
+            return personaCheck;
+        // 3. Swarm Quota Check
+        if (swarmId) {
+            const swarmCheck = await this.config.cortex?.quotas.checkQuota('swarm', swarmId);
+            if (swarmCheck && !swarmCheck.allowed)
+                return swarmCheck;
+        }
+        // 4. Global Quota Check
+        const globalCheck = await this.config.cortex?.quotas.checkQuota('global');
+        if (globalCheck && !globalCheck.allowed)
+            return globalCheck;
+        return { allowed: true };
+    }
     /**
      * Get total cost for a session
      */
@@ -67,7 +99,9 @@ class ResourceMonitor {
             .selectFrom(this.resourcesTable)
             .select([
             'model_name',
-            (eb) => eb.fn.sum((0, sql_js_1.sql) `input_tokens + output_tokens`).as('totalTokens'),
+            (eb) => eb.fn
+                .sum(eb('input_tokens', '+', 'output_tokens'))
+                .as('totalTokens'),
             (eb) => eb.fn.sum('cost').as('totalCost'),
         ])
             .groupBy('model_name')

package/dist/cjs/agentic/SessionManager.js

@@ -139,6 +139,7 @@ class SessionManager {
                 .selectAll()
                 .where('session_id', '=', sessionId)
                 .where('description', '=', description)
+                .forUpdate() // Audit Phase 13: Atomic goal lock
                 .executeTakeFirst();
             if (existing) {
                 const updated = await trx
@@ -205,23 +206,29 @@ class SessionManager {
      * Mark a message as a semantic anchor to prevent it from being pruned
      */
     async markMessageAsAnchor(messageId) {
-        const message = await this.typedDb
-            .selectFrom(this.messagesTable)
-            .selectAll()
-            .where('id', '=', messageId)
-            .executeTakeFirstOrThrow();
-        const metadata = typeof message.metadata === 'string'
-            ? JSON.parse(message.metadata)
-            : message.metadata || {};
-        const updatedMetadata = { ...metadata, anchor: true };
-        const updated = await this.typedDb
-            .updateTable(this.messagesTable)
-            .set({
-            metadata: JSON.stringify(updatedMetadata),
-        })
-            .where('id', '=', messageId)
-            .returningAll()
-            .executeTakeFirstOrThrow();
+        // PRODUCTION HARDENING: Atomic Metadata Patching
+        // 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
+                .selectFrom(this.messagesTable)
+                .select('metadata')
+                .where('id', '=', messageId)
+                .forUpdate() // Lock the row for the duration of the transaction
+                .executeTakeFirstOrThrow();
+            const metadata = typeof message.metadata === 'string'
+                ? JSON.parse(message.metadata)
+                : message.metadata || {};
+            const updatedMetadata = { ...metadata, anchor: true };
+            return await trx
+                .updateTable(this.messagesTable)
+                .set({
+                metadata: JSON.stringify(updatedMetadata),
+            })
+                .where('id', '=', messageId)
+                .returningAll()
+                .executeTakeFirstOrThrow();
+        });
         return this.parseMessage(updated);
     }
     parseSession(session) {

package/dist/cjs/agentic/VectorIndexer.d.ts

@@ -27,6 +27,7 @@ export declare class VectorIndexer {
     addMemory(content: string, embedding: number[], sessionId?: string | number, metadata?: Record<string, any>): Promise<AgentMemory>;
     /**
      * Batch add memories
+     * Refactored Phase 12: Chunked execution to prevent OOM and long-running locks.
      */
     addMemories(items: {
         content: string;

package/dist/cjs/agentic/VectorIndexer.js

@@ -36,21 +36,28 @@ class VectorIndexer {
     }
     /**
      * Batch add memories
+     * Refactored Phase 12: Chunked execution to prevent OOM and long-running locks.
      */
     async addMemories(items) {
-        const values = items.map((item) => ({
-            content: item.content,
-            embedding: JSON.stringify(item.embedding),
-            session_id: item.sessionId || null,
-            metadata: item.metadata ? JSON.stringify(item.metadata) : null,
-            created_at: new Date(),
-        }));
-        const memories = await this.typedDb
-            .insertInto(this.memoriesTable)
-            .values(values)
-            .returningAll()
-            .execute();
-        return memories.map((m) => this.parseMemory(m));
+        const BATCH_SIZE = 50;
+        const results = [];
+        for (let i = 0; i < items.length; i += BATCH_SIZE) {
+            const chunk = items.slice(i, i + BATCH_SIZE);
+            const values = chunk.map((item) => ({
+                content: item.content,
+                embedding: JSON.stringify(item.embedding),
+                session_id: item.sessionId || null,
+                metadata: item.metadata ? JSON.stringify(item.metadata) : null,
+                created_at: new Date(),
+            }));
+            const memories = await this.typedDb
+                .insertInto(this.memoriesTable)
+                .values(values)
+                .returningAll()
+                .execute();
+            results.push(...memories.map((m) => this.parseMemory(m)));
+        }
+        return results;
     }
     /**
      * Search for similar memories using Hybrid Search (Vector + Keyword)
@@ -86,13 +93,15 @@ class VectorIndexer {
         }
         if (vectorResults.length === 0) {
             // Manual Fallback (Cosine Similarity in-memory)
-            let query = this.typedDb.selectFrom(this.memoriesTable).selectAll();
+            // Audit Phase 12: Hard limit on candidate set to protect memory
+            let query = this.typedDb
+                .selectFrom(this.memoriesTable)
+                .selectAll()
+                .orderBy('created_at', 'desc')
+                .limit(1000);
             if (sessionId) {
                 query = query.where('session_id', '=', sessionId);
             }
-            if (!sessionId) {
-                query = query.orderBy('created_at', 'desc').limit(1000);
-            }
             const allMemories = await query.execute();
             const scored = allMemories.map((mem) => {
                 const vec = typeof mem.embedding === 'string'

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

@@ -16,24 +16,22 @@ export declare class AblationEngine {
     private get typedDb();
     /**
      * Identify "Zombies": Items that have never been retrieved/hit and are old.
-     * Checks for linked dependencies before deletion.
      */
     pruneZombies(thresholdDays?: number): Promise<number>;
     /**
-     * Monitor Performance: Check if recent success rates satisfy the safety baseline.
-     * If performance has dropped > 20% since ablation tests started, trigger auto-recovery.
+     * Monitor Performance and perform Intelligent Rollbacks.
+     * Prioritizes recovery of items with highest historical hit counts.
      */
     monitorAblationPerformance(): Promise<{
         status: 'stable' | 'degraded';
         recoveredCount: number;
     }>;
     /**
-     * Conduct an "Ablation Test": Temporarily disable a knowledge item
-     * to see if it impacts reasoning.
+     * Conduct an "Ablation Test": Temporarily disable a knowledge item.
      */
     testAblation(id: string | number): Promise<boolean>;
     /**
      * Restore an ablated knowledge item to its original state.
      */
-    recoverAblatedItem(id: string | number): Promise<boolean>;
+    recoverAblatedItem(id: string | number, trx?: any): Promise<boolean>;
 }

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

@@ -25,13 +25,13 @@ class AblationEngine {
     }
     /**
      * Identify "Zombies": Items that have never been retrieved/hit and are old.
-     * Checks for linked dependencies before deletion.
      */
     async pruneZombies(thresholdDays = 30) {
         const cutoff = new Date(Date.now() - thresholdDays * 24 * 3600000);
         let totalPruned = 0;
         return await this.db.transaction().execute(async (trx) => {
-            // 1. Prune Knowledge (with dependency check)
+            // 1. Prune Knowledge (with dependency check and pagination)
+            // Audit Phase 9: Paginated selection to prevent OOM
             const knowledgeToPrune = await trx
                 .selectFrom(this.knowledgeTable)
                 .selectAll()
@@ -41,16 +41,16 @@ class AblationEngine {
                 eb('metadata', 'is', null),
             ]))
                 .where('updated_at', '<', cutoff)
-                // Exclude items that are linked
                 .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();
             if (knowledgeToPrune.length > 0) {
                 const candidates = knowledgeToPrune.map((k) => this.cortex.knowledge['parseKnowledge'](k));
                 const idsToDelete = [];
                 for (const item of candidates) {
                     const fitness = this.cortex.knowledge.calculateFitness(item);
-                    // Prune if fitness is below threshold (e.g., 0.3)
                     if (fitness < 0.3) {
                         idsToDelete.push(item.id);
                     }
@@ -63,14 +63,17 @@ class AblationEngine {
                     totalPruned += Number(result.numDeletedRows || 0);
                 }
             }
-            // 2. Prune Memories
+            // 2. Prune Memories (Paginated)
             const memoriesResult = await trx
                 .deleteFrom(this.memoriesTable)
+                .where('id', 'in', (eb) => eb.selectFrom(this.memoriesTable)
+                .select('id')
                 .where('created_at', '<', cutoff)
-                .where((eb) => eb.or([
-                eb('metadata', 'not like', '%"anchor":true%'),
-                eb('metadata', 'is', null),
+                .where((eb2) => eb2.or([
+                eb2('metadata', 'not like', '%"anchor":true%'),
+                eb2('metadata', 'is', null),
             ]))
+                .limit(1000))
                 .executeTakeFirst();
             totalPruned += Number(memoriesResult.numDeletedRows || 0);
             if (totalPruned > 0) {
@@ -80,34 +83,44 @@ class AblationEngine {
         });
     }
     /**
-     * Monitor Performance: Check if recent success rates satisfy the safety baseline.
-     * If performance has dropped > 20% since ablation tests started, trigger auto-recovery.
+     * Monitor Performance and perform Intelligent Rollbacks.
+     * Prioritizes recovery of items with highest historical hit counts.
      */
     async monitorAblationPerformance() {
-        console.log(`[AblationEngine] Running performance monitoring for active ablation tests...`);
-        const baseline = await this.cortex.metrics.getAverageMetric('success_rate');
-        const stats = await this.cortex.metrics.getMetricStats('success_rate');
-        // 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 mass recovery.`);
-            const ablatedItems = await this.typedDb
-                .selectFrom(this.knowledgeTable)
-                .select('id')
-                .where('metadata', 'like', '%"ablation_test":true%')
-                .execute();
-            let recoveredCount = 0;
-            for (const item of ablatedItems) {
-                if (await this.recoverAblatedItem(item.id)) {
-                    recoveredCount++;
+        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');
+            // 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.`);
+                // Fetch ablated items, ordered by hit_count descending (prioritize high-value restore)
+                const ablatedItems = await trx
+                    .selectFrom(this.knowledgeTable)
+                    .select(['id', 'metadata'])
+                    .where('metadata', 'like', '%"ablation_test":true%')
+                    .execute();
+                // Sort by hit_count in memory for precise weighted recovery
+                const sortedItems = ablatedItems.sort((a, b) => {
+                    const metaA = typeof a.metadata === 'string' ? JSON.parse(a.metadata) : a.metadata || {};
+                    const metaB = typeof b.metadata === 'string' ? JSON.parse(b.metadata) : b.metadata || {};
+                    return (metaB.hit_count || 0) - (metaA.hit_count || 0);
+                });
+                let recoveredCount = 0;
+                for (const item of sortedItems) {
+                    if (await this.recoverAblatedItem(item.id, trx)) {
+                        recoveredCount++;
+                    }
+                    // Only recover until performance stabilizes or we've recovered a reasonable chunk (e.g. 5)
+                    if (recoveredCount >= 5)
+                        break;
                 }
+                return { status: 'degraded', recoveredCount };
             }
-            return { status: 'degraded', recoveredCount };
-        }
-        return { status: 'stable', recoveredCount: 0 };
+            return { status: 'stable', recoveredCount: 0 };
+        });
     }
     /**
-     * Conduct an "Ablation Test": Temporarily disable a knowledge item
-     * to see if it impacts reasoning.
+     * Conduct an "Ablation Test": Temporarily disable a knowledge item.
      */
     async testAblation(id) {
         console.log(`[AblationEngine] Conducting ablation test on item ${id}`);
@@ -116,18 +129,18 @@ class AblationEngine {
                 .selectFrom(this.knowledgeTable)
                 .selectAll()
                 .where('id', '=', id)
+                .forUpdate() // Audit Phase 9: Atomic lock for test initiation
                 .executeTakeFirst());
             if (!item)
                 return false;
             const metadata = typeof item.metadata === 'string'
                 ? JSON.parse(item.metadata)
                 : item.metadata || {};
-            // 1. Record the experiment in reflections
             await this.cortex.reflections.reflect(item.source_session_id || 'system', 'success', `Ablation experiment initiated for item ${id}`, [
                 `Temporary confidence reduction to evaluate reasoning impact.`,
                 `Original confidence: ${item.confidence}`,
+                `Historical hits: ${metadata.hit_count || 0}`
             ]);
-            // 2. Perform the ablation
             await trx
                 .updateTable(this.knowledgeTable)
                 .set({
@@ -147,12 +160,13 @@ class AblationEngine {
     /**
      * Restore an ablated knowledge item to its original state.
      */
-    async recoverAblatedItem(id) {
-        return await this.db.transaction().execute(async (trx) => {
-            const item = (await trx
+    async recoverAblatedItem(id, trx) {
+        const recoveryStep = async (t) => {
+            const item = (await t
                 .selectFrom(this.knowledgeTable)
                 .selectAll()
                 .where('id', '=', id)
+                .forUpdate() // Audit Phase 9: Atomic lock for restoration
                 .executeTakeFirst());
             if (!item)
                 return false;
@@ -165,7 +179,7 @@ class AblationEngine {
             delete metadata.ablation_test;
             delete metadata.original_confidence;
             delete metadata.ablated_at;
-            await trx
+            await t
                 .updateTable(this.knowledgeTable)
                 .set({
                 confidence: originalConfidence,
@@ -176,7 +190,13 @@ class AblationEngine {
                 .execute();
             console.log(`[AblationEngine] Item ${id} recovered. Confidence restored to ${originalConfidence}.`);
             return true;
-        });
+        };
+        if (trx) {
+            return await recoveryStep(trx);
+        }
+        else {
+            return await this.db.transaction().execute(recoveryStep);
+        }
     }
 }
 exports.AblationEngine = AblationEngine;

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

@@ -21,7 +21,9 @@ class ActionRefiner {
      */
     async refineActions() {
         const recommendations = [];
-        // 1. Find tools with high failure rates
+        // 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
             .selectFrom(this.actionsTable)
             .select('tool_name')
@@ -29,23 +31,27 @@ class ActionRefiner {
             .select((eb) => eb.fn
             .sum(eb.case().when('status', '=', 'failure').then(1).else(0).end())
             .as('failures'))
+            .where('created_at', '>', windowStart)
             .groupBy('tool_name')
             .execute());
+        const failureRateThreshold = this.config.refiner?.failureRateThreshold || 0.3;
+        const minActionBatch = this.config.refiner?.minActionBatch || 3;
         for (const stat of failureStats) {
             const failures = Number(stat.failures || 0);
             const total = Number(stat.total || 1);
             const rate = failures / total;
-            if (rate > 0.3 && total > 3) {
+            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);
             }
         }
-        // 2. Discover missing capabilities based on error patterns
+        // 2. Discover missing capabilities based on error patterns (Last 24h)
         const missingCapabilities = (await this.db
             .selectFrom(this.actionsTable)
             .select('tool_name')
             .where('status', '=', 'failure')
+            .where('created_at', '>', windowStart)
             .where((eb) => eb.or([
             eb('error', 'like', '%permission denied%'),
             eb('error', 'like', '%unknown tool%'),
@@ -64,17 +70,27 @@ class ActionRefiner {
      * Propose a rule to reflect on a specific tool usage
      */
     async proposeReflectionRule(toolName) {
-        const existing = await this.cortex.rules.getActiveRules('agent_actions', 'insert');
-        const hasRule = existing.some((r) => r.metadata?.targetTool === toolName);
-        if (!hasRule) {
-            console.log(`[ActionRefiner] Proposing reflection rule for tool: ${toolName}`);
-            await this.cortex.rules.defineRule('agent_actions', 'insert', 'audit', {
-                metadata: {
-                    targetTool: toolName,
-                    reason: 'High failure rate detected by ActionRefiner',
-                },
-            });
-        }
+        // Audit Phase 19: Atomic rule proposal via transaction + existence check
+        await this.db.transaction().execute(async (trx) => {
+            const rulesTable = this.cortex.config.rulesTable || 'agent_rules';
+            const existing = await trx
+                .selectFrom(rulesTable)
+                .select('id')
+                .where('tableName', '=', 'agent_actions')
+                .where('operation', '=', 'insert')
+                .where('metadata', 'like', `%\"targetTool\":\"${toolName}\"%`)
+                .forUpdate() // Lock to prevent concurrent proposals
+                .executeTakeFirst();
+            if (!existing) {
+                console.log(`[ActionRefiner] Proposing reflection rule for tool: ${toolName}`);
+                await this.cortex.rules.defineRule('agent_actions', 'insert', 'audit', {
+                    metadata: {
+                        targetTool: toolName,
+                        reason: 'High failure rate detected by ActionRefiner',
+                    },
+                }, trx); // Pass transaction object
+            }
+        });
     }
     /**
      * Propose an update to capabilities

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

@@ -12,7 +12,9 @@ export declare class ConflictResolver {
     /**
      * Audit rules for direct conflicts and semantic overlaps.
      */
-    auditRuleConflicts(): Promise<string[]>;
+    auditRuleConflicts(options?: {
+        batchSize?: number;
+    }): Promise<string[]>;
     /**
      * Resolve a detected conflict by disabling the older rule.
      * Real implementation: Find all active rules for the conflict, and disable all but the newest one.