rust-kgdb 0.6.83 → 0.6.84

package/README.archive.md

@@ -1,2632 +0,0 @@
-# rust-kgdb
-
-[![npm version](https://img.shields.io/npm/v/rust-kgdb.svg)](https://www.npmjs.com/package/rust-kgdb)
-[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
-[![W3C](https://img.shields.io/badge/W3C-SPARQL%201.1%20%7C%20RDF%201.2-blue)](https://www.w3.org/TR/sparql11-query/)
-
-> **Two-Layer Architecture**: High-performance Rust knowledge graph database + HyperMind neuro-symbolic agent framework with mathematical foundations.
-
----
-
-## The Problem
-
-We asked GPT-4 to write a simple SPARQL query: *"Find all professors."*
-
-It returned this broken output:
-
-```text
-    ```sparql
-    SELECT ?professor WHERE { ?professor a ub:Faculty . }
-    ```
-    This query retrieves faculty members from the knowledge graph.
-```
-
-Three problems: (1) markdown code fences break the parser, (2) `ub:Faculty` doesn't exist in the schema (it's `ub:Professor`), and (3) the explanation text is mixed with the query. **Result: Parser error. Zero results.**
-
-This isn't a cherry-picked failure. When we ran the standard LUBM benchmark (14 queries, 3,272 triples), vanilla LLMs produced valid, correct SPARQL **0% of the time**.
-
-We built rust-kgdb to fix this.
-
----
-
-## Architecture: What Powers rust-kgdb
-
-```
-┌─────────────────────────────────────────────────────────────────────────────────┐
-│                           YOUR APPLICATION                                       │
-│                 (Fraud Detection, Underwriting, Compliance)                      │
-└────────────────────────────────────┬────────────────────────────────────────────┘
-                                     │
-┌────────────────────────────────────▼────────────────────────────────────────────┐
-│                    HYPERMIND AGENT FRAMEWORK (SDK Layer)                         │
-│  ┌────────────────────────────────────────────────────────────────────────────┐ │
-│  │  Mathematical Abstractions (High-Level)                                     │ │
-│  │  • TypeId: Hindley-Milner type system with refinement types                │ │
-│  │  • LLMPlanner: Natural language → typed tool pipelines                     │ │
-│  │  • WasmSandbox: WASM isolation with capability-based security             │ │
-│  │  • AgentBuilder: Fluent composition of typed tools                         │ │
-│  │  • ExecutionWitness: Cryptographic proofs (SHA-256)                        │ │
-│  └────────────────────────────────────────────────────────────────────────────┘ │
-│                                     │                                            │
-│                    Category Theory: Tools as Morphisms (A → B)                   │
-│                    Proof Theory: Every execution has a witness                   │
-└────────────────────────────────────┬────────────────────────────────────────────┘
-                                     │ NAPI-RS Bindings
-┌────────────────────────────────────▼────────────────────────────────────────────┐
-│                    RUST CORE ENGINE (Native Performance)                         │
-│  ┌────────────────────────────────────────────────────────────────────────────┐ │
-│  │  GraphDB          │ RDF/SPARQL quad store   │ 2.78µs lookups, 24 bytes/triple│
-│  │  GraphFrame       │ Graph algorithms        │ WCOJ optimal joins, PageRank  │
-│  │  EmbeddingService │ Vector similarity       │ HNSW index, 1-hop ARCADE cache│
-│  │  DatalogProgram   │ Rule-based reasoning    │ Semi-naive evaluation         │
-│  │  Pregel           │ BSP graph processing    │ Iterative algorithms          │
-│  └────────────────────────────────────────────────────────────────────────────┘ │
-│                                                                                  │
-│  W3C Standards: SPARQL 1.1 (100%) | RDF 1.2 | OWL 2 RL | SHACL | RDFS          │
-│  Storage Backends: InMemory | RocksDB | LMDB                                     │
-│  Distribution: HDRF Partitioning | Raft Consensus | gRPC                         │
-└──────────────────────────────────────────────────────────────────────────────────┘
-```
-
-**Key Insight**: The Rust core provides raw performance (2.78µs lookups). The HyperMind framework adds mathematical guarantees (type safety, composition laws, proof generation) without sacrificing speed.
-
-### What's Rust Core vs SDK Layer?
-
-All major capabilities are implemented in **Rust** via the HyperMind SDK crates (`hypermind-types`, `hypermind-runtime`, `hypermind-sdk`). The JavaScript/TypeScript layer is a thin binding that exposes these Rust capabilities for Node.js applications.
-
-| Component | Implementation | Performance | Notes |
-|-----------|---------------|-------------|-------|
-| **GraphDB** | Rust via NAPI-RS | 2.78µs lookups | Zero-copy RDF quad store |
-| **GraphFrame** | Rust via NAPI-RS | WCOJ optimal | PageRank, triangles, components |
-| **EmbeddingService** | Rust via NAPI-RS | Sub-ms search | HNSW index + 1-hop cache |
-| **DatalogProgram** | Rust via NAPI-RS | Semi-naive eval | Rule-based reasoning |
-| **Pregel** | Rust via NAPI-RS | BSP model | Iterative graph algorithms |
-| **TypeId** | Rust via NAPI-RS | N/A | Hindley-Milner type system |
-| **LLMPlanner** | JavaScript + HTTP | LLM latency | Orchestrates Rust tools via Claude/GPT |
-| **WasmSandbox** | Rust via NAPI-RS | Capability check | WASM isolation runtime |
-| **AgentBuilder** | Rust via NAPI-RS | N/A | Fluent tool composition |
-| **ExecutionWitness** | Rust via NAPI-RS | SHA-256 | Cryptographic audit proofs |
-
-**Security Model**: All interactions with Rust components flow through NAPI-RS bindings with memory isolation. The WasmSandbox wraps these bindings with capability-based access control, ensuring agents can only invoke tools they're explicitly granted. This provides defense-in-depth: NAPI-RS for memory safety, WasmSandbox for capability control.
-
----
-
-## The Solution
-
-rust-kgdb is a knowledge graph database with a neuro-symbolic agent framework called **HyperMind**. Instead of hoping the LLM gets the syntax right, we use mathematical type theory to *guarantee* correctness.
-
-The same query through HyperMind:
-
-```sparql
-PREFIX ub: <http://swat.cse.lehigh.edu/onto/univ-bench.owl#>
-SELECT ?professor WHERE { ?professor a ub:Professor . }
-```
-
-**Result: 15 professors returned in 2.3ms.**
-
-The difference? HyperMind treats tools as **typed morphisms** (category theory), validates queries at **compile-time** (type theory), and produces **cryptographic witnesses** for every execution (proof theory). The LLM plans; the math executes.
-
-**Accuracy improvement: 0% → 86.4%** on the LUBM benchmark.
-
----
-
-## The Deeper Problem: AI Agents Forget
-
-Fixing SPARQL syntax is table stakes. Here's what keeps enterprise architects up at night:
-
-**Scenario**: Your fraud detection agent correctly identified a circular payment ring last Tuesday. Today, an analyst asks: *"Show me similar patterns to what we found last week."*
-
-The LLM response: *"I don't have access to previous conversations. Can you describe what you're looking for?"*
-
-**The agent forgot everything.**
-
-Every enterprise AI deployment hits the same wall:
-- **No Memory**: Each session starts from zero - expensive recomputation, no learning
-- **No Context Window Management**: Hit token limits? Lose critical history
-- **No Idempotent Responses**: Same question, different answer - compliance nightmare
-- **No Provenance Chain**: "Why did the agent flag this claim?" - silence
-
-LangChain's solution: Vector databases. Store conversations, retrieve via similarity.
-
-**The problem**: Similarity isn't memory. When your underwriter asks *"What did we decide about claims from Provider X?"*, you need:
-1. **Temporal awareness** - What we decided *last month* vs *yesterday*
-2. **Semantic edges** - The decision *relates to* these specific claims
-3. **Epistemological stratification** - Fact vs inference vs hypothesis
-4. **Proof chain** - *Why* we decided this, not just *that* we did
-
-This requires a **Memory Hypergraph** - not a vector store.
-
----
-
-## Memory Hypergraph: How AI Agents Remember
-
-rust-kgdb introduces the **Memory Hypergraph** - a temporal knowledge graph where agent memory is stored in the *same* quad store as your domain knowledge, with hyper-edges connecting episodes to KG entities.
-
-```
-┌─────────────────────────────────────────────────────────────────────────────────┐
-│                         MEMORY HYPERGRAPH ARCHITECTURE                           │
-│                                                                                  │
-│   ┌─────────────────────────────────────────────────────────────────────────┐   │
-│   │                    AGENT MEMORY LAYER (am: graph)                        │   │
-│   │                                                                          │   │
-│   │   Episode:001                Episode:002                Episode:003      │   │
-│   │   ┌───────────────┐         ┌───────────────┐         ┌───────────────┐ │   │
-│   │   │ Fraud ring    │         │ Underwriting  │         │ Follow-up     │ │   │
-│   │   │ detected in   │         │ denied claim  │         │ investigation │ │   │
-│   │   │ Provider P001 │         │ from P001     │         │ on P001       │ │   │
-│   │   │               │         │               │         │               │ │   │
-│   │   │ Dec 10, 14:30 │         │ Dec 12, 09:15 │         │ Dec 15, 11:00 │ │   │
-│   │   │ Score: 0.95   │         │ Score: 0.87   │         │ Score: 0.92   │ │   │
-│   │   └───────┬───────┘         └───────┬───────┘         └───────┬───────┘ │   │
-│   │           │                         │                         │         │   │
-│   └───────────┼─────────────────────────┼─────────────────────────┼─────────┘   │
-│               │ HyperEdge:              │ HyperEdge:              │             │
-│               │ "QueriedKG"             │ "DeniedClaim"           │             │
-│               ▼                         ▼                         ▼             │
-│   ┌─────────────────────────────────────────────────────────────────────────┐   │
-│   │                    KNOWLEDGE GRAPH LAYER (domain graph)                  │   │
-│   │                                                                          │   │
-│   │      Provider:P001 ──────────────▶ Claim:C123 ◀────────── Claimant:C001 │   │
-│   │           │                            │                        │        │   │
-│   │           │ :hasRiskScore              │ :amount                │ :name  │   │
-│   │           ▼                            ▼                        ▼        │   │
-│   │        "0.87"                       "50000"                 "John Doe"   │   │
-│   │                                                                          │   │
-│   │      ┌─────────────────────────────────────────────────────────────┐    │   │
-│   │      │  SAME QUAD STORE - Single SPARQL query traverses BOTH       │    │   │
-│   │      │  memory graph AND knowledge graph!                          │    │   │
-│   │      └─────────────────────────────────────────────────────────────┘    │   │
-│   │                                                                          │   │
-│   └─────────────────────────────────────────────────────────────────────────┘   │
-│                                                                                  │
-│   ┌─────────────────────────────────────────────────────────────────────────┐   │
-│   │                         TEMPORAL SCORING FORMULA                         │   │
-│   │                                                                          │   │
-│   │   Score = α × Recency + β × Relevance + γ × Importance                   │   │
-│   │                                                                          │   │
-│   │   where:                                                                 │   │
-│   │     Recency    = 0.995^hours (12% decay/day)                            │   │
-│   │     Relevance  = cosine_similarity(query, episode)                      │   │
-│   │     Importance = log10(access_count + 1) / log10(max + 1)               │   │
-│   │                                                                          │   │
-│   │   Default: α=0.3, β=0.5, γ=0.2                                          │   │
-│   └─────────────────────────────────────────────────────────────────────────┘   │
-│                                                                                  │
-└─────────────────────────────────────────────────────────────────────────────────┘
-```
-
-### Why This Matters for Enterprise AI
-
-**Without Memory Hypergraph** (LangChain, LlamaIndex):
-```javascript
-// Ask about last week's findings
-agent.chat("What fraud patterns did we find with Provider P001?")
-// Response: "I don't have that information. Could you describe what you're looking for?"
-// Cost: Re-run entire fraud detection pipeline ($5 in API calls, 30 seconds)
-```
-
-**With Memory Hypergraph** (rust-kgdb HyperMind Framework):
-```javascript
-// HyperMind API: Recall memories with KG context (typed, not raw SPARQL)
-const enrichedMemories = await agent.recallWithKG({
-  query: "Provider P001 fraud",
-  kgFilter: { predicate: ":amount", operator: ">", value: 25000 },
-  limit: 10
-})
-
-// Returns typed results:
-// {
-//   episode: "Episode:001",
-//   finding: "Fraud ring detected in Provider P001",
-//   kgContext: {
-//     provider: "Provider:P001",
-//     claims: [{ id: "Claim:C123", amount: 50000 }],
-//     riskScore: 0.87
-//   },
-//   semanticHash: "semhash:fraud-provider-p001-ring-detection"
-// }
-
-// Framework generates optimized SPARQL internally:
-// - Joins memory graph with KG automatically
-// - Applies semantic hashing for deduplication
-// - Returns typed objects, not raw bindings
-```
-
-**Under the hood**, HyperMind generates the SPARQL:
-```sparql
-PREFIX am: <https://gonnect.ai/ontology/agent-memory#>
-PREFIX : <http://insurance.org/>
-
-SELECT ?episode ?finding ?claimAmount WHERE {
-  GRAPH <https://gonnect.ai/memory/> {
-    ?episode a am:Episode ; am:prompt ?finding .
-    ?edge am:source ?episode ; am:target ?provider .
-  }
-  ?claim :provider ?provider ; :amount ?claimAmount .
-  FILTER(?claimAmount > 25000)
-}
-```
-*You never write this - the typed API builds it for you.*
-
-### Rolling Context Window
-
-Token limits are real. rust-kgdb uses a **rolling time window strategy** to find the right context:
-
-```
-┌─────────────────────────────────────────────────────────────────────────────────┐
-│                         ROLLING CONTEXT WINDOW                                   │
-│                                                                                  │
-│   Query: "What did we find about Provider P001?"                                │
-│                                                                                  │
-│   Pass 1: Search last 1 hour      → 0 episodes found → expand                   │
-│   Pass 2: Search last 24 hours    → 1 episode found (not enough) → expand       │
-│   Pass 3: Search last 7 days      → 3 episodes found → within token budget ✓    │
-│                                                                                  │
-│   Context returned:                                                              │
-│   ┌──────────────────────────────────────────────────────────────────────────┐  │
-│   │  Episode 003 (Dec 15): "Follow-up investigation on P001..."              │  │
-│   │  Episode 002 (Dec 12): "Underwriting denied claim from P001..."          │  │
-│   │  Episode 001 (Dec 10): "Fraud ring detected in Provider P001..."         │  │
-│   │                                                                          │  │
-│   │  Estimated tokens: 847 / 8192 max                                        │  │
-│   │  Time window: 7 days                                                     │  │
-│   │  Search passes: 3                                                        │  │
-│   └──────────────────────────────────────────────────────────────────────────┘  │
-│                                                                                  │
-└─────────────────────────────────────────────────────────────────────────────────┘
-```
-
-### Idempotent Responses via Semantic Hashing
-
-Same question = Same answer. Even with **different wording**. Critical for compliance.
-
-```javascript
-// First call: Compute answer, cache with semantic hash
-const result1 = await agent.call("Analyze claims from Provider P001")
-// Semantic Hash: semhash:fraud-provider-p001-claims-analysis
-
-// Second call (different wording, same intent): Cache HIT!
-const result2 = await agent.call("Show me P001's claim patterns")
-// Cache HIT - same semantic hash: semhash:fraud-provider-p001-claims-analysis
-
-// Third call (exact same): Also cache hit
-const result3 = await agent.call("Analyze claims from Provider P001")
-// Cache HIT - same semantic hash: semhash:fraud-provider-p001-claims-analysis
-
-// Compliance officer: "Why are these identical?"
-// You: "Semantic hashing - same meaning, same output, regardless of phrasing."
-```
-
-**How it works**: Query embeddings are hashed via **Locality-Sensitive Hashing (LSH)** with random hyperplane projections. Semantically similar queries map to the same bucket.
-
-**Research Foundation**:
-- **SimHash** (Charikar, 2002) - Random hyperplane projections for cosine similarity
-- **Semantic Hashing** (Salakhutdinov & Hinton, 2009) - Deep autoencoders for binary codes
-- **Learning to Hash** (Wang et al., 2018) - Survey of neural hashing methods
-
-**Implementation**: 384-dim embeddings → LSH with 64 hyperplanes → 64-bit semantic hash
-
-**Benefits**:
-- **Semantic deduplication** - "Find fraud" and "Detect fraudulent activity" hit same cache
-- **Cost reduction** - Avoid redundant LLM calls for paraphrased questions
-- **Consistency** - Same answer for same intent, audit-ready
-- **Sub-linear lookup** - O(1) hash lookup vs O(n) embedding comparison
-
----
-
-## What This Is
-
-**World's first mobile-native knowledge graph database with clustered distribution and mathematically-grounded HyperMind agent framework.**
-
-Most graph databases were designed for servers. Most AI agents are built on prompt engineering and hope. We built both from the ground up - the database for performance, the agent framework for correctness:
-
-1. **Mobile-First**: Runs natively on iOS and Android with zero-copy FFI
-2. **Standalone + Clustered**: Same codebase scales from smartphone to Kubernetes
-3. **Open Standards**: W3C SPARQL 1.1, RDF 1.2, OWL 2 RL, SHACL - no vendor lock-in
-4. **Mathematical Foundations**: Type theory, category theory, proof theory - not prompt engineering
-5. **Worst-Case Optimal Joins**: WCOJ algorithm guarantees O(N^(ρ/2)) complexity
-
----
-
-## Published Benchmarks
-
-We don't make claims we can't prove. All measurements use **publicly available, peer-reviewed benchmarks**.
-
-**Public Benchmarks Used:**
-- **LUBM** (Lehigh University Benchmark) - Standard RDF/SPARQL benchmark since 2005
-- **SP2Bench** - DBLP-based SPARQL performance benchmark
-- **W3C SPARQL 1.1 Conformance Suite** - Official W3C test cases
-
-| Metric | Value | Why It Matters |
-|--------|-------|----------------|
-| **Lookup Latency** | 2.78 µs | 35x faster than RDFox |
-| **Memory per Triple** | 24 bytes | 25% more efficient than RDFox |
-| **Bulk Insert** | 146K triples/sec | Production-ready throughput |
-| **SPARQL Accuracy** | 86.4% | vs 0% vanilla LLM (LUBM benchmark) |
-| **W3C Compliance** | 100% | Full SPARQL 1.1 + RDF 1.2 |
-
-### How We Measured
-
-- **Dataset**: LUBM benchmark (industry standard since 2005)
-- **Hardware**: Apple Silicon M2 MacBook Pro
-- **Methodology**: 10,000+ iterations, cold-start, statistical analysis
-- **Comparison**: Apache Jena 4.x, RDFox 7.x under identical conditions
-
-**Try it yourself:**
-```bash
-node hypermind-benchmark.js  # Compare HyperMind vs Vanilla LLM accuracy
-```
-
----
-
-## Why Embeddings? The Rise of Neuro-Symbolic AI
-
-### The Problem with Pure Symbolic Systems
-
-Traditional knowledge graphs are powerful for **structured reasoning**:
-
-```sparql
-SELECT ?fraud WHERE {
-  ?claim :amount ?amt .
-  FILTER(?amt > 50000)
-  ?claim :provider ?prov .
-  ?prov :flaggedCount ?flags .
-  FILTER(?flags > 3)
-}
-```
-
-But they fail at **semantic similarity**: "Find claims similar to this suspicious one" requires understanding meaning, not just matching predicates.
-
-### The Problem with Pure Neural Systems
-
-LLMs and embedding models excel at **semantic understanding**:
-
-```javascript
-// Find semantically similar claims
-const similar = embeddings.findSimilar('CLM001', 10, 0.85)
-```
-
-But they hallucinate, have no audit trail, and can't explain their reasoning.
-
-### The Neuro-Symbolic Solution
-
-**rust-kgdb combines both**: Use embeddings for semantic discovery, symbolic reasoning for provable conclusions.
-
-```
-┌─────────────────────────────────────────────────────────────────────────┐
-│                    NEURO-SYMBOLIC PIPELINE                               │
-│                                                                          │
-│   ┌──────────────┐      ┌──────────────┐      ┌──────────────┐         │
-│   │   NEURAL     │      │   SYMBOLIC   │      │   NEURAL     │         │
-│   │  (Discovery) │ ───▶ │  (Reasoning) │ ───▶ │  (Explain)   │         │
-│   └──────────────┘      └──────────────┘      └──────────────┘         │
-│                                                                          │
-│   "Find similar"        "Apply rules"         "Summarize for           │
-│   Embeddings search     Datalog inference     human consumption"       │
-│   HNSW index            Semi-naive eval       LLM generation           │
-│   Sub-ms latency        Deterministic         Cryptographic proof      │
-└─────────────────────────────────────────────────────────────────────────┘
-```
-
-### Why 1-Hop Embeddings Matter
-
-The ARCADE (Adaptive Relation-Aware Cache for Dynamic Embeddings) algorithm provides **1-hop neighbor awareness**:
-
-```javascript
-const service = new EmbeddingService()
-
-// Build neighbor cache from triples
-service.onTripleInsert('CLM001', 'claimant', 'P001', null)
-service.onTripleInsert('P001', 'knows', 'P002', null)
-
-// 1-hop aware similarity: finds entities connected in the graph
-const neighbors = service.getNeighborsOut('P001')  // ['P002']
-
-// Combine structural + semantic similarity
-// "Find similar claims that are also connected to this claimant"
-```
-
-**Why it matters**: Pure embedding similarity finds semantically similar entities. 1-hop awareness finds entities that are both similar AND structurally connected - critical for fraud ring detection where relationships matter as much as content.
-
----
-
-## Embedding Service: Multi-Provider Vector Search
-
-### Provider Abstraction
-
-The EmbeddingService supports multiple embedding providers with a unified API:
-
-```javascript
-const { EmbeddingService } = require('rust-kgdb')
-
-// Initialize service (uses built-in 384-dim embeddings by default)
-const service = new EmbeddingService()
-
-// Store embeddings from any provider
-service.storeVector('entity1', openaiEmbedding)    // 384-dim
-service.storeVector('entity2', anthropicEmbedding) // 384-dim
-service.storeVector('entity3', cohereEmbedding)    // 384-dim
-
-// HNSW similarity search (Rust-native, sub-ms)
-service.rebuildIndex()
-const similar = JSON.parse(service.findSimilar('entity1', 10, 0.7))
-```
-
-### Composite Multi-Provider Embeddings
-
-For production deployments, combine multiple providers for robustness:
-
-```javascript
-// Store embeddings from multiple providers for the same entity
-service.storeComposite('CLM001', JSON.stringify({
-  openai: await openai.embed('Insurance claim for soft tissue injury'),
-  voyage: await voyage.embed('Insurance claim for soft tissue injury'),
-  cohere: await cohere.embed('Insurance claim for soft tissue injury')
-}))
-
-// Search with aggregation strategies
-const rrfResults = service.findSimilarComposite('CLM001', 10, 0.7, 'rrf')    // Reciprocal Rank Fusion
-const maxResults = service.findSimilarComposite('CLM001', 10, 0.7, 'max')    // Max score
-const voteResults = service.findSimilarComposite('CLM001', 10, 0.7, 'voting') // Majority voting
-```
-
-### Provider Configuration
-
-rust-kgdb's `EmbeddingService` stores and searches vectors - you bring your own embeddings from any provider. Here are examples using popular third-party libraries:
-
-```javascript
-// ============================================================
-// EXAMPLE: Using OpenAI embeddings (requires: npm install openai)
-// ============================================================
-const { OpenAI } = require('openai')  // Third-party library
-const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY })
-
-async function getOpenAIEmbedding(text) {
-  const response = await openai.embeddings.create({
-    model: 'text-embedding-3-small',
-    input: text,
-    dimensions: 384  // Match rust-kgdb's 384-dim format
-  })
-  return response.data[0].embedding
-}
-
-// ============================================================
-// EXAMPLE: Using Voyage AI (requires: npm install voyageai)
-// Note: Anthropic recommends Voyage AI for embeddings
-// ============================================================
-async function getVoyageEmbedding(text) {
-  // Using fetch directly (no SDK required)
-  const response = await fetch('https://api.voyageai.com/v1/embeddings', {
-    method: 'POST',
-    headers: {
-      'Authorization': `Bearer ${process.env.VOYAGE_API_KEY}`,
-      'Content-Type': 'application/json'
-    },
-    body: JSON.stringify({ input: text, model: 'voyage-2' })
-  })
-  const data = await response.json()
-  return data.data[0].embedding.slice(0, 384)  // Truncate to 384-dim
-}
-
-// ============================================================
-// EXAMPLE: Mock embeddings for testing (no external deps)
-// ============================================================
-function getMockEmbedding(text) {
-  return new Array(384).fill(0).map((_, i) =>
-    Math.sin(text.charCodeAt(i % text.length) * 0.1) * 0.5 + 0.5
-  )
-}
-```
-
----
-
-## Graph Ingestion Pipeline with Embedding Triggers
-
-### Automatic Embedding on Triple Insert
-
-Configure your pipeline to automatically generate embeddings when triples are inserted:
-
-```javascript
-const { GraphDB, EmbeddingService } = require('rust-kgdb')
-
-// Initialize services
-const db = new GraphDB('http://insurance.org/claims')
-const embeddings = new EmbeddingService()
-
-// Embedding provider (configure with your API key)
-async function getEmbedding(text) {
-  // Replace with your provider (OpenAI, Voyage, Cohere, etc.)
-  return new Array(384).fill(0).map(() => Math.random())
-}
-
-// Ingestion pipeline with embedding triggers
-async function ingestClaim(claim) {
-  // 1. Insert structured data into knowledge graph
-  db.loadTtl(`
-    @prefix : <http://insurance.org/> .
-    :${claim.id} a :Claim ;
-      :amount "${claim.amount}" ;
-      :description "${claim.description}" ;
-      :claimant :${claim.claimantId} ;
-      :provider :${claim.providerId} .
-  `, null)
-
-  // 2. Generate and store embedding for semantic search
-  const vector = await getEmbedding(claim.description)
-  embeddings.storeVector(claim.id, vector)
-
-  // 3. Update 1-hop cache for neighbor-aware search
-  embeddings.onTripleInsert(claim.id, 'claimant', claim.claimantId, null)
-  embeddings.onTripleInsert(claim.id, 'provider', claim.providerId, null)
-
-  // 4. Rebuild index after batch inserts (or periodically)
-  embeddings.rebuildIndex()
-
-  return { tripleCount: db.countTriples(), embeddingStored: true }
-}
-
-// Process batch with embedding triggers
-async function processBatch(claims) {
-  for (const claim of claims) {
-    await ingestClaim(claim)
-    console.log(`Ingested: ${claim.id}`)
-  }
-
-  // Rebuild HNSW index after batch
-  embeddings.rebuildIndex()
-  console.log(`Index rebuilt with ${claims.length} new embeddings`)
-}
-```
-
-### Pipeline Architecture
-
-```
-┌─────────────────────────────────────────────────────────────────────────┐
-│                    GRAPH INGESTION PIPELINE                              │
-│                                                                          │
-│   ┌───────────────┐     ┌───────────────┐     ┌───────────────┐        │
-│   │  Data Source  │     │   Transform   │     │    Enrich     │        │
-│   │  (JSON/CSV)   │────▶│   (to RDF)    │────▶│  (+Embeddings)│        │
-│   └───────────────┘     └───────────────┘     └───────┬───────┘        │
-│                                                       │                 │
-│   ┌───────────────────────────────────────────────────┼───────────────┐ │
-│   │                      TRIGGERS                     │               │ │
-│   │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┴─────────────┐ │ │
-│   │  │ Embedding   │  │  1-Hop      │  │  HNSW Index               │ │ │
-│   │  │ Generation  │  │  Cache      │  │  Rebuild                  │ │ │
-│   │  │ (per entity)│  │  Update     │  │  (batch/periodic)         │ │ │
-│   │  └─────────────┘  └─────────────┘  └───────────────────────────┘ │ │
-│   └───────────────────────────────────────────────────────────────────┘ │
-│                                       │                                 │
-│                                       ▼                                 │
-│   ┌───────────────────────────────────────────────────────────────────┐ │
-│   │                      RUST CORE (NAPI-RS)                          │ │
-│   │  GraphDB (triples) │ EmbeddingService (vectors) │ HNSW (index)   │ │
-│   └───────────────────────────────────────────────────────────────────┘ │
-└─────────────────────────────────────────────────────────────────────────┘
-```
-
----
-
-## HyperAgent Framework Components
-
-The HyperMind agent framework provides complete infrastructure for building neuro-symbolic AI agents:
-
-### Architecture Overview
-
-```
-┌─────────────────────────────────────────────────────────────────────────┐
-│                    HYPERAGENT FRAMEWORK                                  │
-│                                                                          │
-│   ┌─────────────────────────────────────────────────────────────────┐   │
-│   │                       GOVERNANCE LAYER                           │   │
-│   │  Policy Engine | Capability Grants | Audit Trail | Compliance   │   │
-│   └─────────────────────────────────────────────────────────────────┘   │
-│                                   │                                      │
-│   ┌───────────────────────────────┼─────────────────────────────────┐   │
-│   │                       RUNTIME LAYER                              │   │
-│   │  ┌──────────────┐    ┌───────┴───────┐    ┌──────────────┐      │   │
-│   │  │  LLMPlanner  │    │  PlanExecutor │    │  WasmSandbox │      │   │
-│   │  │  (Claude/GPT)│───▶│  (Type-safe)  │───▶│  (Isolated)  │      │   │
-│   │  └──────────────┘    └───────────────┘    └──────┬───────┘      │   │
-│   └──────────────────────────────────────────────────┼──────────────┘   │
-│                                                      │                   │
-│   ┌──────────────────────────────────────────────────┼──────────────┐   │
-│   │                       PROXY LAYER                │               │   │
-│   │  Object Proxy: All tool calls flow through typed morphism layer │   │
-│   │  ┌────────────────────────────────────────────────┴───────────┐ │   │
-│   │  │  proxy.call('kg.sparql.query', { query })  → BindingSet    │ │   │
-│   │  │  proxy.call('kg.motif.find', { pattern })  → List<Match>   │ │   │
-│   │  │  proxy.call('kg.datalog.infer', { rules }) → List<Fact>    │ │   │
-│   │  │  proxy.call('kg.embeddings.search', { entity }) → Similar  │ │   │
-│   │  └────────────────────────────────────────────────────────────┘ │   │
-│   └─────────────────────────────────────────────────────────────────┘   │
-│                                                                          │
-│   ┌─────────────────────────────────────────────────────────────────┐   │
-│   │                       MEMORY LAYER                               │   │
-│   │  Working Memory | Long-term Memory | Episodic Memory            │   │
-│   │  (Current context) (Knowledge graph) (Execution history)        │   │
-│   └─────────────────────────────────────────────────────────────────┘   │
-│                                                                          │
-│   ┌─────────────────────────────────────────────────────────────────┐   │
-│   │                       SCOPE LAYER                                │   │
-│   │  Namespace isolation | Resource limits | Capability boundaries  │   │
-│   └─────────────────────────────────────────────────────────────────┘   │
-└─────────────────────────────────────────────────────────────────────────┘
-```
-
-### Component Details
-
-**Governance Layer**: Policy-based control over agent behavior
-```javascript
-const agent = new AgentBuilder('compliance-agent')
-  .withPolicy({
-    maxExecutionTime: 30000,      // 30 second timeout
-    allowedTools: ['kg.sparql.query', 'kg.datalog.infer'],
-    deniedTools: ['kg.update', 'kg.delete'],  // Read-only
-    auditLevel: 'full'           // Log all tool calls
-  })
-```
-
-**Runtime Layer**: Type-safe plan execution
-```javascript
-const { LLMPlanner, TOOL_REGISTRY } = require('rust-kgdb/hypermind-agent')
-
-const planner = new LLMPlanner('claude-sonnet-4', TOOL_REGISTRY)
-const plan = await planner.plan("Find suspicious claims")
-// plan.steps: [{tool: 'kg.sparql.query', args: {...}}, ...]
-// plan.confidence: 0.92
-```
-
-**Proxy Layer**: All Rust interactions through typed morphisms
-```javascript
-const sandbox = new WasmSandbox({
-  capabilities: ['ReadKG', 'ExecuteTool'],
-  fuelLimit: 1000000
-})
-
-const proxy = sandbox.createObjectProxy({
-  'kg.sparql.query': (args) => db.querySelect(args.query),
-  'kg.embeddings.search': (args) => embeddings.findSimilar(args.entity, args.k, args.threshold)
-})
-
-// All calls are logged, metered, and capability-checked
-const result = await proxy['kg.sparql.query']({ query: 'SELECT ?x WHERE { ?x a :Fraud }' })
-```
-
-**Memory Layer**: Context management across agent lifecycle
-```javascript
-const agent = new AgentBuilder('investigator')
-  .withMemory({
-    working: { maxSize: 1024 * 1024 },  // 1MB working memory
-    episodic: { retentionDays: 30 },     // 30-day execution history
-    longTerm: db                          // Knowledge graph as long-term memory
-  })
-```
-
-**Scope Layer**: Resource isolation and boundaries
-```javascript
-const agent = new AgentBuilder('scoped-agent')
-  .withScope({
-    namespace: 'fraud-detection',
-    resourceLimits: {
-      maxTriples: 1000000,
-      maxEmbeddings: 100000,
-      maxConcurrentQueries: 10
-    }
-  })
-```
-
----
-
-## Feature Overview
-
-| Category | Feature | What It Does |
-|----------|---------|--------------|
-| **Core** | GraphDB | High-performance RDF/SPARQL quad store |
-| **Core** | SPOC Indexes | Four-way indexing (SPOC/POCS/OCSP/CSPO) |
-| **Core** | Dictionary | String interning with 8-byte IDs |
-| **Analytics** | GraphFrames | PageRank, connected components, triangles |
-| **Analytics** | Motif Finding | Pattern matching DSL |
-| **Analytics** | Pregel | BSP parallel graph processing |
-| **AI** | Embeddings | HNSW similarity with 1-hop ARCADE cache |
-| **AI** | HyperMind | Neuro-symbolic agent framework |
-| **Reasoning** | Datalog | Semi-naive evaluation engine |
-| **Reasoning** | RDFS Reasoner | Subclass/subproperty inference |
-| **Reasoning** | OWL 2 RL | Rule-based OWL reasoning |
-| **Ontology** | SHACL | W3C shapes constraint validation |
-| **Joins** | WCOJ | Worst-case optimal join algorithm |
-| **Distribution** | HDRF | Streaming graph partitioning |
-| **Distribution** | Raft | Consensus for coordination |
-| **Mobile** | iOS/Android | Swift and Kotlin bindings via UniFFI |
-| **Storage** | InMemory/RocksDB/LMDB | Three backend options |
-
----
-
-## Installation
-
-```bash
-npm install rust-kgdb
-```
-
-**Platforms**: macOS (Intel/Apple Silicon), Linux (x64/ARM64), Windows (x64)
-
----
-
-## Quick Start
-
-```javascript
-const { GraphDB, GraphFrame, EmbeddingService, DatalogProgram, evaluateDatalog } = require('rust-kgdb')
-
-// 1. Create knowledge graph
-const db = new GraphDB('http://example.org/myapp')
-
-// 2. Load RDF data (Turtle format)
-db.loadTtl(`
-  @prefix : <http://example.org/> .
-  :alice :knows :bob .
-  :bob :knows :charlie .
-  :charlie :knows :alice .
-`, null)
-
-console.log(`Loaded ${db.countTriples()} triples`)
-
-// 3. Query with SPARQL
-const results = db.querySelect(`
-  PREFIX : <http://example.org/>
-  SELECT ?person WHERE { ?person :knows :bob }
-`)
-console.log('People who know Bob:', results)
-
-// 4. Graph analytics
-const graph = new GraphFrame(
-  JSON.stringify([{id:'alice'}, {id:'bob'}, {id:'charlie'}]),
-  JSON.stringify([
-    {src:'alice', dst:'bob'},
-    {src:'bob', dst:'charlie'},
-    {src:'charlie', dst:'alice'}
-  ])
-)
-console.log('Triangles:', graph.triangleCount())  // 1
-console.log('PageRank:', graph.pageRank(0.15, 20))
-
-// 5. Semantic similarity
-const embeddings = new EmbeddingService()
-embeddings.storeVector('alice', new Array(384).fill(0.5))
-embeddings.storeVector('bob', new Array(384).fill(0.6))
-embeddings.rebuildIndex()
-console.log('Similar to alice:', embeddings.findSimilar('alice', 5, 0.3))
-
-// 6. Datalog reasoning
-const datalog = new DatalogProgram()
-datalog.addFact(JSON.stringify({predicate:'knows', terms:['alice','bob']}))
-datalog.addFact(JSON.stringify({predicate:'knows', terms:['bob','charlie']}))
-datalog.addRule(JSON.stringify({
-  head: {predicate:'connected', terms:['?X','?Z']},
-  body: [
-    {predicate:'knows', terms:['?X','?Y']},
-    {predicate:'knows', terms:['?Y','?Z']}
-  ]
-}))
-console.log('Inferred:', evaluateDatalog(datalog))
-```
-
----
-
-## HyperMind: Where Neural Meets Symbolic
-
-```
-                    ╔═══════════════════════════════════════════════╗
-                    ║       THE HYPERMIND ARCHITECTURE              ║
-                    ╚═══════════════════════════════════════════════╝
-
-                              Natural Language
-                                    │
-                                    ▼
-                    ┌───────────────────────────────────┐
-                    │         LLM (Neural)              │
-                    │   "Find circular payment patterns │
-                    │    in claims from last month"     │
-                    └───────────────────────────────────┘
-                                    │
-                                    ▼
-    ┌───────────────────────────────────────────────────────────────────────┐
-    │                      TYPE THEORY LAYER                                │
-    │  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐       │
-    │  │ TypeId System   │  │ Refinement      │  │ Session Types   │       │
-    │  │ (compile-time)  │  │ Types           │  │ (protocols)     │       │
-    │  └─────────────────┘  └─────────────────┘  └─────────────────┘       │
-    │                    ERRORS CAUGHT HERE, NOT RUNTIME                    │
-    └───────────────────────────────────────────────────────────────────────┘
-                                    │
-                                    ▼
-    ┌───────────────────────────────────────────────────────────────────────┐
-    │                    CATEGORY THEORY LAYER                              │
-    │                                                                       │
-    │   kg.sparql.query     ────►    kg.motif.find    ────►    kg.datalog   │
-    │   (Query → Bindings)       (Pattern → Matches)      (Rules → Facts)  │
-    │                                                                       │
-    │            f: A → B              g: B → C           h: C → D          │
-    │                   g ∘ f: A → C  (COMPOSITION IS TYPE-SAFE)           │
-    └───────────────────────────────────────────────────────────────────────┘
-                                    │
-                                    ▼
-    ┌───────────────────────────────────────────────────────────────────────┐
-    │                      WASM SANDBOX LAYER                               │
-    │  ┌─────────────────────────────────────────────────────────────────┐ │
-    │  │                    wasmtime isolation                            │ │
-    │  │   • Isolated linear memory (no host access)                     │ │
-    │  │   • CPU fuel metering (10M ops max)                             │ │
-    │  │   • Capability-based security                                   │ │
-    │  │   • NO filesystem, NO network                                   │ │
-    │  └─────────────────────────────────────────────────────────────────┘ │
-    └───────────────────────────────────────────────────────────────────────┘
-                                    │
-                                    ▼
-    ┌───────────────────────────────────────────────────────────────────────┐
-    │                     PROOF THEORY LAYER                                │
-    │                                                                       │
-    │   Every execution produces an ExecutionWitness:                      │
-    │   { tool, input, output, hash, timestamp, duration }                 │
-    │                                                                       │
-    │   Curry-Howard: Types ↔ Propositions, Programs ↔ Proofs              │
-    │   Result: Full audit trail for SOX/GDPR/FDA compliance               │
-    └───────────────────────────────────────────────────────────────────────┘
-                                    │
-                                    ▼
-                    ┌───────────────────────────────────┐
-                    │      Knowledge Graph Result       │
-                    │   15 fraud patterns detected      │
-                    │   with complete audit trail       │
-                    └───────────────────────────────────┘
-```
-
----
-
-## HyperMind Architecture Deep Dive
-
-For a complete walkthrough of the architecture, run:
-```bash
-node examples/hypermind-agent-architecture.js
-```
-
-### Full System Architecture
-
-```
-╔════════════════════════════════════════════════════════════════════════════════╗
-║                    HYPERMIND NEURO-SYMBOLIC ARCHITECTURE                       ║
-╠════════════════════════════════════════════════════════════════════════════════╣
-║                                                                                ║
-║  ┌────────────────────────────────────────────────────────────────────────┐   ║
-║  │                         APPLICATION LAYER                               │   ║
-║  │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐    │   ║
-║  │  │   Fraud     │  │ Underwriting│  │  Compliance │  │   Custom    │    │   ║
-║  │  │  Detection  │  │   Agent     │  │   Checker   │  │   Agents    │    │   ║
-║  │  └──────┬──────┘  └──────┬──────┘  └──────┬──────┘  └──────┬──────┘    │   ║
-║  └─────────┼────────────────┼────────────────┼────────────────┼───────────┘   ║
-║            └────────────────┴────────┬───────┴────────────────┘               ║
-║                                      │                                        ║
-║  ┌───────────────────────────────────┼────────────────────────────────────┐   ║
-║  │                      HYPERMIND RUNTIME                                  │   ║
-║  │  ┌────────────────┐    ┌─────────┴─────────┐    ┌─────────────────┐    │   ║
-║  │  │  LLM PLANNER   │    │  PLAN EXECUTOR    │    │  WASM SANDBOX   │    │   ║
-║  │  │ • Claude/GPT   │───▶│ • Type validation │───▶│ • Capabilities  │    │   ║
-║  │  │ • Intent parse │    │ • Morphism compose│    │ • Fuel metering │    │   ║
-║  │  │ • Tool select  │    │ • Step execution  │    │ • Memory limits │    │   ║
-║  │  └────────────────┘    └───────────────────┘    └────────┬────────┘    │   ║
-║  │                                                          │             │   ║
-║  │  ┌───────────────────────────────────────────────────────┼───────────┐ │   ║
-║  │  │                    OBJECT PROXY (gRPC-style)          │           │ │   ║
-║  │  │  proxy.call("kg.sparql.query", args)  ────────────────┤           │ │   ║
-║  │  │  proxy.call("kg.motif.find", args)    ────────────────┤           │ │   ║
-║  │  │  proxy.call("kg.datalog.infer", args) ────────────────┤           │ │   ║
-║  │  └───────────────────────────────────────────────────────┼───────────┘ │   ║
-║  └──────────────────────────────────────────────────────────┼─────────────┘   ║
-║                                                             │                 ║
-║  ┌──────────────────────────────────────────────────────────┼─────────────┐   ║
-║  │                       HYPERMIND TOOLS                    │              │   ║
-║  │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐  ┌───┴─────────┐    │   ║
-║  │  │   SPARQL    │  │   MOTIF     │  │  DATALOG    │  │ EMBEDDINGS  │    │   ║
-║  │  │ String →    │  │ Pattern →   │  │ Rules →     │  │ Entity →    │    │   ║
-║  │  │ BindingSet  │  │ List<Match> │  │ List<Fact>  │  │ List<Sim>   │    │   ║
-║  │  └─────────────┘  └─────────────┘  └─────────────┘  └─────────────┘    │   ║
-║  └────────────────────────────────────────────────────────────────────────┘   ║
-║                                                                                ║
-║  ┌────────────────────────────────────────────────────────────────────────┐   ║
-║  │                    rust-kgdb KNOWLEDGE GRAPH                            │   ║
-║  │  RDF Triples | SPARQL 1.1 | GraphFrames | Embeddings | Datalog         │   ║
-║  │  2.78µs lookups | 24 bytes/triple | 35x faster than RDFox              │   ║
-║  └────────────────────────────────────────────────────────────────────────┘   ║
-╚════════════════════════════════════════════════════════════════════════════════╝
-```
-
-### Agent Execution Sequence
-
-```
-╔════════════════════════════════════════════════════════════════════════════════╗
-║              HYPERMIND AGENT EXECUTION - SEQUENCE DIAGRAM                      ║
-╠════════════════════════════════════════════════════════════════════════════════╣
-║                                                                                ║
-║  User          SDK           Planner        Sandbox        Proxy         KG    ║
-║   │             │              │              │              │            │    ║
-║   │  "Find suspicious claims"  │              │              │            │    ║
-║   │────────────▶│              │              │              │            │    ║
-║   │             │ plan(prompt) │              │              │            │    ║
-║   │             │─────────────▶│              │              │            │    ║
-║   │             │              │ ┌──────────────────────────┐│            │    ║
-║   │             │              │ │ LLM Reasoning:           ││            │    ║
-║   │             │              │ │ 1. Parse intent          ││            │    ║
-║   │             │              │ │ 2. Select tools          ││            │    ║
-║   │             │              │ │ 3. Validate types        ││            │    ║
-║   │             │              │ └──────────────────────────┘│            │    ║
-║   │             │   Plan{steps, confidence}   │              │            │    ║
-║   │             │◀─────────────│              │              │            │    ║
-║   │             │ execute(plan)│              │              │            │    ║
-║   │             │─────────────────────────────▶              │            │    ║
-║   │             │              │  ┌────────────────────────┐ │            │    ║
-║   │             │              │  │ Sandbox Init:          │ │            │    ║
-║   │             │              │  │ • Capabilities: [Read] │ │            │    ║
-║   │             │              │  │ • Fuel: 1,000,000      │ │            │    ║
-║   │             │              │  └────────────────────────┘ │            │    ║
-║   │             │              │              │ kg.sparql    │            │    ║
-║   │             │              │              │─────────────▶│───────────▶│    ║
-║   │             │              │              │              │ BindingSet │    ║
-║   │             │              │              │◀─────────────│◀───────────│    ║
-║   │             │              │              │ kg.datalog   │            │    ║
-║   │             │              │              │─────────────▶│───────────▶│    ║
-║   │             │              │              │              │ List<Fact> │    ║
-║   │             │              │              │◀─────────────│◀───────────│    ║
-║   │             │   ExecutionResult{findings, witness}       │            │    ║
-║   │             │◀─────────────────────────────              │            │    ║
-║   │  "Found 2 collusion patterns. Evidence: ..."            │            │    ║
-║   │◀────────────│              │              │              │            │    ║
-╚════════════════════════════════════════════════════════════════════════════════╝
-```
-
-### Architecture Components (v0.5.8+)
-
-The TypeScript SDK exports production-ready HyperMind components. All execution flows through the **WASM sandbox** for complete security isolation:
-
-```javascript
-const {
-  // Type System (Hindley-Milner style)
-  TypeId,           // Base types + refinement types (RiskScore, PolicyNumber)
-  TOOL_REGISTRY,    // Tools as typed morphisms (category theory)
-
-  // Runtime Components
-  LLMPlanner,       // Natural language → typed tool pipelines
-  WasmSandbox,      // Secure WASM isolation with capability-based security
-  AgentBuilder,     // Fluent builder for agent composition
-  ComposedAgent,    // Executable agent with execution witness
-} = require('rust-kgdb/hypermind-agent')
-```
-
-**Example: Build a Custom Agent**
-```javascript
-const { AgentBuilder, LLMPlanner, TypeId, TOOL_REGISTRY } = require('rust-kgdb/hypermind-agent')
-
-// Compose an agent using the builder pattern
-const agent = new AgentBuilder('compliance-checker')
-  .withTool('kg.sparql.query')
-  .withTool('kg.datalog.infer')
-  .withPlanner(new LLMPlanner('claude-sonnet-4', TOOL_REGISTRY))
-  .withSandbox({
-    capabilities: ['ReadKG', 'ExecuteTool'],  // No WriteKG for safety
-    fuelLimit: 1000000,
-    maxMemory: 64 * 1024 * 1024  // 64MB
-  })
-  .withHook('afterExecute', (step, result) => {
-    console.log(`Completed: ${step.tool} → ${result.length} results`)
-  })
-  .build()
-
-// Execute with natural language
-const result = await agent.call("Check compliance status for all vendors")
-console.log(result.witness.proof_hash)  // sha256:...
-```
-
----
-
-## HyperMind vs MCP (Model Context Protocol)
-
-Why domain-enriched proxies beat generic function calling:
-
-```
-┌───────────────────────┬──────────────────────┬──────────────────────────┐
-│ Feature               │ MCP                  │ HyperMind Proxy          │
-├───────────────────────┼──────────────────────┼──────────────────────────┤
-│ Type Safety           │ ❌ String only       │ ✅ Full type system      │
-│ Domain Knowledge      │ ❌ Generic           │ ✅ Domain-enriched       │
-│ Tool Composition      │ ❌ Isolated          │ ✅ Morphism composition  │
-│ Validation            │ ❌ Runtime           │ ✅ Compile-time          │
-│ Security              │ ❌ None              │ ✅ WASM sandbox          │
-│ Audit Trail           │ ❌ None              │ ✅ Execution witness     │
-│ LLM Context           │ ❌ Generic schema    │ ✅ Rich domain hints     │
-│ Capability Control    │ ❌ All or nothing    │ ✅ Fine-grained caps     │
-├───────────────────────┼──────────────────────┼──────────────────────────┤
-│ Result                │ 60% accuracy         │ 95%+ accuracy            │
-│                       │ "I think this might  │ "Rule R1 matched facts   │
-│                       │  be suspicious..."   │  F1,F2,F3. Proof: ..."   │
-└───────────────────────┴──────────────────────┴──────────────────────────┘
-```
-
-### The Key Insight
-
-**MCP**: LLM generates query → hope it works
-**HyperMind**: LLM selects tools → type system validates → guaranteed correct
-
-```javascript
-// MCP APPROACH (Generic function calling)
-// Tool: search_database(query: string)
-// LLM generates: "SELECT * FROM claims WHERE suspicious = true"
-// Result: ❌ SQL injection risk, "suspicious" column doesn't exist
-
-// HYPERMIND APPROACH (Domain-enriched proxy)
-// Tool: kg.datalog.infer with NICB fraud rules
-const proxy = sandbox.createObjectProxy(tools)
-const result = await proxy['kg.datalog.infer']({
-  rules: ['potential_collusion', 'staged_accident']
-})
-// Result: ✅ Type-safe, domain-aware, auditable
-```
-
-**Why Domain Proxies Win:**
-1. LLM becomes **orchestrator**, not executor
-2. Domain knowledge **reduces hallucination**
-3. Composition **multiplies capability**
-4. Audit trail **enables compliance**
-5. Security **enables enterprise deployment**
-
----
-
-## Why Vanilla LLMs Fail
-
-When you ask an LLM to query a knowledge graph, it produces **broken SPARQL 85% of the time**:
-
-```
-User: "Find all professors"
-
-Vanilla LLM Output:
-┌───────────────────────────────────────────────────────────────────────┐
-│ ```sparql                                                             │
-│ PREFIX ub: <http://swat.cse.lehigh.edu/onto/univ-bench.owl#>         │
-│ SELECT ?professor WHERE {                                             │
-│   ?professor a ub:Faculty .   ← WRONG! Schema has "Professor"        │
-│ }                                                                     │
-│ ```                            ← Parser rejects markdown              │
-│                                                                       │
-│ This query retrieves all faculty members from the LUBM dataset.      │
-│                                ↑ Explanation text breaks parsing      │
-└───────────────────────────────────────────────────────────────────────┘
-Result: ❌ PARSER ERROR - Invalid SPARQL syntax
-```
-
-**Why it fails:**
-1. LLM wraps query in markdown code blocks → parser chokes
-2. LLM adds explanation text → mixed with query syntax
-3. LLM hallucinates class names → `ub:Faculty` doesn't exist (it's `ub:Professor`)
-4. LLM has no schema awareness → guesses predicates and classes
-
----
-
-## How HyperMind Solves This
-
-```
-User: "Find all professors"
-
-HyperMind Output:
-┌───────────────────────────────────────────────────────────────────────┐
-│ PREFIX ub: <http://swat.cse.lehigh.edu/onto/univ-bench.owl#>         │
-│ SELECT ?professor WHERE {                                             │
-│   ?professor a ub:Professor . ← CORRECT! Schema-aware                │
-│ }                                                                     │
-└───────────────────────────────────────────────────────────────────────┘
-Result: ✅ 15 results returned in 2.3ms
-```
-
-**Why it works:**
-1. **Type-checked tools** - Query must be valid SPARQL (compile-time check)
-2. **Schema integration** - Tools know the ontology, not just the LLM
-3. **No text pollution** - Query output is typed `SPARQLQuery`, not `string`
-4. **Deterministic execution** - Same query, same result, always
-
-**Accuracy improvement: 0% → 86.4%** (+86 percentage points on LUBM benchmark)
-
----
-
-## HyperMind in Action: Complete Agent Conversation
-
-This is what a real HyperMind agent interaction looks like. Run `node examples/hypermind-complete-demo.js` to see it yourself.
-
-```
-================================================================================
-  THE PROBLEM WITH AI AGENTS TODAY
-================================================================================
-
-  You ask ChatGPT: "Find suspicious insurance claims in our data"
-  It replies: "Based on typical fraud patterns, you should look for..."
-
-  But wait -- it never SAW your data. It's guessing. Hallucinating.
-
-  HYPERMIND'S INSIGHT: Use LLMs for UNDERSTANDING, symbolic systems for REASONING.
-
-================================================================================
-
-+------------------------------------------------------------------------+
-|  SECTION 4: DATALOG REASONING                                          |
-|  Rule-Based Inference Using NICB Fraud Detection Guidelines            |
-+------------------------------------------------------------------------+
-
-  RULE 1: potential_collusion(?X, ?Y, ?P)
-    IF claimant(?X) AND claimant(?Y) AND provider(?P)
-       AND claims_with(?X, ?P) AND claims_with(?Y, ?P)
-       AND knows(?X, ?Y)
-    THEN potential_collusion(?X, ?Y, ?P)
-    Source: NICB Ring Detection Guidelines
-
-  Running Datalog Inference Engine...
-
-  INFERRED FACTS:
-  ---------------
-  [!] COLLUSION DETECTED: 1 pattern(s)
-        P001 <-> P002 via PROV001
-  [!] STAGED ACCIDENT INDICATORS: 3 pattern(s)
-        P001 via PROV001
-        P002 via PROV001
-        P005 via PROV001
-
-+------------------------------------------------------------------------+
-|  SECTION 5: HYPERMIND AGENT INTERACTION                                |
-|  Natural Language Interface - The Power of Neuro-Symbolic AI           |
-+------------------------------------------------------------------------+
-
-  ========================================================================
-  USER PROMPT: "Which claims look suspicious and why should I investigate them?"
-  ========================================================================
-
-  Agent Reasoning:
-  1. Decomposing query: "suspicious claims" -> need risk indicators
-  2. Selecting tools: GraphFrame (network), Embeddings (similarity), Datalog (rules)
-  3. Type checking: All tools compatible (Graph -> Analysis -> Inference)
-  4. Executing pipeline...
-
-  ========================================================================
-  AGENT RESPONSE:
-  ========================================================================
-
-  I analyzed 5 claims across 3 providers and found 2 CRITICAL fraud indicators:
-
-  [CRITICAL] FINDING 1: COLLUSION RING (Confidence: 95%)
-  --------------------------------------------------------
-  Claimants:    John Smith (P001) + Jane Doe (P002)
-  Provider:     Quick Care Rehabilitation Clinic
-  Evidence:
-    - Both filed soft tissue claims within 3 days of each other
-    - Both live at 123 Main St (shared address)
-    - Both have elevated risk scores (0.85, 0.72)
-
-  Rule Triggered: NICB Collusion Pattern
-    potential_collusion(P001, P002, PROV001) <- knows AND same_provider AND same_address
-
-  Recommendation: IMMEDIATE SIU REFERRAL
-
-  EXECUTION WITNESS (Proof Theory - Audit Trail):
-  ------------------------------------------------
-  Timestamp:  2024-12-14T23:15:00Z
-  Agent:      fraud-investigator
-  Tools:
-    - kg.graphframe.triangles: 1 triangle detected
-    - kg.embeddings.search: 3 clusters found
-    - kg.datalog.infer: 3 fraud patterns derived
-  Proof Hash: sha256:a3f2b8c9d1e4...
-
-  ========================================================================
-  USER FOLLOW-UP: "Show me the rule that detected the collusion"
-  ========================================================================
-
-  Agent Response:
-
-  The collusion was detected by this NICB-derived Datalog rule:
-
-  +----------------------------------------------------------------------+
-  |  RULE: potential_collusion(?X, ?Y, ?P)                               |
-  |                                                                      |
-  |  IF:                                                                 |
-  |    claimant(?X)           <- John Smith is a claimant               |
-  |    claimant(?Y)           <- Jane Doe is a claimant                 |
-  |    provider(?P)           <- Quick Care is a provider               |
-  |    claims_with(?X, ?P)    <- John filed claim with Quick Care       |
-  |    claims_with(?Y, ?P)    <- Jane filed claim with Quick Care       |
-  |    knows(?X, ?Y)          <- John and Jane know each other          |
-  |                                                                      |
-  |  THEN:                                                               |
-  |    potential_collusion(P001, P002, PROV001)                         |
-  |                                                                      |
-  |  CONFIDENCE: 100% (all facts verified in knowledge graph)           |
-  +----------------------------------------------------------------------+
-
-  This derivation is 100% deterministic and auditable.
-  A regulator can verify this finding by checking the rule against the facts.
-```
-
-**The Key Difference:**
-- **Vanilla LLM**: "Some claims may be suspicious" (no data access, no proof)
-- **HyperMind**: Specific findings + rule derivations + cryptographic audit trail
-
-**Try it yourself:**
-```bash
-node examples/hypermind-complete-demo.js  # Full 7-section demo
-node examples/fraud-detection-agent.js    # Fraud detection pipeline
-node examples/underwriting-agent.js       # Underwriting pipeline
-```
-
----
-
-## Mathematical Foundations
-
-We don't "vibe code" AI agents. Every tool is a **mathematical morphism** with provable properties.
-
-### Type Theory: Compile-Time Validation
-
-```typescript
-// Refinement types catch errors BEFORE execution
-type RiskScore = number & { __refinement: '0 ≤ x ≤ 1' }
-type PolicyNumber = string & { __refinement: '/^POL-\\d{9}$/' }
-type CreditScore = number & { __refinement: '300 ≤ x ≤ 850' }
-
-// Framework validates at construction, not runtime
-function assessRisk(score: RiskScore): Decision {
-  // score is GUARANTEED to be 0.0-1.0
-  // No defensive coding needed
-}
-```
-
-### Category Theory: Safe Tool Composition
-
-```
-Tools are morphisms (typed arrows):
-
-  kg.sparql.query:     Query → BindingSet
-  kg.motif.find:       Pattern → Matches
-  kg.datalog.apply:    Rules → InferredFacts
-  kg.embeddings.search: Entity → SimilarEntities
-
-Composition is type-checked:
-
-  f: A → B
-  g: B → C
-  g ∘ f: A → C  (valid only if types align)
-
-Laws guaranteed:
-  1. Identity:      id ∘ f = f = f ∘ id
-  2. Associativity: (h ∘ g) ∘ f = h ∘ (g ∘ f)
-```
-
-### Proof Theory: Auditable Execution
-
-Every execution produces an **ExecutionWitness** (Curry-Howard correspondence):
-
-```json
-{
-  "tool": "kg.sparql.query",
-  "input": "SELECT ?x WHERE { ?x a :Fraud }",
-  "output": "[{x: 'entity001'}]",
-  "inputType": "Query",
-  "outputType": "BindingSet",
-  "timestamp": "2024-12-14T10:30:00Z",
-  "durationMs": 12,
-  "hash": "sha256:a3f2c8d9..."
-}
-```
-
-**Implication**: Full audit trail for SOX, GDPR, FDA 21 CFR Part 11 compliance.
-
----
-
-## Ontology Engine
-
-rust-kgdb includes a complete ontology engine based on W3C standards.
-
-### RDFS Reasoning
-
-```turtle
-# Schema
-:Employee rdfs:subClassOf :Person .
-:Manager rdfs:subClassOf :Employee .
-
-# Data
-:alice a :Manager .
-
-# Inferred (automatic)
-:alice a :Employee .  # via subclass chain
-:alice a :Person .    # via subclass chain
-```
-
-### OWL 2 RL Rules
-
-| Rule | Description |
-|------|-------------|
-| `prp-dom` | Property domain inference |
-| `prp-rng` | Property range inference |
-| `prp-symp` | Symmetric property |
-| `prp-trp` | Transitive property |
-| `cls-hv` | hasValue restriction |
-| `cls-svf` | someValuesFrom restriction |
-| `cax-sco` | Subclass transitivity |
-
-### SHACL Validation
-
-```turtle
-:PersonShape a sh:NodeShape ;
-    sh:targetClass :Person ;
-    sh:property [
-        sh:path :email ;
-        sh:pattern "^[a-z]+@[a-z]+\\.[a-z]+$" ;
-        sh:minCount 1 ;
-    ] .
-```
-
----
-
-## Production Example: Fraud Detection
-
-**Data Sources:** Example patterns based on [NICB (National Insurance Crime Bureau)](https://www.nicb.org/) published fraud statistics:
-- Staged accidents: 20% of insurance fraud
-- Provider collusion: 25% of fraud claims
-- Ring operations: 40% of organized fraud
-
-**Pattern Recognition:** Circular payment detection mirrors real SIU (Special Investigation Unit) methodologies from major insurers.
-
-### Pre-Steps: Dataset and Embedding Configuration
-
-Before running the fraud detection pipeline, configure your environment:
-
-```javascript
-// ============================================================
-// STEP 1: Environment Configuration
-// ============================================================
-const { GraphDB, GraphFrame, EmbeddingService, DatalogProgram, evaluateDatalog } = require('rust-kgdb')
-const { AgentBuilder, LLMPlanner, WasmSandbox, TOOL_REGISTRY } = require('rust-kgdb/hypermind-agent')
-
-// Configure embedding provider (choose one)
-const EMBEDDING_PROVIDER = process.env.EMBEDDING_PROVIDER || 'mock'
-const OPENAI_API_KEY = process.env.OPENAI_API_KEY
-const VOYAGE_API_KEY = process.env.VOYAGE_API_KEY
-
-// Embedding dimension must match provider output
-const EMBEDDING_DIM = 384
-
-// ============================================================
-// STEP 2: Initialize Services
-// ============================================================
-const db = new GraphDB('http://insurance.org/fraud-kb')
-const embeddings = new EmbeddingService()
-
-// ============================================================
-// STEP 3: Configure Embedding Provider (bring your own)
-// ============================================================
-async function getEmbedding(text) {
-  switch (EMBEDDING_PROVIDER) {
-    case 'openai':
-      // Requires: npm install openai
-      const { OpenAI } = require('openai')
-      const openai = new OpenAI({ apiKey: OPENAI_API_KEY })
-      const resp = await openai.embeddings.create({
-        model: 'text-embedding-3-small',
-        input: text,
-        dimensions: EMBEDDING_DIM
-      })
-      return resp.data[0].embedding
-
-    case 'voyage':
-      // Using fetch directly (no SDK required)
-      const vResp = await fetch('https://api.voyageai.com/v1/embeddings', {
-        method: 'POST',
-        headers: {
-          'Authorization': `Bearer ${VOYAGE_API_KEY}`,
-          'Content-Type': 'application/json'
-        },
-        body: JSON.stringify({ input: text, model: 'voyage-2' })
-      })
-      const vData = await vResp.json()
-      return vData.data[0].embedding.slice(0, EMBEDDING_DIM)
-
-    default: // Mock embeddings for testing (no external deps)
-      return new Array(EMBEDDING_DIM).fill(0).map((_, i) =>
-        Math.sin(text.charCodeAt(i % text.length) * 0.1) * 0.5 + 0.5
-      )
-  }
-}
-
-// ============================================================
-// STEP 4: Load Dataset with Embedding Triggers
-// ============================================================
-async function loadClaimsDataset() {
-  // Load structured RDF data
-  db.loadTtl(`
-    @prefix : <http://insurance.org/> .
-    @prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
-
-    # Claims
-    :CLM001 a :Claim ;
-      :amount "18500"^^xsd:decimal ;
-      :description "Soft tissue injury from rear-end collision" ;
-      :claimant :P001 ;
-      :provider :PROV001 ;
-      :filingDate "2024-11-15"^^xsd:date .
-
-    :CLM002 a :Claim ;
-      :amount "22300"^^xsd:decimal ;
-      :description "Whiplash injury from vehicle accident" ;
-      :claimant :P002 ;
-      :provider :PROV001 ;
-      :filingDate "2024-11-18"^^xsd:date .
-
-    # Claimants
-    :P001 a :Claimant ;
-      :name "John Smith" ;
-      :address "123 Main St, Miami, FL" ;
-      :riskScore "0.85"^^xsd:decimal .
-
-    :P002 a :Claimant ;
-      :name "Jane Doe" ;
-      :address "123 Main St, Miami, FL" ;  # Same address!
-      :riskScore "0.72"^^xsd:decimal .
-
-    # Relationships (fraud indicators)
-    :P001 :knows :P002 .
-    :P001 :paidTo :P002 .
-    :P002 :paidTo :P003 .
-    :P003 :paidTo :P001 .  # Circular payment!
-
-    # Provider
-    :PROV001 a :Provider ;
-      :name "Quick Care Rehabilitation Clinic" ;
-      :flagCount "4"^^xsd:integer .
-  `, null)
-
-  console.log(`[Dataset] Loaded ${db.countTriples()} triples`)
-
-  // Generate embeddings for claims (TRIGGER)
-  const claims = ['CLM001', 'CLM002']
-  for (const claimId of claims) {
-    const desc = db.querySelect(`
-      PREFIX : <http://insurance.org/>
-      SELECT ?desc WHERE { :${claimId} :description ?desc }
-    `)[0]?.bindings?.desc || claimId
-
-    const vector = await getEmbedding(desc)
-    embeddings.storeVector(claimId, vector)
-    console.log(`[Embedding] Stored ${claimId}: ${vector.slice(0, 3).map(v => v.toFixed(3)).join(', ')}...`)
-  }
-
-  // Update 1-hop cache (TRIGGER)
-  embeddings.onTripleInsert('CLM001', 'claimant', 'P001', null)
-  embeddings.onTripleInsert('CLM001', 'provider', 'PROV001', null)
-  embeddings.onTripleInsert('CLM002', 'claimant', 'P002', null)
-  embeddings.onTripleInsert('CLM002', 'provider', 'PROV001', null)
-  embeddings.onTripleInsert('P001', 'knows', 'P002', null)
-  console.log('[1-Hop Cache] Updated neighbor relationships')
-
-  // Rebuild HNSW index
-  embeddings.rebuildIndex()
-  console.log('[HNSW Index] Rebuilt for similarity search')
-}
-
-// ============================================================
-// STEP 5: Run Fraud Detection Pipeline
-// ============================================================
-async function runFraudDetection() {
-  await loadClaimsDataset()
-
-  // Graph network analysis
-  const graph = new GraphFrame(
-    JSON.stringify([{id:'P001'}, {id:'P002'}, {id:'P003'}]),
-    JSON.stringify([
-      {src:'P001', dst:'P002'},
-      {src:'P002', dst:'P003'},
-      {src:'P003', dst:'P001'}
-    ])
-  )
-
-  const triangles = graph.triangleCount()
-  console.log(`[GraphFrame] Fraud rings detected: ${triangles}`)
-
-  // Semantic similarity search
-  const similarClaims = JSON.parse(embeddings.findSimilar('CLM001', 5, 0.7))
-  console.log(`[Embeddings] Claims similar to CLM001:`, similarClaims)
-
-  // Datalog rule-based inference
-  const datalog = new DatalogProgram()
-  datalog.addFact(JSON.stringify({predicate:'claim', terms:['CLM001','P001','PROV001']}))
-  datalog.addFact(JSON.stringify({predicate:'claim', terms:['CLM002','P002','PROV001']}))
-  datalog.addFact(JSON.stringify({predicate:'related', terms:['P001','P002']}))
-
-  datalog.addRule(JSON.stringify({
-    head: {predicate:'collusion', terms:['?P1','?P2','?Prov']},
-    body: [
-      {predicate:'claim', terms:['?C1','?P1','?Prov']},
-      {predicate:'claim', terms:['?C2','?P2','?Prov']},
-      {predicate:'related', terms:['?P1','?P2']}
-    ]
-  }))
-
-  const result = JSON.parse(evaluateDatalog(datalog))
-  console.log('[Datalog] Collusion detected:', result.collusion)
-  // Output: [["P001","P002","PROV001"]]
-}
-
-runFraudDetection()
-```
-
-**Run it yourself:**
-```bash
-node examples/fraud-detection-agent.js
-```
-
-**Actual Output:**
-```
-======================================================================
-  FRAUD DETECTION AGENT - Production Pipeline
-  rust-kgdb v0.2.0 | Neuro-Symbolic AI Framework
-======================================================================
-
-[PHASE 1] Knowledge Graph Initialization
---------------------------------------------------
-  Graph URI:    http://insurance.org/fraud-kb
-  Triples:      13
-
-[PHASE 2] Graph Network Analysis
---------------------------------------------------
-  Vertices: 7
-  Edges:    8
-  Triangles: 1 (fraud ring indicator)
-  PageRank (central actors):
-    - PROV001: 0.2169
-    - P001: 0.1418
-
-[PHASE 3] Semantic Similarity Analysis
---------------------------------------------------
-  Embeddings stored: 5
-  Vector dimension: 384
-
-[PHASE 4] Datalog Rule-Based Inference
---------------------------------------------------
-  Facts: 6
-  Rules: 2
-  Inferred facts:
-    - Collusion: [["P001","P002","PROV001"]]
-    - Connected: [["P001","P003"]]
-
-======================================================================
-  FRAUD DETECTION REPORT - OVERALL RISK: HIGH
-======================================================================
-```
-
----
-
-## Production Example: Underwriting
-
-**Data Sources:** Rating factors based on [ISO (Insurance Services Office)](https://www.verisk.com/insurance/brands/iso/) industry standards:
-- NAICS codes: US Census Bureau industry classification
-- Territory modifiers: Based on catastrophe exposure (hurricane zones FL, earthquake CA)
-- Loss ratio thresholds: Industry standard 0.70 referral trigger
-- Experience modification: Standard 5/10 year breaks
-
-**Premium Formula:** `Base Rate × Exposure × Territory Mod × Experience Mod × Loss Mod` - standard ISO methodology.
-
-```javascript
-const { GraphDB, GraphFrame, DatalogProgram, evaluateDatalog } = require('rust-kgdb')
-
-// Load risk factors
-const db = new GraphDB('http://underwriting.org/kb')
-db.loadTtl(`
-  @prefix : <http://underwriting.org/> .
-  :BUS001 :naics "332119" ; :lossRatio "0.45" ; :territory "FL" .
-  :BUS002 :naics "541512" ; :lossRatio "0.00" ; :territory "CA" .
-  :BUS003 :naics "484121" ; :lossRatio "0.72" ; :territory "TX" .
-`, null)
-
-// Apply underwriting rules
-const datalog = new DatalogProgram()
-datalog.addFact(JSON.stringify({predicate:'business', terms:['BUS001','manufacturing','0.45']}))
-datalog.addFact(JSON.stringify({predicate:'business', terms:['BUS002','tech','0.00']}))
-datalog.addFact(JSON.stringify({predicate:'business', terms:['BUS003','transport','0.72']}))
-datalog.addFact(JSON.stringify({predicate:'highRiskClass', terms:['transport']}))
-
-datalog.addRule(JSON.stringify({
-  head: {predicate:'referToUW', terms:['?Bus']},
-  body: [
-    {predicate:'business', terms:['?Bus','?Class','?LR']},
-    {predicate:'highRiskClass', terms:['?Class']}
-  ]
-}))
-
-datalog.addRule(JSON.stringify({
-  head: {predicate:'autoApprove', terms:['?Bus']},
-  body: [{predicate:'business', terms:['?Bus','tech','?LR']}]
-}))
-
-const decisions = JSON.parse(evaluateDatalog(datalog))
-console.log('Auto-approve:', decisions.autoApprove)  // [["BUS002"]]
-console.log('Refer to UW:', decisions.referToUW)     // [["BUS003"]]
-```
-
-**Run it yourself:**
-```bash
-node examples/underwriting-agent.js
-```
-
-**Actual Output:**
-```
-======================================================================
-  INSURANCE UNDERWRITING AGENT - Production Pipeline
-  rust-kgdb v0.2.0 | Neuro-Symbolic AI Framework
-======================================================================
-
-[PHASE 2] Risk Factor Analysis
---------------------------------------------------
-  Risk network: 12 nodes, 10 edges
-  Risk concentration (PageRank):
-    - BUS001: 0.0561
-    - BUS003: 0.0561
-
-[PHASE 3] Similar Risk Profile Matching
---------------------------------------------------
-  Risk embeddings stored: 4
-  Profiles similar to BUS003 (high-risk transportation):
-    - BUS001: manufacturing, loss ratio 0.45
-    - BUS004: hospitality, loss ratio 0.28
-
-[PHASE 4] Underwriting Decision Rules
---------------------------------------------------
-  Facts loaded: 6
-  Decision rules: 2
-  Automated decisions:
-    - BUS002: AUTO-APPROVE
-    - BUS003: REFER TO UNDERWRITER
-
-[PHASE 5] Premium Calculation
---------------------------------------------------
-  - BUS001: $1,339,537 (STANDARD)
-  - BUS002: $74,155 (APPROVED)
-  - BUS003: $1,125,778 (REFER)
-
-======================================================================
-  Applications processed: 4 | Auto-approved: 1 | Referred: 1
-======================================================================
-```
-
----
-
-## HyperMind Agent Design: A Complete Guide
-
-This section explains how to design production-grade AI agents using HyperMind's mathematical foundations. We'll walk through the complete architecture using our Fraud Detection and Underwriting agents as case studies.
-
-### The HyperMind Architecture
-
-```
-┌─────────────────────────────────────────────────────────────────────────────┐
-│                         HYPERMIND FRAMEWORK                                  │
-│                                                                             │
-│  ┌───────────────┐   ┌───────────────┐   ┌───────────────┐                │
-│  │  TYPE THEORY  │   │   CATEGORY    │   │    PROOF      │                │
-│  │  (Hindley-    │   │    THEORY     │   │    THEORY     │                │
-│  │   Milner)     │   │  (Morphisms)  │   │  (Witnesses)  │                │
-│  └───────┬───────┘   └───────┬───────┘   └───────┬───────┘                │
-│          │                   │                   │                          │
-│          └─────────────┬─────┴───────────────────┘                          │
-│                        │                                                     │
-│  ┌─────────────────────▼─────────────────────────────────────────┐         │
-│  │                    TOOL REGISTRY                               │         │
-│  │  Every tool is a typed morphism: Input Type → Output Type     │         │
-│  │                                                                │         │
-│  │  kg.sparql.query   : SPARQLQuery    → BindingSet              │         │
-│  │  kg.graphframe     : Graph          → AnalysisResult          │         │
-│  │  kg.embeddings     : EntityId       → SimilarEntities         │         │
-│  │  kg.datalog        : DatalogProgram → InferredFacts           │         │
-│  └───────────────────────────────────────────────────────────────┘         │
-│                        │                                                     │
-│  ┌─────────────────────▼─────────────────────────────────────────┐         │
-│  │                   AGENT EXECUTOR                               │         │
-│  │  Composes tools safely • Produces execution witness            │         │
-│  └───────────────────────────────────────────────────────────────┘         │
-└─────────────────────────────────────────────────────────────────────────────┘
-```
-
-### Step 1: Design Your Knowledge Graph
-
-The knowledge graph is the foundation. It encodes domain expertise as structured data.
-
-**Fraud Detection Domain Model:**
-```
-┌─────────────┐     paidTo      ┌─────────────┐
-│  Claimant   │ ───────────────▶│  Claimant   │
-│   (P001)    │                 │   (P002)    │
-└──────┬──────┘                 └──────┬──────┘
-       │ claimant                      │ claimant
-       ▼                               ▼
-┌─────────────┐                 ┌─────────────┐
-│   Claim     │     provider    │   Claim     │
-│  (CLM001)   │ ───────────────▶│  (CLM002)   │
-└──────┬──────┘       ┌─────────┴─────────────┘
-       │              │
-       ▼              ▼
-┌──────────────────────┐
-│      Provider        │  ◀── High claim volume signals risk
-│     (PROV001)        │
-└──────────────────────┘
-```
-
-**Code: Loading the Graph**
-```javascript
-const { GraphDB } = require('rust-kgdb')
-
-const db = new GraphDB('http://insurance.org/fraud-kb')
-
-// NICB-informed fraud ontology with real patterns
-db.loadTtl(`
-  @prefix ins: <http://insurance.org/> .
-  @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
-  @prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
-
-  # Claimants with risk scores
-  ins:P001 rdf:type ins:Claimant ;
-           ins:name "John Smith" ;
-           ins:riskScore "0.85"^^xsd:float .
-
-  ins:P002 rdf:type ins:Claimant ;
-           ins:name "Jane Doe" ;
-           ins:riskScore "0.72"^^xsd:float .
-
-  # Claims linked to claimants and providers
-  ins:CLM001 rdf:type ins:Claim ;
-             ins:claimant ins:P001 ;
-             ins:provider ins:PROV001 ;
-             ins:amount "18500"^^xsd:decimal .
-
-  # Fraud ring indicator: claimants know each other
-  ins:P001 ins:knows ins:P002 .
-  ins:P001 ins:sameAddress ins:P002 .
-`, 'http://insurance.org/fraud-kb')
-
-console.log(`Knowledge Graph: ${db.countTriples()} triples`)
-```
-
-### Step 2: Graph Analytics with GraphFrames
-
-GraphFrames detect structural patterns that indicate fraud rings.
-
-**Design Thinking:** Fraud rings create network triangles. If A→B→C→A, there's a closed loop of money flow - a classic fraud indicator.
-
-```
-Triangle Detection:                PageRank Analysis:
-
-    P001                           PROV001: 0.2169  ← Central actor
-   ╱    ╲                          P001:    0.1418  ← High influence
-  ╱      ╲                         P002:    0.1312  ← Connected to ring
- ▼        ▼
-P002 ────▶ P003                    Interpretation: PROV001 is the hub
-     ↖____/                        that connects multiple claimants.
-
-     1 Triangle = 1 Fraud Ring
-```
-
-**Code: Network Analysis**
-```javascript
-const { GraphFrame } = require('rust-kgdb')
-
-// Model the payment network as a graph
-const vertices = [
-  { id: 'P001', type: 'claimant', risk: 0.85 },
-  { id: 'P002', type: 'claimant', risk: 0.72 },
-  { id: 'P003', type: 'claimant', risk: 0.45 },
-  { id: 'PROV001', type: 'provider', claimCount: 847 }
-]
-
-const edges = [
-  { src: 'P001', dst: 'P002', relationship: 'paidTo' },
-  { src: 'P002', dst: 'P003', relationship: 'paidTo' },
-  { src: 'P003', dst: 'P001', relationship: 'paidTo' },  // Closes the loop!
-  { src: 'P001', dst: 'PROV001', relationship: 'claimsWith' },
-  { src: 'P002', dst: 'PROV001', relationship: 'claimsWith' }
-]
-
-// GraphFrame requires JSON strings
-const gf = new GraphFrame(JSON.stringify(vertices), JSON.stringify(edges))
-
-// Detect triangles (fraud rings)
-const triangles = gf.triangleCount()
-console.log(`Fraud rings detected: ${triangles}`)  // 1
-
-// Find central actors with PageRank
-const pageRankJson = gf.pageRank(0.85, 20)
-const pageRank = JSON.parse(pageRankJson)
-console.log('Central actors:', pageRank.ranks)
-```
-
-### Step 3: Semantic Similarity with Embeddings
-
-Embeddings find claims with similar characteristics - useful for detecting patterns across different fraud schemes.
-
-**Design Thinking:** Claims with similar profiles (same type, similar amounts, same provider type) cluster together in vector space.
-
-```
-Vector Space Visualization:
-
-         High Amount
-              │
-              │    CLM001 (bodily injury, $18.5K)
-              │       ●
-              │         ╲ similarity: 0.815
-              │          ╲
-              │           ●  CLM002 (bodily injury, $22.3K)
-              │
-              │                 ● CLM003 (collision, $15.8K)
-    Low Risk ─┼────────────────────────── High Risk
-              │
-              │    ● CLM005 (property, $3.2K)
-              │
-         Low Amount
-
-Claims cluster by type + amount + risk.
-Similar claims = similar fraud patterns.
-```
-
-**Code: Embedding Storage and Search**
-```javascript
-const { EmbeddingService } = require('rust-kgdb')
-
-const embeddings = new EmbeddingService()
-
-// Generate embeddings from claim characteristics
-function generateClaimEmbedding(claimType, amount, providerVolume, riskScore) {
-  // Create 384-dimensional vector encoding claim profile
-  const embedding = new Array(384).fill(0)
-
-  // Encode claim type (one-hot style in first dimensions)
-  const typeIndex = { 'bodily_injury': 0, 'collision': 1, 'property': 2 }
-  embedding[typeIndex[claimType] || 0] = 1.0
-
-  // Encode normalized values
-  embedding[10] = amount / 50000           // Normalize amount
-  embedding[11] = providerVolume / 1000    // Normalize provider volume
-  embedding[12] = riskScore                // Risk score (0-1)
-
-  // Add some variance for realistic embedding
-  for (let i = 13; i < 384; i++) {
-    embedding[i] = Math.sin(i * amount * 0.001) * 0.1
-  }
-
-  return embedding
-}
-
-// Store claim embeddings
-const claims = {
-  'CLM001': { type: 'bodily_injury', amount: 18500, volume: 847, risk: 0.85 },
-  'CLM002': { type: 'bodily_injury', amount: 22300, volume: 847, risk: 0.72 },
-  'CLM003': { type: 'collision', amount: 15800, volume: 2341, risk: 0.45 },
-  'CLM004': { type: 'property', amount: 3200, volume: 156, risk: 0.22 }
-}
-
-Object.entries(claims).forEach(([id, profile]) => {
-  const vec = generateClaimEmbedding(profile.type, profile.amount, profile.volume, profile.risk)
-  embeddings.storeVector(id, vec)
-})
-
-// Find claims similar to high-risk CLM001
-const similarJson = embeddings.findSimilar('CLM001', 5, 0.5)
-const similar = JSON.parse(similarJson)
-
-similar.forEach(s => {
-  if (s.entity !== 'CLM001') {
-    console.log(`${s.entity}: similarity ${s.score.toFixed(3)}`)
-  }
-})
-// CLM002: 0.815 (same type, similar amount)
-// CLM003: 0.679 (different type, but similar profile)
-```
-
-### Step 4: Rule-Based Inference with Datalog
-
-Datalog applies logical rules to infer fraud patterns. This is the "expert system" component.
-
-**Design Thinking:** Domain experts encode their knowledge as rules. The engine applies these rules automatically.
-
-```
-NICB Fraud Detection Rules:
-
-Rule 1: COLLUSION
-  IF claimant(X) AND claimant(Y) AND
-     provider(P) AND claims_with(X, P) AND
-     claims_with(Y, P) AND knows(X, Y)
-  THEN potential_collusion(X, Y, P)
-
-Rule 2: ADDRESS FRAUD
-  IF claimant(X) AND claimant(Y) AND
-     same_address(X, Y) AND high_risk(X) AND high_risk(Y)
-  THEN address_fraud_indicator(X, Y)
-
-Inference Chain:
-  claimant(P001)           ┐
-  claimant(P002)           │
-  provider(PROV001)        │──▶ potential_collusion(P001, P002, PROV001)
-  claims_with(P001,PROV001)│
-  claims_with(P002,PROV001)│
-  knows(P001, P002)        ┘
-```
-
-**Code: Datalog Inference**
-```javascript
-const { DatalogProgram, evaluateDatalog } = require('rust-kgdb')
-
-const datalog = new DatalogProgram()
-
-// Add facts from knowledge graph
-datalog.addFact(JSON.stringify({ predicate: 'claimant', terms: ['P001'] }))
-datalog.addFact(JSON.stringify({ predicate: 'claimant', terms: ['P002'] }))
-datalog.addFact(JSON.stringify({ predicate: 'provider', terms: ['PROV001'] }))
-datalog.addFact(JSON.stringify({ predicate: 'claims_with', terms: ['P001', 'PROV001'] }))
-datalog.addFact(JSON.stringify({ predicate: 'claims_with', terms: ['P002', 'PROV001'] }))
-datalog.addFact(JSON.stringify({ predicate: 'knows', terms: ['P001', 'P002'] }))
-datalog.addFact(JSON.stringify({ predicate: 'same_address', terms: ['P001', 'P002'] }))
-datalog.addFact(JSON.stringify({ predicate: 'high_risk', terms: ['P001'] }))
-datalog.addFact(JSON.stringify({ predicate: 'high_risk', terms: ['P002'] }))
-
-// Add NICB-informed collusion rule
-datalog.addRule(JSON.stringify({
-  head: { predicate: 'potential_collusion', terms: ['?X', '?Y', '?P'] },
-  body: [
-    { predicate: 'claimant', terms: ['?X'] },
-    { predicate: 'claimant', terms: ['?Y'] },
-    { predicate: 'provider', terms: ['?P'] },
-    { predicate: 'claims_with', terms: ['?X', '?P'] },
-    { predicate: 'claims_with', terms: ['?Y', '?P'] },
-    { predicate: 'knows', terms: ['?X', '?Y'] }
-  ]
-}))
-
-// Add address fraud rule
-datalog.addRule(JSON.stringify({
-  head: { predicate: 'address_fraud_indicator', terms: ['?X', '?Y'] },
-  body: [
-    { predicate: 'claimant', terms: ['?X'] },
-    { predicate: 'claimant', terms: ['?Y'] },
-    { predicate: 'same_address', terms: ['?X', '?Y'] },
-    { predicate: 'high_risk', terms: ['?X'] },
-    { predicate: 'high_risk', terms: ['?Y'] }
-  ]
-}))
-
-// Run inference
-const resultJson = evaluateDatalog(datalog)
-const result = JSON.parse(resultJson)
-
-console.log('Collusion:', result.potential_collusion)
-// [["P001", "P002", "PROV001"]]
-
-console.log('Address Fraud:', result.address_fraud_indicator)
-// [["P001", "P002"]]
-```
-
-### Step 5: Compose Into HyperMind Agent
-
-Now we compose all tools into a coherent agent with execution witness.
-
-**Design Thinking:** The agent orchestrates tools as typed morphisms. Each tool has a signature (A → B), and composition is type-safe.
-
-```
-Agent Execution Flow:
-
-┌─────────────────────────────────────────────────────────────────┐
-│                    HyperMindAgent.spawn()                        │
-│                                                                  │
-│  AgentSpec: {                                                    │
-│    name: "fraud-detector",                                       │
-│    model: "claude-sonnet-4",                                     │
-│    tools: [kg.sparql.query, kg.graphframe, kg.embeddings,       │
-│            kg.datalog]                                           │
-│  }                                                               │
-└─────────────────────┬───────────────────────────────────────────┘
-                      │
-                      ▼
-┌─────────────────────────────────────────────────────────────────┐
-│  TOOL 1: kg.sparql.query                                         │
-│  Type: SPARQLQuery → BindingSet                                  │
-│  Input: "SELECT ?claimant WHERE { ?claimant :riskScore ?s . }"  │
-│  Output: [{ claimant: "P001" }, { claimant: "P002" }]           │
-└─────────────────────┬───────────────────────────────────────────┘
-                      │
-                      ▼
-┌─────────────────────────────────────────────────────────────────┐
-│  TOOL 2: kg.graphframe.triangles                                 │
-│  Type: Graph → TriangleCount                                     │
-│  Input: 4 nodes, 5 edges                                         │
-│  Output: 1 triangle (fraud ring indicator)                       │
-└─────────────────────┬───────────────────────────────────────────┘
-                      │
-                      ▼
-┌─────────────────────────────────────────────────────────────────┐
-│  TOOL 3: kg.embeddings.search                                    │
-│  Type: EntityId → List[SimilarEntity]                            │
-│  Input: "CLM001"                                                 │
-│  Output: [{entity:"CLM002", score:0.815}, ...]                  │
-└─────────────────────┬───────────────────────────────────────────┘
-                      │
-                      ▼
-┌─────────────────────────────────────────────────────────────────┐
-│  TOOL 4: kg.datalog.infer                                        │
-│  Type: DatalogProgram → InferredFacts                            │
-│  Input: 9 facts, 2 rules                                         │
-│  Output: { collusion: [...], address_fraud: [...] }             │
-└─────────────────────┬───────────────────────────────────────────┘
-                      │
-                      ▼
-┌─────────────────────────────────────────────────────────────────┐
-│                   EXECUTION WITNESS                              │
-│                                                                  │
-│  {                                                               │
-│    "agent": "fraud-detector",                                    │
-│    "timestamp": "2024-12-14T22:41:34.077Z",                     │
-│    "tools_executed": 4,                                          │
-│    "findings": {                                                 │
-│      "triangles": 1,                                             │
-│      "collusions": 1,                                            │
-│      "addressFraud": 1                                           │
-│    },                                                            │
-│    "proof_hash": "sha256:000000005330d147"                       │
-│  }                                                               │
-└─────────────────────────────────────────────────────────────────┘
-```
-
-**Complete Agent Code:**
-```javascript
-const { HyperMindAgent } = require('rust-kgdb/hypermind-agent')
-const { GraphDB, GraphFrame, EmbeddingService, DatalogProgram, evaluateDatalog } = require('rust-kgdb')
-
-async function runFraudDetectionAgent() {
-  // Step 1: Initialize Knowledge Graph
-  const db = new GraphDB('http://insurance.org/fraud-kb')
-  db.loadTtl(FRAUD_ONTOLOGY, 'http://insurance.org/fraud-kb')
-
-  // Step 2: Spawn Agent
-  const agent = await HyperMindAgent.spawn({
-    name: 'fraud-detector',
-    model: process.env.ANTHROPIC_API_KEY ? 'claude-sonnet-4' : 'mock',
-    tools: ['kg.sparql.query', 'kg.graphframe', 'kg.embeddings.search', 'kg.datalog.apply'],
-    tracing: true
-  })
-
-  // Step 3: Execute Tool Pipeline
-  const findings = {}
-
-  // Tool 1: Query high-risk claimants
-  const highRisk = db.querySelect(`
-    SELECT ?claimant ?score WHERE {
-      ?claimant <http://insurance.org/riskScore> ?score .
-      FILTER(?score > 0.7)
-    }
-  `)
-  findings.highRiskClaimants = highRisk.length
-
-  // Tool 2: Detect fraud rings
-  const gf = new GraphFrame(JSON.stringify(vertices), JSON.stringify(edges))
-  findings.triangles = gf.triangleCount()
-
-  // Tool 3: Find similar claims
-  const embeddings = new EmbeddingService()
-  // ... store vectors ...
-  const similar = JSON.parse(embeddings.findSimilar('CLM001', 5, 0.5))
-  findings.similarClaims = similar.length
-
-  // Tool 4: Infer collusion patterns
-  const datalog = new DatalogProgram()
-  // ... add facts and rules ...
-  const inferred = JSON.parse(evaluateDatalog(datalog))
-  findings.collusions = (inferred.potential_collusion || []).length
-  findings.addressFraud = (inferred.address_fraud_indicator || []).length
-
-  // Step 4: Generate Execution Witness
-  const witness = {
-    agent: agent.getName(),
-    model: agent.getModel(),
-    timestamp: new Date().toISOString(),
-    findings,
-    proof_hash: `sha256:${Date.now().toString(16)}`
-  }
-
-  return { findings, witness }
-}
-```
-
-### Run the Complete Examples
-
-```bash
-# Fraud Detection Agent (full pipeline)
-node examples/fraud-detection-agent.js
-
-# Underwriting Agent (full pipeline)
-node examples/underwriting-agent.js
-
-# With real LLM (Anthropic)
-ANTHROPIC_API_KEY=sk-ant-... node examples/fraud-detection-agent.js
-
-# With real LLM (OpenAI)
-OPENAI_API_KEY=sk-proj-... node examples/underwriting-agent.js
-```
-
-### The Complete Picture
-
-```
-┌──────────────────────────────────────────────────────────────────────────────┐
-│                    HYPERMIND AGENT DESIGN FLOW                                │
-│                                                                               │
-│   ┌─────────────────┐                                                        │
-│   │  Domain Expert  │  "Fraud rings create payment triangles"                │
-│   │   Knowledge     │  "Same address + high risk = address fraud"            │
-│   └────────┬────────┘                                                        │
-│            │                                                                  │
-│            ▼                                                                  │
-│   ┌─────────────────┐                                                        │
-│   │ Knowledge Graph │  RDF/Turtle ontology with NICB patterns               │
-│   │    (GraphDB)    │  Claims, claimants, providers, relationships           │
-│   └────────┬────────┘                                                        │
-│            │                                                                  │
-│   ┌────────┴────────────────────────────────────────────┐                    │
-│   │                                                      │                    │
-│   ▼                        ▼                             ▼                    │
-│   ┌──────────────┐   ┌──────────────┐   ┌──────────────────┐                │
-│   │  GraphFrame  │   │  Embeddings  │   │     Datalog      │                │
-│   │  (Structure) │   │  (Semantics) │   │     (Rules)      │                │
-│   │              │   │              │   │                  │                │
-│   │ • Triangles  │   │ • Similar    │   │ • Collusion rule │                │
-│   │ • PageRank   │   │   claims     │   │ • Address fraud  │                │
-│   │ • Components │   │ • Clustering │   │ • Custom rules   │                │
-│   └──────┬───────┘   └──────┬───────┘   └────────┬─────────┘                │
-│          │                  │                     │                          │
-│          └──────────────────┼─────────────────────┘                          │
-│                             │                                                 │
-│                             ▼                                                 │
-│                   ┌─────────────────┐                                        │
-│                   │  HyperMind Agent│                                        │
-│                   │   Composition   │                                        │
-│                   │                 │                                        │
-│                   │ Type-safe tools │                                        │
-│                   │ Execution proof │                                        │
-│                   │ Audit trail     │                                        │
-│                   └────────┬────────┘                                        │
-│                            │                                                  │
-│                            ▼                                                  │
-│                   ┌─────────────────┐                                        │
-│                   │ ExecutionWitness│                                        │
-│                   │                 │                                        │
-│                   │ • SHA-256 hash  │                                        │
-│                   │ • Timestamp     │                                        │
-│                   │ • Tool trace    │                                        │
-│                   │ • Findings      │                                        │
-│                   └─────────────────┘                                        │
-│                                                                               │
-│  RESULT: Auditable, provable, type-safe fraud detection                      │
-└──────────────────────────────────────────────────────────────────────────────┘
-```
-
-This is the power of HyperMind: **every step is typed, every execution is witnessed, every result is provable.**
-
----
-
-## API Reference
-
-### GraphDB
-
-```typescript
-class GraphDB {
-  constructor(baseUri: string)
-  loadTtl(ttl: string, graphName: string | null): void
-  querySelect(sparql: string): QueryResult[]
-  query(sparql: string): TripleResult[]
-  countTriples(): number
-  clear(): void
-  getGraphUri(): string
-}
-```
-
-### GraphFrame
-
-```typescript
-class GraphFrame {
-  constructor(verticesJson: string, edgesJson: string)
-  vertexCount(): number
-  edgeCount(): number
-  pageRank(resetProb: number, maxIter: number): string
-  connectedComponents(): string
-  shortestPaths(landmarks: string[]): string
-  labelPropagation(maxIter: number): string
-  triangleCount(): number
-  find(pattern: string): string
-}
-```
-
-### EmbeddingService
-
-```typescript
-class EmbeddingService {
-  constructor()
-  isEnabled(): boolean
-  storeVector(entityId: string, vector: number[]): void
-  getVector(entityId: string): number[] | null
-  findSimilar(entityId: string, k: number, threshold: number): string
-  rebuildIndex(): void
-  storeComposite(entityId: string, embeddingsJson: string): void
-  findSimilarComposite(entityId: string, k: number, threshold: number, strategy: string): string
-}
-```
-
-### DatalogProgram
-
-```typescript
-class DatalogProgram {
-  constructor()
-  addFact(factJson: string): void
-  addRule(ruleJson: string): void
-  factCount(): number
-  ruleCount(): number
-}
-
-function evaluateDatalog(program: DatalogProgram): string
-function queryDatalog(program: DatalogProgram, predicate: string): string
-```
-
----
-
-## Architecture
-
-```
-┌──────────────────────────────────────────────────────────────────┐
-│                     Your Application                             │
-│          (Fraud Detection, Underwriting, Compliance)             │
-├──────────────────────────────────────────────────────────────────┤
-│                     rust-kgdb SDK                                │
-│  GraphDB │ GraphFrame │ Embeddings │ Datalog │ HyperMind        │
-├──────────────────────────────────────────────────────────────────┤
-│                  Mathematical Layer                              │
-│  Type Theory │ Category Theory │ Proof Theory │ WASM Sandbox    │
-├──────────────────────────────────────────────────────────────────┤
-│                  Reasoning Layer                                 │
-│  RDFS │ OWL 2 RL │ SHACL │ Datalog │ WCOJ                       │
-├──────────────────────────────────────────────────────────────────┤
-│                   Storage Layer                                  │
-│  InMemory │ RocksDB │ LMDB │ SPOC Indexes │ Dictionary          │
-├──────────────────────────────────────────────────────────────────┤
-│                Distribution Layer                                │
-│  HDRF Partitioning │ Raft Consensus │ gRPC │ Kubernetes         │
-└──────────────────────────────────────────────────────────────────┘
-```
-
----
-
-## Critical Business Cannot Be Built on "Vibe Coding"
-
-```
-╔═══════════════════════════════════════════════════════════════════════════════╗
-║                                                                               ║
-║   "It works on my laptop" is not a deployment strategy.                       ║
-║   "The LLM usually gets it right" is not acceptable for compliance.           ║
-║   "We'll fix it in production" is how companies get fined.                    ║
-║                                                                               ║
-╠═══════════════════════════════════════════════════════════════════════════════╣
-║                                                                               ║
-║   VIBE CODING (LangChain, AutoGPT, etc.):                                     ║
-║                                                                               ║
-║   • "Let's just call the LLM and hope"              → 0% SPARQL accuracy     ║
-║   • "Tools are just functions"                      → Runtime type errors     ║
-║   • "We'll add validation later"                    → Production failures     ║
-║   • "The AI will figure it out"                     → Infinite loops          ║
-║   • "We don't need proofs"                          → No audit trail          ║
-║                                                                               ║
-║   Result: Fails FDA, SOX, GDPR audits. Gets you fired.                        ║
-║                                                                               ║
-╠═══════════════════════════════════════════════════════════════════════════════╣
-║                                                                               ║
-║   HYPERMIND (Mathematical Foundations):                                       ║
-║                                                                               ║
-║   • Type Theory: Errors caught at compile-time     → 86.4% SPARQL accuracy   ║
-║   • Category Theory: Morphism composition          → No runtime type errors  ║
-║   • Proof Theory: ExecutionWitness for every call  → Full audit trail        ║
-║   • WASM Sandbox: Isolated execution               → Zero attack surface     ║
-║   • WCOJ Algorithm: Optimal joins                  → Predictable performance ║
-║                                                                               ║
-║   Result: Passes audits. Ships to production. Keeps your job.                 ║
-║                                                                               ║
-╚═══════════════════════════════════════════════════════════════════════════════╝
-```
-
----
-
-## On AGI, Prompt Optimization, and Mathematical Foundations
-
-### The AGI Distraction
-
-While the industry chases AGI (Artificial General Intelligence) with increasingly large models and prompt tricks, **production systems need correctness NOW** - not eventually, not probably, not "when the model gets better."
-
-HyperMind takes a different stance: **We don't need AGI. We need provably correct tool composition.**
-
-```
-AGI Promise:     "Someday the model will understand everything"
-HyperMind Reality: "Today the system PROVES every operation is type-safe"
-```
-
-### DSPy and Prompt Optimization: A Fundamental Misunderstanding
-
-**DSPy** and similar frameworks optimize prompts through gradient descent and few-shot learning. This is essentially **curve fitting on text** - statistical optimization, not logical proof.
-
-```
-DSPy Approach:
-┌─────────────────────────────────────────────────────────────┐
-│   Input examples → Optimize prompt → Better outputs         │
-│                                                             │
-│   Problem: "Better" is measured statistically               │
-│   Problem: No guarantee on unseen inputs                    │
-│   Problem: Prompt drift over model updates                  │
-│   Problem: Cannot explain WHY it works                      │
-└─────────────────────────────────────────────────────────────┘
-
-HyperMind Approach:
-┌─────────────────────────────────────────────────────────────┐
-│   Type signature → Morphism composition → Proven output     │
-│                                                             │
-│   Guarantee: Type A in → Type B out (always)                │
-│   Guarantee: Composition laws hold (associativity, id)      │
-│   Guarantee: Execution witness (proof of correctness)       │
-│   Guarantee: Explainable via Curry-Howard correspondence    │
-└─────────────────────────────────────────────────────────────┘
-```
-
-### Why Prompt Optimization is the Wrong Abstraction
-
-| Approach | Foundation | Guarantee | Audit |
-|----------|------------|-----------|-------|
-| **Prompt Optimization (DSPy)** | Statistical fitting | Probabilistic | None |
-| **Chain-of-Thought** | Heuristic patterns | Hope-based | None |
-| **Few-Shot Learning** | Example matching | Similarity-based | None |
-| **HyperMind** | Type Theory + Category Theory | Mathematical proof | Full witness |
-
-**The hard truth:**
-
-```
-Prompt optimization CANNOT prove:
-  × That a tool chain terminates
-  × That intermediate types are compatible
-  × That the result satisfies business constraints
-  × That the execution is deterministic
-
-HyperMind PROVES:
-  ✓ Tool chains form valid morphism compositions
-  ✓ Types are checked at compile-time (Hindley-Milner)
-  ✓ Business constraints are refinement types
-  ✓ Every execution has a cryptographic witness
-```
-
-### The Mathematical Difference
-
-**DSPy** says: *"Let's tune the prompt until outputs look right"*
-**HyperMind** says: *"Let's prove the types align, and correctness follows"*
-
-```
-DSPy: P(correct | prompt, examples) ≈ 0.85  (probabilistic)
-HyperMind: ∀x:A. f(x):B                     (universal quantifier - ALWAYS)
-```
-
-This isn't academic distinction. When your fraud detection system flags 15 suspicious patterns, the regulator asks: *"How do you know these are correct?"*
-
-- **DSPy answer**: "Our test set accuracy was 85%"
-- **HyperMind answer**: "Here's the ExecutionWitness with SHA-256 hash, timestamp, and full type derivation"
-
-One passes audit. One doesn't.
-
----
-
-## Code Comparison: DSPy vs HyperMind
-
-### DSPy Approach (Prompt Optimization)
-
-```python
-# DSPy: Statistically optimized prompt - NO guarantees
-
-import dspy
-
-class FraudDetector(dspy.Signature):
-    """Find fraud patterns in claims data."""
-    claims_data = dspy.InputField()
-    fraud_patterns = dspy.OutputField()
-
-class FraudPipeline(dspy.Module):
-    def __init__(self):
-        self.detector = dspy.ChainOfThought(FraudDetector)
-
-    def forward(self, claims):
-        return self.detector(claims_data=claims)
-
-# "Optimize" via statistical fitting
-optimizer = dspy.BootstrapFewShot(metric=some_metric)
-optimized = optimizer.compile(FraudPipeline(), trainset=examples)
-
-# Call and HOPE it works
-result = optimized(claims="[claim data here]")
-
-# ❌ No type guarantee - fraud_patterns could be anything
-# ❌ No proof of execution - just text output
-# ❌ No composition safety - next step might fail
-# ❌ No audit trail - "it said fraud" is not compliance
-```
-
-**What DSPy produces:** A string that *probably* contains fraud patterns.
-
-### HyperMind Approach (Mathematical Proof)
-
-```javascript
-// HyperMind: Type-safe morphism composition - PROVEN correct
-
-const { GraphDB, GraphFrame, DatalogProgram, evaluateDatalog } = require('rust-kgdb')
-
-// Step 1: Load typed knowledge graph (Schema enforced)
-const db = new GraphDB('http://insurance.org/fraud-kb')
-db.loadTtl(`
-  @prefix : <http://insurance.org/> .
-  :CLM001 :amount "18500" ; :claimant :P001 ; :provider :PROV001 .
-  :P001 :paidTo :P002 .
-  :P002 :paidTo :P003 .
-  :P003 :paidTo :P001 .
-`, null)
-
-// Step 2: GraphFrame analysis (Morphism: Graph → TriangleCount)
-// Type signature: GraphFrame → number (guaranteed)
-const graph = new GraphFrame(
-  JSON.stringify([{id:'P001'}, {id:'P002'}, {id:'P003'}]),
-  JSON.stringify([
-    {src:'P001', dst:'P002'},
-    {src:'P002', dst:'P003'},
-    {src:'P003', dst:'P001'}
-  ])
-)
-const triangles = graph.triangleCount()  // Type: number (always)
-
-// Step 3: Datalog inference (Morphism: Rules → Facts)
-// Type signature: DatalogProgram → InferredFacts (guaranteed)
-const datalog = new DatalogProgram()
-datalog.addFact(JSON.stringify({predicate:'claim', terms:['CLM001','P001','PROV001']}))
-datalog.addFact(JSON.stringify({predicate:'related', terms:['P001','P002']}))
-
-datalog.addRule(JSON.stringify({
-  head: {predicate:'collusion', terms:['?P1','?P2','?Prov']},
-  body: [
-    {predicate:'claim', terms:['?C1','?P1','?Prov']},
-    {predicate:'claim', terms:['?C2','?P2','?Prov']},
-    {predicate:'related', terms:['?P1','?P2']}
-  ]
-}))
-
-const result = JSON.parse(evaluateDatalog(datalog))
-
-// ✓ Type guarantee: result.collusion is always array of tuples
-// ✓ Proof of execution: Datalog evaluation is deterministic
-// ✓ Composition safety: Each step has typed input/output
-// ✓ Audit trail: Every fact derivation is traceable
-```
-
-**What HyperMind produces:** Typed results with mathematical proof of derivation.
-
-### Actual Output Comparison
-
-**DSPy Output:**
-```
-fraud_patterns: "I found some suspicious patterns involving P001 and P002
-that appear to be related. There might be collusion with provider PROV001."
-```
-*How do you validate this? You can't. It's text.*
-
-**HyperMind Output:**
-```json
-{
-  "triangles": 1,
-  "collusion": [["P001", "P002", "PROV001"]],
-  "executionWitness": {
-    "tool": "datalog.evaluate",
-    "input": "6 facts, 1 rule",
-    "output": "collusion(P001,P002,PROV001)",
-    "derivation": "claim(CLM001,P001,PROV001) ∧ claim(CLM002,P002,PROV001) ∧ related(P001,P002) → collusion(P001,P002,PROV001)",
-    "timestamp": "2024-12-14T10:30:00Z",
-    "semanticHash": "semhash:collusion-p001-p002-prov001"
-  }
-}
-```
-*Every result has a logical derivation and cryptographic proof.*
-
-### The Compliance Question
-
-**Auditor:** "How do you know P001-P002-PROV001 is actually collusion?"
-
-**DSPy Team:** "Our model said so. It was trained on examples and optimized for accuracy."
-
-**HyperMind Team:** "Here's the derivation chain:
-1. `claim(CLM001, P001, PROV001)` - fact from data
-2. `claim(CLM002, P002, PROV001)` - fact from data
-3. `related(P001, P002)` - fact from data
-4. Rule: `collusion(?P1, ?P2, ?Prov) :- claim(?C1, ?P1, ?Prov), claim(?C2, ?P2, ?Prov), related(?P1, ?P2)`
-5. Unification: `?P1=P001, ?P2=P002, ?Prov=PROV001`
-6. Conclusion: `collusion(P001, P002, PROV001)` - QED
-
-Here's the semantic hash: `semhash:collusion-p001-p002-prov001` - same query intent will always return this exact result."
-
-**Result:** HyperMind passes audit. DSPy gets you a follow-up meeting with legal.
-
-### The Stack That Matters
-
-```
-┌───────────────────────────────────────────────────────────────────────────────┐
-│                                                                               │
-│   HYPERMIND AGENT (this is what you build with)                               │
-│   ├── Natural language → structured queries                                   │
-│   ├── 86.4% accuracy on complex SPARQL generation                            │
-│   └── Full provenance for every decision                                     │
-│                                                                               │
-├───────────────────────────────────────────────────────────────────────────────┤
-│                                                                               │
-│   KNOWLEDGE GRAPH DATABASE (this is what powers it)                           │
-│   ├── 2.78 µs lookups (35x faster than RDFox)                                │
-│   ├── 24 bytes/triple (25% more efficient)                                   │
-│   ├── W3C SPARQL 1.1 + RDF 1.2 (100% compliance)                             │
-│   ├── RDFS + OWL 2 RL reasoners (ontology inference)                         │
-│   ├── SHACL validation (schema enforcement)                                   │
-│   └── WCOJ algorithm (worst-case optimal joins)                              │
-│                                                                               │
-├───────────────────────────────────────────────────────────────────────────────┤
-│                                                                               │
-│   DISTRIBUTION LAYER (this is how it scales)                                  │
-│   ├── Mobile: iOS + Android with zero-copy FFI                               │
-│   ├── Standalone: Single node with RocksDB/LMDB                              │
-│   └── Clustered: Kubernetes with HDRF + Raft consensus                       │
-│                                                                               │
-└───────────────────────────────────────────────────────────────────────────────┘
-```
-
----
-
-## Why This Matters
-
-```
-┌─────────────────────────────────────────────────────────────────┐
-│                    COMPETITIVE LANDSCAPE                        │
-├─────────────────────────────────────────────────────────────────┤
-│                                                                 │
-│  Apache Jena:    Great features, but 150+ µs lookups            │
-│  RDFox:          Fast, but expensive and no mobile support      │
-│  Neo4j:          Popular, but no SPARQL/RDF standards           │
-│  Amazon Neptune: Managed, but cloud-only vendor lock-in         │
-│  LangChain:      Vibe coding, fails compliance audits           │
-│                                                                 │
-│  rust-kgdb:      2.78 µs lookups, mobile-native, open standards │
-│                  Standalone → Clustered on same codebase        │
-│                  Mathematical foundations, audit-ready           │
-│                                                                 │
-└─────────────────────────────────────────────────────────────────┘
-```
-
----
-
-## Contact
-
-**Email:** gonnect.uk@gmail.com
-
-**GitHub:** [github.com/gonnect-uk/rust-kgdb](https://github.com/gonnect-uk/rust-kgdb)
-
-**npm:** [npmjs.com/package/rust-kgdb](https://www.npmjs.com/package/rust-kgdb)
-
----
-
-## License
-
-Apache-2.0
-
----
-
-*Built with Rust. Grounded in mathematics. Ready for production.*