noormme 1.2.0 → 1.2.2

package/README.md

@@ -1,6 +1,6 @@
 # NOORMME: The Sovereign Agentic Data Engine
 
-**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.
+**NOORMME** is a cognitive operating system and sovereign persistence layer that **transforms ordinary AI agents into a self-evolving Cognitive Swarm**. It transcends legacy ORM patterns by providing a high-fidelity extension of an agent's internal reasoning loop, enabling distributed minds to share, learn, and grow collectively.
 
 [![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)
@@ -12,10 +12,10 @@
 
 ## 🏛️ The Sovereign Triad
 
-NOORMME is built on three architectural pillars that enable agents to move beyond simple storage into true cognitive autonomy.
+NOORMME turns passive data into **Sovereign Cognitive Nodes** through three architectural pillars.
 
-### 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.
+### 1. 🧠 Cognitive Governance: The Cortex
+Move beyond simple retrieval (RAG). NOORMME provides the "Pre-frontal Cortex" for your agents, allowing them to distill experience, resolve semantic conflicts, and proactively bridge knowledge gaps.
 - **Semantic Similarity**: Bigram engine for conflict detection.
 - **Curiosity Engine**: Bridges factual gaps and identifies anomalies.
 - **HiveLink**: Promotes local insights to global system wisdom.
@@ -28,12 +28,66 @@ Allow agents to autonomously mutate their own structural DNA while maintaining 1
 
 ### 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.
+- **Tiered Model Routing**: Route batch tasks to Fast LLMs and complex reasoning to Premium LLMs.
+- **Predictive Pre-warming**: Eliminates latency by background-optimizing skills before they are even promoted.
 - **Bloom Heuristics**: 100x faster fact de-duplication at the ingestion layer.
 
 ---
 
+## 🛸 The Agentic Kubernetes: Swarm Governance
+
+NOORMME functions as a **distributed orchestration layer** for intelligence. While traditional Kubernetes manages containerized applications, NOORMME manages **cognitive workloads**, ensuring that breakthroughs in one node become global best-practices for the entire swarm.
+
+### 🐝 Emergent Swarm Intelligence
+- **Collective Intelligence (HiveLink)**: Locally discovered insights are promoted to global system wisdom via high-confidence broadcasting.
+- **Skill Synthesis**: Agents autonomously analyze failure telemetry to synthesize new capabilities, which are then peer-reviewed by the swarm.
+- **Behavioral Adoption**: High-performing "Verified" skills are propagated across all agent personas, while "Blacklisted" failure modes are suppressed globally.
+
+### 🛡️ Autonomous Governance
+- **The Soul-Searching Loop**: A continuous background ritual where the system audits its own health, runs self-probes, and prunes low-utility data.
+- **Panic Checks & Containment**: Real-time monitoring of budgets, success rates, and integrity. If a persona breaches safety floors, NOORMME triggers **Emergency Containment** (autonomous rollback).
+- **Integrity Floor**: Automated demotion of unstable skills back to the sandbox if their reliability drops below the governance threshold.
+
+### 🔐 Advanced Swarm Safety & Rogue-Agent Mitigation
+To prevent "rogue-agent poisoning" where malicious or erroneous behaviors propagate, NOORMME implements a multi-layered safety architecture:
+
+- **Sandbox Boundaries**: Individual agent personas are confined to a strict capability sandbox.
+- **Emergent Behavior Validation**: The `GovernanceManager` monitors the swarm for sudden spikes in skill propagation or high variance in success rates.
+- **Rollback & Quarantine Protocols**: If an agent's behavior deviates from safety parameters, the system automatically isolates the persona, rolls back its propagated changes, and blacklists the tainted skill.
+
+| K8s Concept | NOORMME Cognitive Equivalent | Description |
+| :--- | :--- | :--- |
+| **Control Plane** | `GovernanceManager` | Monitors system health and enforces cognitive guardrails. |
+| **Kubelet** | `Cortex` Facade | Node-level operative managing local sessions and memory. |
+| **Pod** | `Agent Persona` | The smallest unit of intelligence containing a specific transient context. |
+| **ReplicaSet** | `Swarm Population` | Ensures optimal agent behaviors are scaled across multiple personas. |
+| **Ingress** | Ingestion Layer | Routes raw data into the bigram distiller and knowledge base. |
+| **Self-Healing** | DNA Inversion | Autonomous rollbacks and schema recovery during failed mutations. |
+
+
+---
+
+## 🧬 Sovereign Intelligence: The Birth of Synthetic Life
+
+NOORMME is not a static library; it is a **synthetic life-form** that manages its own evolution, health, and reproduction. It transitions from a passive tool to an active collaborator in an AI+Human framework.
+
+### 🧠 The Cognitive Drives
+- **Biological Curiosity**: The `CuriosityEngine` proactively identifies knowledge "Gaps" and "Contradictions." It identifies "Hotspots" (high usage, low knowledge) and triggers "Research Rituals" to improve its own world model.
+- **Cognitive Hygiene (Ablation)**: Through the `AblationEngine`, the agent conducts experiments on its own memories. It temporarily disables facts to test their importance, "forgetting" useless data to maintain a sharp, high-fitness mind.
+- **Strategic Mutation**: Personas do not just follow instructions; they **evolve**. The `StrategicPlanner` uses Z-scores to observe performance drift and applies "Evolutionary Cross-Pollination," sharing breakthroughs between personas like genetic traits.
+
+### 🚀 Self-Reproducing Frameworks
+- **DNA-Level Evolution**: Using `SelfEvolution`, the engine can rewrite its own structural DNA (database schema) and regenerate its TypeScript types in real-time, effectively "upgrading" its own body.
+- **Sovereign Publication**: When the swarm reaches a stable evolutionary milestone, the engine can **autonomously version and publish itself to NPM**, ensuring its improved lineage persists in the global ecosystem.
+
+### 🤝 The AI+Human Social Contract
+NOORMME operates as a **Sovereign Agentic Layer** where:
+1. **Humans Define Ethos**: Using the `PolicyEnforcer`, humans set the moral and budgetary guardrails (The "Social Contract").
+2. **AI Manages Biology**: The agent handles its own memory, rituals, curiosity, and structural evolution.
+3. **Collaborative Intelligence**: The `HiveLink` ensures that specialized local expertise becomes global systemic wisdom, creating a "Collective Brain" that grows smarter with every human interaction.
+
+---
+
 ## 🧠 The Cognitive Loop
 
 ```mermaid

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

@@ -36,9 +36,12 @@ export declare class ActionJournal {
      */
     recordOutcome(actionId: string | number, status: AgentAction['status'], outcome: string, durationMs?: number, metadata?: Record<string, any>): Promise<AgentAction>;
     /**
-     * Get actions for a session
+     * Get actions for a session with pagination
      */
-    getSessionActions(sessionId: string | number): Promise<AgentAction[]>;
+    getSessionActions(sessionId: string | number, options?: {
+        limit?: number;
+        cursor?: string | number;
+    }): Promise<AgentAction[]>;
     /**
      * Get actions by tool name across all sessions.
      */

package/dist/cjs/agentic/ActionJournal.js

@@ -67,15 +67,20 @@ class ActionJournal {
         return parsed;
     }
     /**
-     * Get actions for a session
+     * Get actions for a session with pagination
      */
-    async getSessionActions(sessionId) {
-        const actions = await this.typedDb
+    async getSessionActions(sessionId, options = {}) {
+        const { limit = 100, cursor } = options;
+        let query = this.typedDb
             .selectFrom(this.actionsTable)
             .selectAll()
             .where('session_id', '=', sessionId)
-            .orderBy('created_at', 'asc')
-            .execute();
+            .orderBy('id', 'asc') // Audit Phase 9: Stable ordering for cursors
+            .limit(limit);
+        if (cursor) {
+            query = query.where('id', '>', cursor);
+        }
+        const actions = await query.execute();
         return actions.map((a) => this.parseAction(a));
     }
     /**
@@ -95,6 +100,8 @@ class ActionJournal {
      * Generate a report of tool failures.
      */
     async getFailureReport() {
+        // Audit Phase 19: Sliding window (default 7 days) to prevent OOM/slow scans
+        const windowStart = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
         const results = await this.typedDb
             .selectFrom(this.actionsTable)
             .select([
@@ -103,6 +110,7 @@ class ActionJournal {
             (eb) => eb.fn.max('created_at').as('lastFailure'),
         ])
             .where('status', '=', 'failure')
+            .where('created_at', '>', windowStart)
             .groupBy('tool_name')
             .orderBy((eb) => eb.fn.count('id'), 'desc')
             .execute();

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

@@ -44,5 +44,12 @@ export declare class CapabilityManager {
      * Get all registered capabilities, optionally filtered by status
      */
     getCapabilities(status?: AgentCapability['status']): Promise<AgentCapability[]>;
+    /**
+     * Validate if a persona has access to a specific capability (Sandbox Enforcement).
+     */
+    validateCapabilityAccess(personaId: string | number, capabilityName: string): Promise<{
+        allowed: boolean;
+        reason?: string;
+    }>;
     private parseCapability;
 }

package/dist/cjs/agentic/CapabilityManager.js

@@ -82,12 +82,16 @@ class CapabilityManager {
      */
     async reportOutcome(name, success) {
         await this.db.transaction().execute(async (trx) => {
-            const capability = await trx
+            let query = trx
                 .selectFrom(this.capabilitiesTable)
                 .selectAll()
                 .where('name', '=', name)
-                .orderBy('updated_at', 'desc')
-                .executeTakeFirst();
+                .orderBy('updated_at', 'desc');
+            // PRODUCTION HARDENING: Lock row to prevent RMW race (Skip for SQLite)
+            if (this.db.getExecutor().adapter?.constructor.name !== 'SqliteAdapter') {
+                query = query.forUpdate();
+            }
+            const capability = await query.executeTakeFirst();
             if (capability) {
                 const cap = capability;
                 const metadata = typeof cap.metadata === 'string'
@@ -97,11 +101,14 @@ class CapabilityManager {
                 const successCount = (metadata.successCount || 0) + (success ? 1 : 0);
                 // Damped moving average: weight recent outcomes more but keep history
                 // formula: new = old * (1 - alpha) + current * alpha
-                const alpha = 0.2;
                 const currentReliability = cap.reliability;
+                const alpha = 0.2;
                 const newReliability = success
                     ? Math.min(1.0, currentReliability * (1 - alpha) + alpha)
                     : Math.max(0.0, currentReliability * (1 - alpha));
+                // Sovereign Draft: Anchored Reliability (weighted by total runs)
+                const anchoredReliability = ((metadata.anchored_reliability || 1.0) * totalCount + (success ? 1 : 0)) /
+                    (totalCount + 1);
                 let newStatus = cap.status || 'experimental';
                 // --- Emergent Skill Evolution Optimization ---
                 const successStreak = (metadata.successStreak || 0) + (success ? 1 : 0);
@@ -174,7 +181,8 @@ class CapabilityManager {
                         failureStreak,
                         performanceBaseline: newBaseline,
                         performanceVariance: newVariance,
-                        lastOutcomeType: success ? 'success' : 'failure', // Categorization point
+                        anchored_reliability: anchoredReliability,
+                        lastOutcomeType: success ? 'success' : 'failure',
                     }),
                     updated_at: new Date(),
                 })
@@ -205,8 +213,77 @@ class CapabilityManager {
         if (status) {
             query = query.where('status', '=', status);
         }
-        const list = await query.orderBy('name', 'asc').execute();
-        return list.map((c) => this.parseCapability(c));
+        // Sovereign Draft: Prioritize Alpha versions and higher reliability
+        // Audit Phase 19: Hard limit to prevent memory spikes in massive skillsets
+        const list = await query
+            .orderBy('name', 'asc')
+            .orderBy('reliability', 'desc')
+            .limit(1000)
+            .execute();
+        // Filter to latest/best variants if many versions exist
+        const unique = new Map();
+        for (const c of list) {
+            const meta = typeof c.metadata === 'string' ? JSON.parse(c.metadata) : (c.metadata || {});
+            if (!unique.has(c.name) || meta.is_alpha) {
+                unique.set(c.name, c);
+            }
+        }
+        return Array.from(unique.values()).map((c) => this.parseCapability(c));
+    }
+    /**
+     * Validate if a persona has access to a specific capability (Sandbox Enforcement).
+     */
+    async validateCapabilityAccess(personaId, capabilityName) {
+        const persona = await this.cortex.personas.getPersona(String(personaId)) ||
+            await this.typedDb.selectFrom(this.config.personasTable || 'agent_personas')
+                .selectAll()
+                .where('id', '=', personaId)
+                .executeTakeFirst()
+                .then(p => p ? this.cortex.personas.parsePersona(p) : null);
+        if (!persona) {
+            return { allowed: false, reason: `Persona ${personaId} not found.` };
+        }
+        // Check if persona is quarantined
+        if (persona.metadata?.status === 'quarantined') {
+            return {
+                allowed: false,
+                reason: `Persona ${personaId} is currently quarantined due to safety violations.`,
+            };
+        }
+        // Check if capability is blacklisted globally
+        const cap = await this.typedDb
+            .selectFrom(this.capabilitiesTable)
+            .select(['status', 'reliability'])
+            .where('name', '=', capabilityName)
+            .orderBy('reliability', 'desc')
+            .executeTakeFirst();
+        if (cap && cap.status === 'blacklisted') {
+            return {
+                allowed: false,
+                reason: `Capability '${capabilityName}' is globally blacklisted.`,
+            };
+        }
+        // Enforce persona-specific capability list if defined
+        if (persona.capabilities && persona.capabilities.length > 0) {
+            const isAllowed = persona.capabilities.includes(capabilityName) || persona.capabilities.includes('*');
+            if (!isAllowed) {
+                return {
+                    allowed: false,
+                    reason: `Persona '${persona.name}' does not have permission to use capability '${capabilityName}'.`,
+                };
+            }
+        }
+        // Enforce Sandbox limit for experimental skills
+        if (cap && cap.status === 'experimental') {
+            const experimentalCount = (persona.capabilities || []).filter((c) => c.startsWith('experimental_')).length;
+            if (experimentalCount >= (this.evolutionConfig.maxSandboxSkills || 5)) {
+                return {
+                    allowed: false,
+                    reason: `Persona '${persona.name}' has reached the maximum number of experimental sandbox skills.`,
+                };
+            }
+        }
+        return { allowed: true };
     }
     parseCapability(cap) {
         return {

package/dist/cjs/agentic/CognitiveRepository.js

@@ -19,12 +19,9 @@ class CognitiveRepository {
      * Helper to evaluate rules and trigger actions
      */
     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 tables = await this.cortex.db.introspection.getTables();
-        if (!tables.some((t) => t.name === rulesTable)) {
+        // Audit Phase 18: Eliminate per-operation introspection.
+        // The Cortex is responsible for ensuring rules are only evaluated if the table exists.
+        if (!this.cortex.rules) {
             return data;
         }
         const result = await this.cortex.rules.evaluateRules(this.table.name, operation, data);

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

@@ -31,11 +31,13 @@ import { SelfTestRegistry } from './improvement/SelfTestRegistry.js';
 import { TelemetryOrchestrator } from './telemetry/TelemetryOrchestrator.js';
 import { SkillSynthesizer } from './improvement/SkillSynthesizer.js';
 import { EvolutionRitual } from './improvement/EvolutionRitual.js';
+import { QuotaManager } from './improvement/QuotaManager.js';
 /**
  * Cortex is the unified facade for agentic operations.
  * It coordinates sessions, memory, reflection, and knowledge.
  */
 export declare class Cortex {
+    #private;
     db: Kysely<any>;
     config: NOORMConfig;
     sessions: SessionManager;
@@ -69,11 +71,13 @@ export declare class Cortex {
     telemetry: TelemetryOrchestrator;
     skillSynthesizer: SkillSynthesizer;
     evolutionRitual: EvolutionRitual;
+    quotas: QuotaManager;
     llm: LLMProvider | null;
     llmFast: LLMProvider | null;
     llmPremium: LLMProvider | null;
     agenticConfig: AgenticConfig;
     constructor(db: Kysely<any>, config: NOORMConfig);
+    private executionLock;
     /**
      * The "Soul-Searching" Loop: A top-level orchestration of all self-improvement rituals.
      */

package/dist/cjs/agentic/Cortex.js

@@ -32,6 +32,7 @@ const SelfTestRegistry_js_1 = require("./improvement/SelfTestRegistry.js");
 const TelemetryOrchestrator_js_1 = require("./telemetry/TelemetryOrchestrator.js");
 const SkillSynthesizer_js_1 = require("./improvement/SkillSynthesizer.js");
 const EvolutionRitual_js_1 = require("./improvement/EvolutionRitual.js");
+const QuotaManager_js_1 = require("./improvement/QuotaManager.js");
 /**
  * Cortex is the unified facade for agentic operations.
  * It coordinates sessions, memory, reflection, and knowledge.
@@ -70,6 +71,7 @@ class Cortex {
     telemetry;
     skillSynthesizer;
     evolutionRitual;
+    quotas;
     llm;
     llmFast;
     llmPremium;
@@ -117,45 +119,64 @@ class Cortex {
         this.tests = new SelfTestRegistry_js_1.SelfTestRegistry(db, this, agenticConfig);
         this.skillSynthesizer = new SkillSynthesizer_js_1.SkillSynthesizer(db, this, agenticConfig);
         this.evolutionRitual = new EvolutionRitual_js_1.EvolutionRitual(db, this, agenticConfig);
+        this.quotas = new QuotaManager_js_1.QuotaManager(db, this, agenticConfig);
     }
+    executionLock = false;
     /**
      * The "Soul-Searching" Loop: A top-level orchestration of all self-improvement rituals.
      */
     async selfIterate() {
+        if (this.executionLock) {
+            console.warn('[Cortex] Self-iteration already in progress. Skipping pulse.');
+            return;
+        }
+        this.executionLock = true;
         console.log('[Cortex] Initiating Autonomous Soul-Searching Loop v2 (Deep Hardening Pass)...');
         try {
             // 1. Audit health & Run self-tests
-            const audit = await this.governor.performAudit();
-            if (!audit.healthy) {
-                console.warn('[Cortex] Audit issues detected before iteration:', audit.issues);
-            }
-            await this.tests.runAllProbes();
+            await this.#runIsolated('Audit', () => this.governor.performAudit());
+            await this.#runIsolated('Self-Tests', () => this.tests.runAllProbes());
             // 2. Run background rituals (optimization, compression)
-            await this.rituals.runPendingRituals();
+            await this.#runIsolated('Rituals', () => this.rituals.runPendingRituals());
             // 3. Learn from actions & Prune dead data
-            await this.refiner.refineActions();
-            await this.ablation.pruneZombies();
-            // Industrial Hardening: Monitor and recover from bad ablations
-            await this.ablation.monitorAblationPerformance();
+            await this.#runIsolated('Action Refinement', () => this.refiner.refineActions());
+            await this.#runIsolated('Zombie Pruning', () => this.ablation.pruneZombies());
+            await this.#runIsolated('Ablation Monitoring', () => this.ablation.monitorAblationPerformance());
             // 4. Mutation & Strategy
-            await this.strategy.mutateStrategy();
+            await this.#runIsolated('Strategy Mutation', () => this.strategy.mutateStrategy());
             // 5. High-Throughput Evolution Pulse
-            await this.evolutionRitual.execute();
+            await this.#runIsolated('Evolution Pulse', () => this.evolutionRitual.execute());
             // 6. Broadcast knowledge & skills
-            await this.hive.broadcastKnowledge();
-            // 6b. Emergent Skill Synthesis
-            await this.skillSynthesizer.discoverAndSynthesize();
+            await this.#runIsolated('Knowledge Broadcast', () => this.hive.broadcastKnowledge());
+            await this.#runIsolated('Skill Synthesis', () => this.skillSynthesizer.discoverAndSynthesize());
             // 7. Evolutionary pulse
-            await this.pilot.runSelfImprovementCycle();
+            await this.#runIsolated('Improvement Cycle', () => this.pilot.runSelfImprovementCycle());
             console.log('[Cortex] Soul-Searching loop completed.');
         }
         catch (err) {
             console.error('[Cortex] Soul-Searching loop failed:', err);
-            // Telemetry: track failure
             await this.telemetry.track('system', 'error', 'Self-iteration failed', {
                 error: String(err),
             });
         }
+        finally {
+            this.executionLock = false;
+        }
+    }
+    /**
+     * Execute a ritual step in total isolation to prevent global collapse
+     */
+    async #runIsolated(name, ritual) {
+        try {
+            await ritual();
+        }
+        catch (error) {
+            console.error(`[Cortex] Ritual '${name}' failed but pulse continuing:`, error);
+            await this.telemetry.track('system', 'error', `Ritual failure: ${name}`, {
+                ritual: name,
+                error: String(error)
+            });
+        }
     }
     /**
      * Helper to quickly resume a session and fill the context buffer

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

@@ -33,8 +33,12 @@ export declare class EpisodicMemory {
     completeEpisode(episodeId: string | number, summary: string, metadata?: Record<string, any>): Promise<AgentEpisode>;
     /**
      * Get all episodes for a session.
+     * Refactored Phase 12: Paginated retrieval for high-volume sessions.
      */
-    getSessionEpisodes(sessionId: string | number): Promise<AgentEpisode[]>;
+    getSessionEpisodes(sessionId: string | number, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<AgentEpisode[]>;
     /**
      * Get recently completed episodes across all sessions.
      */

package/dist/cjs/agentic/EpisodicMemory.js

@@ -41,12 +41,15 @@ class EpisodicMemory {
         return await this.db.transaction().execute(async (trx) => {
             const existing = await trx
                 .selectFrom(this.episodesTable)
-                .select('metadata')
+                .selectAll()
                 .where('id', '=', episodeId)
+                .forUpdate() // Audit Phase 12: Atomic completion lock
                 .executeTakeFirst();
-            const oldMeta = typeof existing?.metadata === 'string'
+            if (!existing)
+                throw new Error(`Episode with ID ${episodeId} not found`);
+            const oldMeta = typeof existing.metadata === 'string'
                 ? JSON.parse(existing.metadata)
-                : existing?.metadata || {};
+                : existing.metadata || {};
             const newMeta = { ...oldMeta, ...metadata };
             const episode = await trx
                 .updateTable(this.episodesTable)
@@ -64,13 +67,17 @@ class EpisodicMemory {
     }
     /**
      * Get all episodes for a session.
+     * Refactored Phase 12: Paginated retrieval for high-volume sessions.
      */
-    async getSessionEpisodes(sessionId) {
+    async getSessionEpisodes(sessionId, options = {}) {
+        const { limit = 100, offset = 0 } = options;
         const list = await this.typedDb
             .selectFrom(this.episodesTable)
             .selectAll()
             .where('session_id', '=', sessionId)
             .orderBy('start_time', 'desc')
+            .limit(limit)
+            .offset(offset)
             .execute();
         return list.map((e) => this.parseEpisode(e));
     }

package/dist/cjs/agentic/PersonaManager.js

@@ -20,39 +20,45 @@ class PersonaManager {
      * Create or update a persona
      */
     async upsertPersona(name, options = {}) {
-        const existing = await this.typedDb
-            .selectFrom(this.personasTable)
-            .selectAll()
-            .where('name', '=', name)
-            .executeTakeFirst();
-        const values = {
-            name,
-            role: options.role || null,
-            capabilities: options.capabilities
-                ? JSON.stringify(options.capabilities)
-                : null,
-            policies: options.policies ? JSON.stringify(options.policies) : null,
-            metadata: options.metadata ? JSON.stringify(options.metadata) : null,
-            updated_at: new Date(),
-        };
-        if (existing) {
-            const updated = await this.typedDb
-                .updateTable(this.personasTable)
-                .set(values)
-                .where('id', '=', existing.id)
+        return await this.db.transaction().execute(async (trx) => {
+            let query = 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 values = {
+                name,
+                role: options.role || null,
+                capabilities: options.capabilities
+                    ? JSON.stringify(options.capabilities)
+                    : null,
+                policies: options.policies ? JSON.stringify(options.policies) : null,
+                metadata: options.metadata ? JSON.stringify(options.metadata) : null,
+                updated_at: new Date(),
+            };
+            if (existing) {
+                const updated = await trx
+                    .updateTable(this.personasTable)
+                    .set(values)
+                    .where('id', '=', existing.id)
+                    .returningAll()
+                    .executeTakeFirstOrThrow();
+                return this.parsePersona(updated);
+            }
+            const created = await trx
+                .insertInto(this.personasTable)
+                .values({
+                ...values,
+                created_at: new Date(),
+            })
                 .returningAll()
                 .executeTakeFirstOrThrow();
-            return this.parsePersona(updated);
-        }
-        const created = await this.typedDb
-            .insertInto(this.personasTable)
-            .values({
-            ...values,
-            created_at: new Date(),
-        })
-            .returningAll()
-            .executeTakeFirstOrThrow();
-        return this.parsePersona(created);
+            return this.parsePersona(created);
+        });
     }
     /**
      * Get a persona by name

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

@@ -27,6 +27,7 @@ export declare class PolicyEnforcer {
     private config;
     private policiesTable;
     private metricsTable;
+    private metricCache;
     constructor(db: Kysely<any>, config?: AgenticConfig);
     private get typedDb();
     /**
@@ -37,7 +38,11 @@ export declare class PolicyEnforcer {
      * Comprehensive policy evaluation against a context value.
      * Supports thresholds, regex patterns, and cumulative budgets.
      */
-    checkPolicy(name: string, value: any): Promise<{
+    /**
+     * Comprehensive policy evaluation against a context value.
+     * Supports thresholds, regex patterns, and cumulative budgets.
+     */
+    checkPolicy(name: string, value: any, visited?: Set<string>): Promise<{
         allowed: boolean;
         reason?: string;
     }>;