noormme 1.0.2 → 1.0.4

package/README.md

@@ -1,344 +1,109 @@
-# NOORMME - The NO-ORM for Normies
+# NOORMME: The Agentic Data Engine
 
-[![npm version](https://img.shields.io/npm/v/noormme)](https://www.npmjs.com/package/noormme)
-[![npm downloads](https://img.shields.io/npm/dm/noormme)](https://www.npmjs.com/package/noormme)
-[![License: Apache-2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
-[![TypeScript](https://img.shields.io/badge/TypeScript-5.9-blue)](https://www.typescriptlang.org/)
-[![Node.js](https://img.shields.io/badge/Node.js-%3E%3D20-green)](https://nodejs.org/)
+**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.
 
-> **"Finally, an ORM that doesn't make me feel dumb."** - Every Normie Developer Ever
+[![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)
 
-**NOORMME** (pronounced "normie") is the toolkit that makes you feel like a coding genius without actually being one. It's like having a senior developer in your pocket, but without the attitude.
-
-**The Mission**: Make AI-assisted development so easy, even your grandma could build a startup (if she wanted to).
-
-## 🤔 Why Should You Care? (Spoiler: You Should)
-
-### **The Problem (AKA Why You're Reading This):**
-You're probably here because:
-- Setting up databases makes you want to throw your laptop out the window
-- You've spent more time configuring ORMs than actually coding
-- AI tools keep suggesting code that doesn't work with your setup
-- You're tired of feeling like you need a computer science degree to build a simple app
-- Your project structure looks like a tornado hit a code factory
-
-### **The NOORMME Solution (AKA Your New Best Friend):**
-We fixed all that nonsense:
-- **Zero-config database** - Point, click, done (well, almost)
-- **AI that actually helps** - No more "helpful" suggestions that break everything
-- **Organized by default** - Your code will look like a senior dev wrote it
-- **Minimal setup** - From "I have an idea" to "I have an app" in 5 minutes
-- **No vendor lock-in** - You're not trapped in framework jail
-
-### **Real Benefits (The Stuff That Actually Matters):**
-- 🚀 **Feel like a coding wizard** - AI that understands your project
-- 💰 **Save money** - No expensive database servers to maintain
-- 🔧 **Deploy easily** - One file instead of a server farm
-- ⚡ **Go fast** - Direct file access beats network calls every time
-- 🛡️ **Stay secure** - No network = no network attacks
-- 😊 **Have fun** - Finally, coding that doesn't make you cry
-
-**Bottom line:** You get enterprise-grade superpowers with the simplicity of a single file.
-
-## 🚀 What's the Big Deal? (Spoiler: It's Actually Pretty Big)
-
-**Before NOORMME:** You spend 8 hours setting up a database, 4 hours organizing your project, and 2 hours fighting with AI tools that suggest code from 2019.
-
-**With NOORMME:** Your development environment becomes AI-ready in 5 minutes:
-- ✅ **SQLite that acts like PostgreSQL** - All the power, none of the pain
-- ✅ **Organized architecture** - Patterns that actually make sense
-- ✅ **AI context rules** - Cursor IDE integration that works
-- ✅ **Type safety** - TypeScript that doesn't make you want to throw things
-- ✅ **Production features** - WAL mode, caching, and performance optimization
-
-**It's literally a development environment that makes AI assistance useful.** 🤯
-
-## ⚡ Get Started in 60 Seconds (No, Really)
-
-### 1. Install It (The Easy Part)
-```bash
-npm install noormme
-```
-
-### 2. Initialize Your Project (The Even Easier Part)
-```bash
-npx noormme init
-```
-
-### 3. Point at Your Database (The "Wait, That's It?" Part)
-```typescript
-import { NOORMME } from 'noormme'
-
-const db = new NOORMME({
-  dialect: 'sqlite',
-  connection: {
-    database: './your-database.sqlite'  // Point to your existing database
-  }
-})
-
-await db.initialize()
-```
-
-### 4. Start Building with AI Assistance (The "I'm a Genius Now" Part)
-```typescript
-// NOORMME automatically finds your 'users' table and creates methods
-const userRepo = db.getRepository('users')
-
-// These methods are automatically available based on your table columns:
-const users = await userRepo.findAll()
-const user = await userRepo.findByEmail('john@example.com')
-const activeUsers = await userRepo.findManyByStatus('active')
-
-// Full CRUD with type safety (because we're not animals)
-const newUser = await userRepo.create({
-  name: 'Jane Doe',
-  email: 'jane@example.com'
-})
-```
-
-**That's it!** Your development environment is now AI-ready and organized. 🎉
-
-## 🎯 What NOORMME Does For You (The Magic Behind the Curtain)
-
-### 🔍 **Database Automation (AKA "How Did It Know That?")**
-NOORMME looks at your SQLite database and goes "Oh, I see what you're trying to do here":
-- **Auto-discovery** - Finds tables, columns, and relationships (like a detective, but for databases)
-- **Type generation** - Creates TypeScript interfaces (because guessing types is for amateurs)
-- **Performance optimization** - WAL mode, caching, and index recommendations (because slow is the enemy)
-- **Health monitoring** - Real-time performance tracking (because knowing is half the battle)
-
-### 🏗️ **Organized Architecture (AKA "Finally, Code That Makes Sense")**
-NOORMME applies patterns from frameworks that actually work:
-- **Django-style structure** - Organized folders and clear separation (because chaos is not a feature)
-- **Laravel-style services** - Service classes and repository patterns (because organization is beautiful)
-- **Rails-style conventions** - Naming conventions and file organization (because consistency is key)
-- **Next.js patterns** - App Router, Server Components, and modern React patterns (because we live in 2025)
-
-### 🤖 **AI-Ready Development (AKA "Finally, AI That Actually Helps")**
-NOORMME makes AI assistance useful (revolutionary, we know):
-- **Cursor IDE integration** - Context rules that AI tools understand (because context matters)
-- **Consistent patterns** - AI generates code that follows your conventions (because consistency is everything)
-- **Type safety** - AI suggestions are always type-safe (because runtime errors are for the weak)
-- **Documentation** - AI understands your project structure (because understanding is power)
-
-### ⚡ **Performance Optimization (AKA "Speed Is Life")**
-NOORMME automatically makes everything faster:
-- **WAL mode** - Concurrent read/write operations (because waiting is for losers)
-- **Intelligent caching** - Cache frequently accessed data (because memory is cheap, time is not)
-- **Query optimization** - Automatic index recommendations (because slow queries are the enemy)
-- **Real-time monitoring** - Performance metrics and health checks (because ignorance is not bliss)
-
-## 🔥 WAL Mode: Why This Changes Everything (The Technical Stuff Made Simple)
-
-**The Problem:** Most SQLite databases are slow and lock up when multiple people try to use them. It's like having a single-lane road for a busy intersection during rush hour.
-
-**The NOORMME Solution:** WAL Mode (Write-Ahead Logging) turns your SQLite file into a multi-lane highway with express lanes.
-
-### **What WAL Mode Actually Does (In Plain English):**
+---
 
-**Before WAL Mode (The Dark Ages):**
-- When someone writes to the database, EVERYONE has to wait
-- Reading data blocks writing data (and vice versa)
-- Your app freezes when multiple users try to do things at once
-- It's like having one checkout lane at Walmart on Black Friday
+## 🏗 The Agentic Data Loop
 
-**With NOORMME's WAL Mode (The Renaissance):**
-- ✅ **Multiple readers can access data simultaneously** - No more waiting in line
-- ✅ **Writers don't block readers** - Updates happen in the background
-- ✅ **3x faster write operations** - Append-only logging is lightning fast
-- ✅ **Better crash recovery** - Your data is safer than Fort Knox
-- ✅ **Real production performance** - Handles thousands of concurrent users
+NOORMME implements a closed-loop system where data is not merely "stored" but continuously distilled, questioned, and evolved.
 
-### **Real-World Proof (Because We Don't Make Stuff Up):**
-NOORMME's WAL Mode is already running in production at **DreamBeesArt**, where it:
-- Handles multiple users creating and editing content simultaneously
-- Processes orders and inventory updates without blocking customer browsing
-- Maintains sub-second response times even under heavy load
-- Provides enterprise-level reliability in a simple SQLite file
+### 🧠 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.
 
-### **The Magic Behind the Scenes (The Technical Wizardry):**
-Instead of one database file, WAL Mode creates three files:
-- `your-database.db` - Your actual data (the main file)
-- `your-database.db-wal` - Pending changes (like a shopping cart)
-- `your-database.db-shm` - Coordination between processes (like traffic lights)
+---
 
-**Don't worry** - NOORMME handles all three files automatically. You just see your database working like a high-performance server.
+## 💎 Technical Moats
 
-### **Why You Should Care (The Bottom Line):**
-- 🚀 **Your app won't freeze** when multiple users are active
-- 💰 **Save money** - No need for expensive database servers
-- 🔧 **Easier deployment** - Copy one file instead of managing servers
-- ⚡ **Better user experience** - Everything feels snappy and responsive
-- 🛡️ **More reliable** - Your data is safer with better crash recovery
+### 🧬 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.
 
-**Bottom line:** Your SQLite file becomes as powerful as PostgreSQL, but without the complexity.
+### 🚥 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.
 
-## 🛠️ CLI Tools (For When You Want to Feel Like a Pro)
+### 📊 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**.
 
-NOORMME includes command-line tools that make development stupidly simple:
+---
 
-### Analyze Your Database (The "What's Wrong?" Tool)
-```bash
-# See what's slow and get recommendations
-npx noormme analyze --database ./app.sqlite
-```
+## ⚡ Performance Engineering
 
-### Optimize Performance (The "Make It Faster" Tool)
-```bash
-# Make your database faster automatically
-npx noormme optimize --database ./app.sqlite
-```
+### 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.
 
-### Watch and Auto-Optimize (The "Set It and Forget It" Tool)
-```bash
-# Set it and forget it - NOORMME watches your database
-npx noormme watch --auto-optimize
-```
+### 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.
 
-### Generate Project Structure (The "I'm Too Lazy" Tool)
-```bash
-# Create organized Next.js project with NOORMME
-npx noormme create --template nextjs --name my-app
-```
+---
 
-## 💡 Real Examples (Because Examples Are Everything)
+## 🚀 Implementation
 
-### Blog App with AI Assistance (The "I Want to Build a Blog" Example)
+### Initializing the Mind
 ```typescript
-const db = new NOORMME({
-  dialect: 'sqlite',
-  connection: { database: './blog.sqlite' }
-})
-
-await db.initialize()
-
-// Auto-generated repositories (because we're not writing boilerplate)
-const postRepo = db.getRepository('posts')
-const userRepo = db.getRepository('users')
+import { NOORMME } from 'noormme';
 
-// Smart methods based on your schema (because we're smart like that)
-const recentPosts = await postRepo.findManyByPublished(true)
-const adminUsers = await userRepo.findManyByRole('admin')
-
-// Complex queries with full type safety (because we're not animals)
-const postWithAuthor = await db.getKysely()
-  .selectFrom('posts')
-  .innerJoin('users', 'users.id', 'posts.author_id')
-  .select(['posts.title', 'users.name as author'])
-  .where('posts.published', '=', true)
-  .execute()
-```
-
-### E-commerce App with Organized Architecture (The "I Want to Make Money" Example)
-```typescript
-// Point at your existing e-commerce database
 const db = new NOORMME({
   dialect: 'sqlite',
-  connection: { database: './shop.sqlite' }
-})
-
-await db.initialize()
-
-const productRepo = db.getRepository('products')
-const orderRepo = db.getRepository('orders')
+  connection: { database: './mind.sqlite' },
+  agentic: {
+    enableSelfEvolution: true,
+    enableSelfHealing: true
+  }
+});
 
-// Auto-generated methods work with your existing data (because we're not picky)
-const featuredProducts = await productRepo.findManyByFeatured(true)
-const pendingOrders = await orderRepo.findManyByStatus('pending')
+// Provisions 20+ tables for goals, knowledge, episodes, and logic probes
+await db.initialize();
 ```
 
-## 🔧 Configuration (Optional, Because We're Not Dictators)
-
-For most people, the default settings work perfectly. But if you want to customize (because you're a special snowflake):
-
+### Strategic Interaction
 ```typescript
-const db = new NOORMME({
-  dialect: 'sqlite',
-  connection: {
-    database: './app.sqlite'
-  },
-  automation: {
-    enableAutoOptimization: true,     // Make it fast automatically
-    enableIndexRecommendations: true, // Suggest better indexes
-    enableQueryAnalysis: true,        // Find slow queries
-  },
-  performance: {
-    enableCaching: true,              // Cache results for speed
-    maxCacheSize: 1000               // How much to cache
-  }
-})
-```
-
-## 🚀 Production Ready (Because We're Not Playing Around)
-
-NOORMME is already running in production applications with real-world success stories. It includes:
-
-- **Health monitoring** - Know when something's wrong (because ignorance is not bliss)
-- **Performance metrics** - See how fast your queries are (because speed is life)
-- **Security features** - Protection against common attacks (because security matters)
-- **Migration support** - Move from PostgreSQL to SQLite easily (because change is good)
-- **Backup strategies** - Your data is safe (because data loss is not fun)
-- **WAL Mode implementation** - Proven in production at DreamBeesArt with enterprise-level performance
-
-### **Real Production Success (Because We Don't Make Stuff Up):**
-The DreamBeesArt application successfully migrated from Drizzle ORM to NOORMME with WAL Mode, achieving:
-- **Better concurrent access** - Multiple users can create/edit content simultaneously
-- **Improved write performance** - 3x faster operations with append-only logging
-- **Enhanced reliability** - Better crash recovery and data integrity
-- **Reduced complexity** - From complex database server setup to a single SQLite file
-- **Lower costs** - No database hosting fees while maintaining enterprise performance
-
-## ❓ FAQ for Normies (The Questions You're Too Afraid to Ask)
-
-**Q: Do I need to learn SQL?**
-A: Nope! NOORMME handles most things automatically. You only need SQL for complex queries (and even then, we'll help you).
-
-**Q: Can I use my existing database?**
-A: Yes! Just point NOORMME at your existing SQLite file and it figures everything out (because we're not picky).
+// Access the higher-order cognitive facade
+const cortex = db.agent.cortex;
 
-**Q: Is this really production-ready?**
-A: Absolutely. Real applications are using it right now with better performance than PostgreSQL (because we're not lying).
+// Execute a background knowledge distillation ritual
+await cortex.rituals.runPendingRituals();
 
-**Q: What if I'm already using another ORM?**
-A: NOORMME works alongside other tools. You can migrate gradually or use both (because we're not territorial).
-
-**Q: Do I need TypeScript?**
-A: NOORMME works with JavaScript too, but TypeScript gives you the best experience (because types are your friends).
-
-**Q: How does this work with AI tools like Cursor?**
-A: NOORMME includes Cursor IDE context rules that make AI assistance actually useful. The AI understands your project structure and generates code that follows your conventions (because we're not savages).
-
-**Q: What makes this different from other toolkits?**
-A: NOORMME combines database automation, organized architecture, and AI-ready patterns in one integrated toolkit. It's not just an ORM - it's a complete development environment (because we're ambitious).
-
-**Q: Will this make me a better developer?**
-A: Probably not, but it will make you feel like one (which is half the battle).
-
-## 🤝 Contributing (Because We're Not Perfect)
-
-Found a bug? Have an idea? We'd love your help! (Because we're not too proud to ask for help)
-
-```bash
-git clone https://github.com/cardsorting/noormme.git
-cd noormme
-npm install
-npm test
+// Challenge existing knowledge with new evidence
+await cortex.knowledge.challengeKnowledge('SystemArchitecture', 'New facts contradict old.', 0.95);
 ```
 
-## 📄 License (The Legal Stuff)
+---
 
-Apache 2.0 License - see [LICENSE](LICENSE) file for details. (Because we're not lawyers, but we try to be responsible)
+## 🗄 Dialect Matrix
 
-## 🎉 Start Today (Because Tomorrow Is Overrated)
+| 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 |
 
-Ready to make your development environment work for you instead of against you?
+---
 
-```bash
-npm install noormme
-```
+## 🤝 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.
 
-**Because AI-assisted development should be normal, not rocket science.** 🚀
+[Contribution Guide](CONTRIBUTING.md) | [Security Audit](SECURITY.md)
 
 ---
 
-*NOORMME - Making AI-assisted development so simple, even normies can use it.*
+*Transforming passive records into sovereign intelligence.*

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

@@ -0,0 +1,55 @@
+import type { Kysely } from '../kysely.js';
+import type { AgenticConfig, AgentAction } from '../types/index.js';
+import type { TelemetryOrchestrator } from './telemetry/TelemetryOrchestrator.js';
+export interface ActionTable {
+    id: number | string;
+    session_id: number | string;
+    message_id: number | string | null;
+    tool_name: string;
+    arguments: string;
+    outcome: string | null;
+    status: 'success' | 'failure' | 'pending';
+    duration_ms: number | null;
+    metadata: string | null;
+    created_at: string | Date;
+}
+export interface ActionDatabase {
+    agent_actions: ActionTable;
+}
+/**
+ * ActionJournal records tool usage and outcomes to help agents learn
+ * from their past actions.
+ */
+export declare class ActionJournal {
+    private db;
+    private config;
+    private telemetry?;
+    private actionsTable;
+    constructor(db: Kysely<any>, config?: AgenticConfig, telemetry?: TelemetryOrchestrator | undefined);
+    private get typedDb();
+    /**
+     * Log an action (tool call)
+     */
+    logAction(sessionId: string | number, toolName: string, args: Record<string, any>, messageId?: string | number): Promise<AgentAction>;
+    /**
+     * Update action with outcome
+     */
+    recordOutcome(actionId: string | number, status: AgentAction['status'], outcome: string, durationMs?: number, metadata?: Record<string, any>): Promise<AgentAction>;
+    /**
+     * Get actions for a session
+     */
+    getSessionActions(sessionId: string | number): Promise<AgentAction[]>;
+    /**
+     * Get actions by tool name across all sessions.
+     */
+    getActionsByTool(toolName: string, limit?: number): Promise<AgentAction[]>;
+    /**
+     * Generate a report of tool failures.
+     */
+    getFailureReport(): Promise<{
+        toolName: string;
+        failureCount: number;
+        lastFailure: string;
+    }[]>;
+    private parseAction;
+}

package/dist/cjs/agentic/ActionJournal.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionJournal = void 0;
+/**
+ * ActionJournal records tool usage and outcomes to help agents learn
+ * from their past actions.
+ */
+class ActionJournal {
+    db;
+    config;
+    telemetry;
+    actionsTable;
+    constructor(db, config = {}, telemetry) {
+        this.db = db;
+        this.config = config;
+        this.telemetry = telemetry;
+        this.actionsTable = config.actionsTable || 'agent_actions';
+    }
+    get typedDb() {
+        return this.db;
+    }
+    /**
+     * Log an action (tool call)
+     */
+    async logAction(sessionId, toolName, args, messageId) {
+        const action = await this.typedDb
+            .insertInto(this.actionsTable)
+            .values({
+            session_id: sessionId,
+            message_id: messageId || null,
+            tool_name: toolName,
+            arguments: JSON.stringify(args),
+            status: 'pending',
+            created_at: new Date()
+        })
+            .returningAll()
+            .executeTakeFirstOrThrow();
+        const parsed = this.parseAction(action);
+        // Telemetry: Track action start
+        if (this.telemetry) {
+            await this.telemetry.track(sessionId, 'action', `Tool call: ${toolName}`, { actionId: action.id, arguments: args });
+        }
+        return parsed;
+    }
+    /**
+     * Update action with outcome
+     */
+    async recordOutcome(actionId, status, outcome, durationMs, metadata) {
+        const action = await this.typedDb
+            .updateTable(this.actionsTable)
+            .set({
+            status,
+            outcome,
+            duration_ms: durationMs || null,
+            metadata: metadata ? JSON.stringify(metadata) : null
+        })
+            .where('id', '=', actionId)
+            .returningAll()
+            .executeTakeFirstOrThrow();
+        const parsed = this.parseAction(action);
+        // Telemetry: Track outcome and failures
+        if (this.telemetry) {
+            if (status === 'failure') {
+                await this.telemetry.track(parsed.sessionId, 'error', `Action failed: ${outcome}`, { actionId, status });
+            }
+        }
+        return parsed;
+    }
+    /**
+     * Get actions for a session
+     */
+    async getSessionActions(sessionId) {
+        const actions = await this.typedDb
+            .selectFrom(this.actionsTable)
+            .selectAll()
+            .where('session_id', '=', sessionId)
+            .orderBy('created_at', 'asc')
+            .execute();
+        return actions.map(a => this.parseAction(a));
+    }
+    /**
+     * Get actions by tool name across all sessions.
+     */
+    async getActionsByTool(toolName, limit = 50) {
+        const actions = await this.typedDb
+            .selectFrom(this.actionsTable)
+            .selectAll()
+            .where('tool_name', '=', toolName)
+            .orderBy('created_at', 'desc')
+            .limit(limit)
+            .execute();
+        return actions.map(a => this.parseAction(a));
+    }
+    /**
+     * Generate a report of tool failures.
+     */
+    async getFailureReport() {
+        const results = await this.typedDb
+            .selectFrom(this.actionsTable)
+            .select([
+            'tool_name',
+            (eb) => eb.fn.count('id').as('failureCount'),
+            (eb) => eb.fn.max('created_at').as('lastFailure')
+        ])
+            .where('status', '=', 'failure')
+            .groupBy('tool_name')
+            .orderBy((eb) => eb.fn.count('id'), 'desc')
+            .execute();
+        return results.map((r) => ({
+            toolName: r.tool_name,
+            failureCount: Number(r.failureCount),
+            lastFailure: r.lastFailure
+        }));
+    }
+    parseAction(action) {
+        return {
+            id: action.id,
+            sessionId: action.session_id,
+            messageId: action.message_id,
+            toolName: action.tool_name,
+            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)
+        };
+    }
+}
+exports.ActionJournal = ActionJournal;

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

@@ -0,0 +1,43 @@
+import type { Kysely } from '../kysely.js';
+import type { AgenticConfig, AgentCapability } from '../types/index.js';
+export interface CapabilityTable {
+    id: number | string;
+    name: string;
+    version: string;
+    description: string | null;
+    reliability: number;
+    metadata: string | null;
+    created_at: string | Date;
+    updated_at: string | Date;
+}
+export interface CapabilityDatabase {
+    agent_capabilities: CapabilityTable;
+}
+/**
+ * CapabilityManager tracks the skills (tools) available to an agent
+ * and their historical reliability.
+ */
+export declare class CapabilityManager {
+    private db;
+    private config;
+    private capabilitiesTable;
+    constructor(db: Kysely<any>, config?: AgenticConfig);
+    private get typedDb();
+    /**
+     * Register or update a capability (skill)
+     */
+    registerCapability(name: string, version: string, description?: string, metadata?: Record<string, any>): Promise<AgentCapability>;
+    /**
+     * Update reliability based on action outcome using a damped moving average.
+     */
+    reportOutcome(name: string, success: boolean): Promise<void>;
+    /**
+     * Get reliability score for a capability.
+     */
+    getReliability(name: string): Promise<number>;
+    /**
+     * Get all registered capabilities
+     */
+    getCapabilities(): Promise<AgentCapability[]>;
+    private parseCapability;
+}