noormme 1.0.6 → 1.2.0

package/README.md

@@ -1,109 +1,138 @@
-# NOORMME: The Agentic Data Engine
+# NOORMME: The Sovereign Agentic Data Engine
 
-**NOORMME** is a sovereign persistence layer and cognitive operating system designed for **Autonomous AI Agents**. It transcends legacy ORM patterns by providing a self-healing, evolutionary data infrastructure that functions as an extension of the agent's internal reasoning loop.
+**NOORMME** is a sovereign persistence layer and cognitive operating system purpose-built for **Autonomous AI Agents**. It transcends legacy ORM patterns by providing a self-healing, evolutionary data infrastructure that functions as a high-fidelity extension of an agent's internal reasoning loop.
 
-[![Version](https://img.shields.io/npm/v/noormme.svg)](https://www.npmjs.com/package/noormme)
-[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
-[![Cognitive](https://img.shields.io/badge/Intelligence-Autonomous_Governance-purple.svg)](#-autonomous-governance)
+[![Version](https://img.shields.io/npm/v/noormme.svg?style=flat-square&color=black)](https://www.npmjs.com/package/noormme)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg?style=flat-square)](https://opensource.org/licenses/Apache-2.0)
+[![Storage](https://img.shields.io/badge/Storage-SQLite_%26_PostgreSQL-orange.svg?style=flat-square)](./docs/postgresql/POSTGRESQL_SUPPORT.md)
+[![Intelligence](https://img.shields.io/badge/Intelligence-Autonomous_Governance-purple.svg?style=flat-square)](./docs/agentic-intelligence.md)
+[![Scale](https://img.shields.io/badge/Scale-Ultra_Scale_Orchestration-blueviolet.svg?style=flat-square)](./docs/ultra-scale-orchestration.md)
 
 ---
 
-## 🏗 The Agentic Data Loop
+## 🏛️ The Sovereign Triad
 
-NOORMME implements a closed-loop system where data is not merely "stored" but continuously distilled, questioned, and evolved.
+NOORMME is built on three architectural pillars that enable agents to move beyond simple storage into true cognitive autonomy.
 
-### 🧠 Cognitive Orchestration
-- **Strategic Planner**: Proactively suggests and applies persona mutations (roles, policies, capabilities) based on real-time success/latency telemetry.
-- **Knowledge Distiller**: Extracts structured entities and facts from raw history using Jaccard similarity-based consolidation and confidence gradients.
-- **Curiosity Engine**: Identifies "Knowledge Gaps" and "Factual Contradictions," generating research hypotheses and active questions for the agent to resolve.
-- **Ablation Labs**: Conducts "Zombie Pruning" and "Impact Tests"—temporarily disabling knowledge to evaluate its necessity in the reasoning path.
+### 1. 🧠 Cognitive Governance
+Turn your passive database into a living world model. NOORMME implements a closed-loop system where data is distilled, questioned, and evolved.
+- **Semantic Similarity**: Bigram engine for conflict detection.
+- **Curiosity Engine**: Bridges factual gaps and identifies anomalies.
+- **HiveLink**: Promotes local insights to global system wisdom.
 
----
-
-## 💎 Technical Moats
-
-### 🧬 Evolutionary Infrastructure & "DNA Inversion"
-NOORMME allows agents to autonomously mutate their own schema.
-- **Dynamic DDL**: Agents can propose `CREATE TABLE`, `ADD COLUMN`, or `CREATE INDEX` mutations via the **Evolutionary Pilot**.
-- **Structural Rollback**: The **DNA Inverter** automatically generates inverse SQL for any DDL mutation (e.g., inverting an `ADD COLUMN` to a `DROP COLUMN`) to ensure safe structural experimentation.
-- **Real-Time Type Synthesis**: TypeScript interfaces and types are regenerated and written to disk the moment a structural change is committed.
-
-### 🚥 Autonomous Governance (Logic Probes)
-The **Self-Test Registry** enables agents to maintain their own integrity through automated "probes":
-- **Integrity Audits**: Detects orphaned records and semantic memory failures.
-- **Performance Drift**: Detects when autonomous schema changes cause query latency to drift more than 50% from a rolling 100-query baseline.
-- **Consistency Probes**: Verifies that new knowledge doesn't contradict established "Hive" facts.
+### 2. 🧬 Evolutionary DNA
+Allow agents to autonomously mutate their own structural DNA while maintaining 100% safety.
+- **DNA Inversion**: Automatically generates inverse SQL for all autonomous DDL changes.
+- **Self-Healing Indexing**: Proactively optimizes schema based on observed query contexts.
+- **Strategic Mutation**: Sequential evolution loops with autonomous safety rollbacks.
 
-### 📊 Deep Behavioral Telemetry
-A three-layered telemetry stack for research and production observation:
-1. **Raw Event Harvester**: High-fidelity capture of every interaction, pivot, and failure.
-2. **Cognitive Synthesizer**: Serializes the strategic "Evolution Path" and calculates dynamic **Autonomy Levels**.
-3. **Research Alchemist**: Transmutes events into high-order metrics like **Time-to-Magic**, **Discovery Index**, and **Trust Signals**.
+### 3. 🚀 Ultra-Scale Orchestration
+Handle massive agentic workloads with high-throughput intelligence.
+- **Tiered Model Routing**: Route batch tasks to Fast LLMs and reasoning to Premium LLMs.
+- **Predictive Pre-warming**: Eliminates latency by optimizing skills in the background.
+- **Bloom Heuristics**: 100x faster fact de-duplication at the ingestion layer.
 
 ---
 
-## ⚡ Performance Engineering
-
-### Query Intelligence
-- **N+1 Detection**: Real-time pattern analysis to identify and warn about inefficient recursive queries.
-- **Semantic Caching**: Context-aware result caching that understands query patterns rather than just raw SQL.
-- **Dialect Optimization**: Native WAL-mode management for SQLite and optimized JSONB/Vector operations for PostgreSQL.
-
-### High-Fidelity Infrastructure
-- **Unified Vector Abstraction**: Seamless semantic search across `PGVector`, `SQLite-vss`, and a optimized **Manual Cosine Fallback**.
-- **Ritual Orchestration**: Automated background "rituals" for semantic compression, stale history pruning, and database vacuuming.
+## 🧠 The Cognitive Loop
+
+```mermaid
+graph TD
+    subgraph "Ingestion & Distillation"
+        A[Raw Ingestion] --> B{Bigram Distiller}
+    end
+    
+    subgraph "Internal Reasoning"
+        B --> C[Knowledge Base]
+        C --> D[Reasoning Engine]
+        D --> E[Action / Outcome]
+    end
+    
+    subgraph "Evolutionary Feedback"
+        E --> F{Cognitive Reflection}
+        F -->|Success| G[Goal Reinforcement]
+        F -->|Failure| H[DNA Inversion Reset]
+        H --> B
+        G --> I[HiveLink Promotion]
+        I --> B
+    end
+    
+    style B fill:#f9f,stroke:#333,stroke-width:2px
+    style D fill:#bbf,stroke:#333,stroke-width:2px
+    style F fill:#bfb,stroke:#333,stroke-width:2px
+```
 
 ---
 
-## 🚀 Implementation
+## ⚡ Quick Start
+
+### 1. Provision the Mind
+Initialize a self-healing database in seconds. Supports SQLite (Local Cortex) and PostgreSQL (Neural Storage).
 
-### Initializing the Mind
 ```typescript
 import { NOORMME } from 'noormme';
 
 const db = new NOORMME({
-  dialect: 'sqlite',
+  dialect: 'sqlite', // or 'postgresql'
   connection: { database: './mind.sqlite' },
   agentic: {
-    enableSelfEvolution: true,
-    enableSelfHealing: true
+    llm: primaryModel,
+    llmFast: gpt4oMini,
+    enableSelfEvolution: true
   }
 });
 
-// Provisions 20+ tables for goals, knowledge, episodes, and logic probes
 await db.initialize();
 ```
 
-### Strategic Interaction
+### 2. High-Fidelity Data Interaction
+Use the Django-style `objects` manager for sovereign data sifting.
+
+```typescript
+// Access a repository
+const agentRepo = db.getRepository('agents');
+
+// Chainable query logic
+const activeAgents = await agentRepo.objects
+  .filter({ status: 'active', is_verified: true })
+  .exclude({ type: 'temporary' })
+  .order_by('-last_active')
+  .limit(10)
+  .all();
+```
+
+### 3. Autonomous Evolution
+Challenge the system with new evidence and let it evolve.
+
 ```typescript
-// Access the higher-order cognitive facade
 const cortex = db.agent.cortex;
 
-// Execute a background knowledge distillation ritual
+// Execute background rituals (Compression, Pruning, Evolution)
 await cortex.rituals.runPendingRituals();
 
 // Challenge existing knowledge with new evidence
-await cortex.knowledge.challengeKnowledge('SystemArchitecture', 'New facts contradict old.', 0.95);
+await cortex.knowledge.challengeKnowledge('SystemArch', 'New audit results.', 0.95);
 ```
 
 ---
 
-## 🗄 Dialect Matrix
+![NOORMME Banner](./assets/noormme_hero_banner.png)
+
+## 📚 Deep Dive Documentation
+Explore our comprehensive guides to unlock the full potential of your agents:
 
-| Feature | SQLite (Edge) | PostgreSQL (Enterprise) |
-| :--- | :--- | :--- |
-| **Search** | `sqlite-vss` / Fallback | `pgvector` |
-| **Persistence** | WAL Mode | Native Pooling / SSL |
-| **Evolution** | DNA Inversion | Structural Migrations |
-| **Reliability** | Local Atomicity | Multi-Tenant Isolation |
+- [**Full Documentation Index**](./docs/README.md) – Start here for the complete guide.
+- [**Agentic Intelligence**](./docs/agentic-intelligence.md) – Cognitive rules and governance.
+- [**PostgreSQL Neural Storage**](./docs/postgresql/POSTGRESQL_SUPPORT.md) – Enterprise-grade scaling and `pgvector`.
+- [**Ultra-Scale Orchestration**](./docs/ultra-scale-orchestration.md) – Massive scale patterns.
+- [**Strategic Evolution**](./docs/strategic-evolution.md) – DNA inversion and mutation.
+- [**Skill Lifecycle**](./docs/skill-lifecycle.md) – How agents learn and grow.
 
 ---
 
-## 🤝 Community & Contribution
-NOORMME is an Apache 2.0 open-source project. We invite AI researchers and data engineers to contribute to the future of autonomous persistence.
+## 🤝 Community
+NOORMME is an Apache 2.0 open-source project. We invite researchers to contribute to the future of autonomous persistence.
 
 [Contribution Guide](CONTRIBUTING.md) | [Security Audit](SECURITY.md)
 
----
-
 *Transforming passive records into sovereign intelligence.*

package/dist/cjs/agentic/ActionJournal.js

@@ -31,7 +31,7 @@ class ActionJournal {
             tool_name: toolName,
             arguments: JSON.stringify(args),
             status: 'pending',
-            created_at: new Date()
+            created_at: new Date(),
         })
             .returningAll()
             .executeTakeFirstOrThrow();
@@ -52,7 +52,7 @@ class ActionJournal {
             status,
             outcome,
             duration_ms: durationMs || null,
-            metadata: metadata ? JSON.stringify(metadata) : null
+            metadata: metadata ? JSON.stringify(metadata) : null,
         })
             .where('id', '=', actionId)
             .returningAll()
@@ -76,7 +76,7 @@ class ActionJournal {
             .where('session_id', '=', sessionId)
             .orderBy('created_at', 'asc')
             .execute();
-        return actions.map(a => this.parseAction(a));
+        return actions.map((a) => this.parseAction(a));
     }
     /**
      * Get actions by tool name across all sessions.
@@ -89,7 +89,7 @@ class ActionJournal {
             .orderBy('created_at', 'desc')
             .limit(limit)
             .execute();
-        return actions.map(a => this.parseAction(a));
+        return actions.map((a) => this.parseAction(a));
     }
     /**
      * Generate a report of tool failures.
@@ -100,7 +100,7 @@ class ActionJournal {
             .select([
             'tool_name',
             (eb) => eb.fn.count('id').as('failureCount'),
-            (eb) => eb.fn.max('created_at').as('lastFailure')
+            (eb) => eb.fn.max('created_at').as('lastFailure'),
         ])
             .where('status', '=', 'failure')
             .groupBy('tool_name')
@@ -109,7 +109,7 @@ class ActionJournal {
         return results.map((r) => ({
             toolName: r.tool_name,
             failureCount: Number(r.failureCount),
-            lastFailure: r.lastFailure
+            lastFailure: r.lastFailure,
         }));
     }
     parseAction(action) {
@@ -118,12 +118,16 @@ class ActionJournal {
             sessionId: action.session_id,
             messageId: action.message_id,
             toolName: action.tool_name,
-            arguments: typeof action.arguments === 'string' ? JSON.parse(action.arguments) : (action.arguments || {}),
+            arguments: typeof action.arguments === 'string'
+                ? JSON.parse(action.arguments)
+                : action.arguments || {},
             status: action.status,
             outcome: action.outcome,
             durationMs: action.duration_ms,
-            metadata: typeof action.metadata === 'string' ? JSON.parse(action.metadata) : (action.metadata || {}),
-            createdAt: new Date(action.created_at)
+            metadata: typeof action.metadata === 'string'
+                ? JSON.parse(action.metadata)
+                : action.metadata || {},
+            createdAt: new Date(action.created_at),
         };
     }
 }

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

@@ -1,10 +1,12 @@
 import type { Kysely } from '../kysely.js';
-import type { AgenticConfig, AgentCapability } from '../types/index.js';
+import { AgenticConfig, AgentCapability } from '../types/index.js';
+import type { Cortex } from './Cortex.js';
 export interface CapabilityTable {
     id: number | string;
     name: string;
     version: string;
     description: string | null;
+    status: 'experimental' | 'verified' | 'blacklisted';
     reliability: number;
     metadata: string | null;
     created_at: string | Date;
@@ -19,9 +21,11 @@ export interface CapabilityDatabase {
  */
 export declare class CapabilityManager {
     private db;
+    private cortex;
     private config;
     private capabilitiesTable;
-    constructor(db: Kysely<any>, config?: AgenticConfig);
+    private evolutionConfig;
+    constructor(db: Kysely<any>, cortex: Cortex, config?: AgenticConfig);
     private get typedDb();
     /**
      * Register or update a capability (skill)
@@ -29,6 +33,7 @@ export declare class CapabilityManager {
     registerCapability(name: string, version: string, description?: string, metadata?: Record<string, any>): Promise<AgentCapability>;
     /**
      * Update reliability based on action outcome using a damped moving average.
+     * Manages the lifecycle of emergent skills (sandbox -> verified / blacklisted).
      */
     reportOutcome(name: string, success: boolean): Promise<void>;
     /**
@@ -36,8 +41,8 @@ export declare class CapabilityManager {
      */
     getReliability(name: string): Promise<number>;
     /**
-     * Get all registered capabilities
+     * Get all registered capabilities, optionally filtered by status
      */
-    getCapabilities(): Promise<AgentCapability[]>;
+    getCapabilities(status?: AgentCapability['status']): Promise<AgentCapability[]>;
     private parseCapability;
 }

package/dist/cjs/agentic/CapabilityManager.js

@@ -7,12 +7,22 @@ exports.CapabilityManager = void 0;
  */
 class CapabilityManager {
     db;
+    cortex;
     config;
     capabilitiesTable;
-    constructor(db, config = {}) {
+    evolutionConfig;
+    constructor(db, cortex, config = {}) {
         this.db = db;
+        this.cortex = cortex;
         this.config = config;
         this.capabilitiesTable = config.capabilitiesTable || 'agent_capabilities';
+        this.evolutionConfig = {
+            verificationWindow: config.evolution?.verificationWindow ?? 20,
+            rollbackThresholdZ: config.evolution?.rollbackThresholdZ ?? 2.5,
+            enableHiveLink: config.evolution?.enableHiveLink ?? true,
+            mutationAggressiveness: config.evolution?.mutationAggressiveness ?? 0.5,
+            maxSandboxSkills: config.evolution?.maxSandboxSkills ?? 5,
+        };
     }
     get typedDb() {
         return this.db;
@@ -33,8 +43,12 @@ class CapabilityManager {
                     .updateTable(this.capabilitiesTable)
                     .set({
                     description: description || existing.description,
-                    metadata: JSON.stringify({ ...JSON.parse(existing.metadata || '{}'), ...metadata }),
-                    updated_at: new Date()
+                    status: existing.status || 'experimental',
+                    metadata: JSON.stringify({
+                        ...JSON.parse(existing.metadata || '{}'),
+                        ...metadata,
+                    }),
+                    updated_at: new Date(),
                 })
                     .where('id', '=', existing.id)
                     .returningAll()
@@ -47,10 +61,15 @@ class CapabilityManager {
                 name,
                 version,
                 description: description || null,
+                status: metadata.initialStatus || 'experimental',
                 reliability: 1.0,
-                metadata: JSON.stringify({ ...metadata, successCount: 0, totalCount: 0 }),
+                metadata: JSON.stringify({
+                    ...metadata,
+                    successCount: 0,
+                    totalCount: 0,
+                }),
                 created_at: new Date(),
-                updated_at: new Date()
+                updated_at: new Date(),
             })
                 .returningAll()
                 .executeTakeFirstOrThrow();
@@ -59,6 +78,7 @@ class CapabilityManager {
     }
     /**
      * Update reliability based on action outcome using a damped moving average.
+     * Manages the lifecycle of emergent skills (sandbox -> verified / blacklisted).
      */
     async reportOutcome(name, success) {
         await this.db.transaction().execute(async (trx) => {
@@ -70,7 +90,9 @@ class CapabilityManager {
                 .executeTakeFirst();
             if (capability) {
                 const cap = capability;
-                const metadata = typeof cap.metadata === 'string' ? JSON.parse(cap.metadata) : (cap.metadata || {});
+                const metadata = typeof cap.metadata === 'string'
+                    ? JSON.parse(cap.metadata)
+                    : cap.metadata || {};
                 const totalCount = (metadata.totalCount || 0) + 1;
                 const successCount = (metadata.successCount || 0) + (success ? 1 : 0);
                 // Damped moving average: weight recent outcomes more but keep history
@@ -80,12 +102,81 @@ class CapabilityManager {
                 const newReliability = success
                     ? Math.min(1.0, currentReliability * (1 - alpha) + alpha)
                     : Math.max(0.0, currentReliability * (1 - alpha));
+                let newStatus = cap.status || 'experimental';
+                // --- Emergent Skill Evolution Optimization ---
+                const successStreak = (metadata.successStreak || 0) + (success ? 1 : 0);
+                const failureStreak = success ? 0 : (metadata.failureStreak || 0) + 1;
+                const streakSuccess = success ? successStreak : 0;
+                const winRate = successCount / totalCount;
+                const windowSize = this.evolutionConfig.verificationWindow || 20;
+                const minSampleSize = Math.ceil(windowSize * 0.75);
+                // Fast-Track Promotion: 5 consecutive successes bypasses sample size
+                const isPromotable = (totalCount >= minSampleSize && winRate >= 0.8) || streakSuccess >= 5;
+                // Early-Exit Rollback: 3 consecutive failures at the start immediately blacklists
+                const isCatastrophic = !success && failureStreak >= 3 && totalCount <= 5;
+                // Pass 6: Predictive Pre-warming Trigger
+                // If a skill is close to promotion, pre-warm its optimized description
+                const promoThreshold = Math.ceil(minSampleSize * 0.8);
+                const isNearingPromotion = (totalCount >= promoThreshold && winRate >= 0.8) ||
+                    streakSuccess === 4;
+                if (isNearingPromotion &&
+                    newStatus === 'experimental' &&
+                    this.cortex.skillSynthesizer) {
+                    // Trigger async background pre-warming
+                    this.cortex.skillSynthesizer.preWarmSkill(name).catch(() => { });
+                }
+                // --- Production Hardening: Dynamic Performance Baselining ---
+                const historyAlpha = 0.05; // Slower moving average for baseline
+                const baseline = metadata.performanceBaseline ?? winRate;
+                const newBaseline = baseline * (1 - historyAlpha) + winRate * historyAlpha;
+                // Variance tracking for Z-score calculation
+                const variance = metadata.performanceVariance ?? 0.01;
+                const diff = winRate - baseline;
+                const newVariance = variance * (1 - historyAlpha) + Math.pow(diff, 2) * historyAlpha;
+                const stdDev = Math.sqrt(newVariance);
+                // Z-Score: How many standard deviations is current performance from baseline?
+                const zScore = stdDev > 0 ? (winRate - baseline) / stdDev : 0;
+                // Promotion/Demotion Logic
+                if (isCatastrophic &&
+                    (newStatus === 'experimental' || newStatus === 'sandbox')) {
+                    console.error(`[CapabilityManager] Skill '${name}' FAILED early-exit safety check (Streak: ${failureStreak}). Blacklisting immediately.`);
+                    newStatus = 'blacklisted';
+                }
+                else if (isPromotable &&
+                    (newStatus === 'experimental' || newStatus === 'sandbox')) {
+                    console.log(`[CapabilityManager] Skill '${name}' PASSED fast-track verification (Streak: ${streakSuccess}, Rate: ${(winRate * 100).toFixed(1)}%). Promoting to Verified.`);
+                    newStatus = 'verified';
+                }
+                else if (totalCount >= minSampleSize) {
+                    if (winRate < 0.4) {
+                        console.log(`[CapabilityManager] Skill '${name}' FAILED statistical verification (Rate: ${(winRate * 100).toFixed(1)}%). Blacklisting.`);
+                        newStatus = 'blacklisted';
+                    }
+                    else if (newStatus === 'verified' && zScore < -2.0) {
+                        // Performance Collapse: Z-score indicates current run is significantly below historical baseline
+                        console.warn(`[CapabilityManager] Verified skill '${name}' PERFORMANCE COLLAPSE (Z: ${zScore.toFixed(2)}, Rate: ${(winRate * 100).toFixed(1)}%). Demoting to Experimental.`);
+                        newStatus = 'experimental';
+                    }
+                }
+                if (newStatus !== cap.status) {
+                    console.log(`[CapabilityManager] EVOLVING STATUS: ${name} (${cap.status} -> ${newStatus})`);
+                }
                 await trx
                     .updateTable(this.capabilitiesTable)
                     .set({
                     reliability: newReliability,
-                    metadata: JSON.stringify({ ...metadata, totalCount, successCount }),
-                    updated_at: new Date()
+                    status: newStatus,
+                    metadata: JSON.stringify({
+                        ...metadata,
+                        totalCount,
+                        successCount,
+                        successStreak: streakSuccess,
+                        failureStreak,
+                        performanceBaseline: newBaseline,
+                        performanceVariance: newVariance,
+                        lastOutcomeType: success ? 'success' : 'failure', // Categorization point
+                    }),
+                    updated_at: new Date(),
                 })
                     .where('id', '=', cap.id)
                     .execute();
@@ -105,15 +196,17 @@ class CapabilityManager {
         return cap ? cap.reliability : 0.0;
     }
     /**
-     * Get all registered capabilities
+     * Get all registered capabilities, optionally filtered by status
      */
-    async getCapabilities() {
-        const list = await this.typedDb
+    async getCapabilities(status) {
+        let query = this.typedDb
             .selectFrom(this.capabilitiesTable)
-            .selectAll()
-            .orderBy('name', 'asc')
-            .execute();
-        return list.map(c => this.parseCapability(c));
+            .selectAll();
+        if (status) {
+            query = query.where('status', '=', status);
+        }
+        const list = await query.orderBy('name', 'asc').execute();
+        return list.map((c) => this.parseCapability(c));
     }
     parseCapability(cap) {
         return {
@@ -121,10 +214,13 @@ class CapabilityManager {
             name: cap.name,
             version: cap.version,
             description: cap.description,
+            status: cap.status || 'experimental',
             reliability: cap.reliability,
-            metadata: typeof cap.metadata === 'string' ? JSON.parse(cap.metadata) : (cap.metadata || {}),
+            metadata: typeof cap.metadata === 'string'
+                ? JSON.parse(cap.metadata)
+                : cap.metadata || {},
             createdAt: new Date(cap.created_at),
-            updatedAt: new Date(cap.updated_at)
+            updatedAt: new Date(cap.updated_at),
         };
     }
 }

package/dist/cjs/agentic/CognitiveRepository.js

@@ -20,16 +20,18 @@ class CognitiveRepository {
      */
     async triggerRules(operation, data) {
         // Check if rules table exists to avoid errors during initialization
-        const rulesTable = this.cortex.config.agentic?.rulesTable || this.cortex.config.rulesTable || 'agent_rules';
+        const rulesTable = this.cortex.config.agentic?.rulesTable ||
+            this.cortex.config.rulesTable ||
+            'agent_rules';
         const tables = await this.cortex.db.introspection.getTables();
-        if (!tables.some(t => t.name === rulesTable)) {
+        if (!tables.some((t) => t.name === rulesTable)) {
             return data;
         }
         const result = await this.cortex.rules.evaluateRules(this.table.name, operation, data);
         if (result.action === 'deny') {
             throw new NoormError_js_1.NoormError(`Operation ${operation} on ${this.table.name} denied: ${result.reason}`, {
                 operation: 'cognitive_rule_enforcement',
-                suggestion: 'Check agent rules or adjust policy'
+                suggestion: 'Check agent rules or adjust policy',
             });
         }
         if (result.action === 'audit') {
@@ -37,7 +39,7 @@ class CognitiveRepository {
         }
         if (result.action === 'mask' && result.ruleId) {
             const rules = await this.cortex.rules.getActiveRules(this.table.name, operation);
-            const rule = rules.find(r => r.id === result.ruleId);
+            const rule = rules.find((r) => r.id === result.ruleId);
             if (rule) {
                 return this.cortex.rules.applyMasking(data, rule);
             }
@@ -57,10 +59,18 @@ class CognitiveRepository {
         return await this.repository.delete(id);
     }
     // Delegate other methods to the internal repository
-    async findById(id) { return this.repository.findById(id); }
-    async findAll() { return this.repository.findAll(); }
-    async count() { return this.repository.count(); }
-    async exists(id) { return this.repository.exists(id); }
+    async findById(id) {
+        return this.repository.findById(id);
+    }
+    async findAll() {
+        return this.repository.findAll();
+    }
+    async count() {
+        return this.repository.count();
+    }
+    async exists(id) {
+        return this.repository.exists(id);
+    }
     // Dynamic method delegation via Proxy
     static createProxy(repository, table, cortex) {
         const cognitive = new CognitiveRepository(repository, table, cortex);
@@ -70,7 +80,7 @@ class CognitiveRepository {
                     return cognitive[prop];
                 }
                 return Reflect.get(target, prop, receiver);
-            }
+            },
         });
     }
 }