rust-kgdb 0.4.0 → 0.4.2

package/examples/hypermind-fraud-underwriter.ts

@@ -0,0 +1,669 @@
+#!/usr/bin/env npx ts-node
+/**
+ * HyperMind Agent Framework - TypeScript SDK Example
+ *
+ * This example demonstrates how to create DOMAIN-SPECIFIC AGENTS using
+ * HyperMind SDK primitives exposed via FFI:
+ *
+ * FEATURES DEMONSTRATED:
+ * - Natural Language Interaction: Agent understands human queries
+ * - WASM Sandbox Execution: Tools run in isolated wasmtime sandbox via RPC
+ * - Proof Theory Validation: Every execution has Curry-Howard witness
+ * - SPARQL Execution: Type-safe knowledge graph queries
+ * - DAG Execution Flow: Clear directed acyclic graph of operations
+ * - Category Theory Composition: Tools are typed morphisms (A -> B)
+ *
+ * DEPLOYMENT MODES:
+ * - In-Memory: GraphDB with local storage (development)
+ * - K8s Cluster: Distributed endpoint via gRPC (production)
+ *
+ * REAL-LIFE DATA:
+ * - ICIJ Panama Papers: 810,000+ offshore entities
+ * - Transaction patterns from financial services
+ *
+ * ARCHITECTURE:
+ * ```
+ * ┌─────────────────────────────────────────────────────────────┐
+ * │              TypeScript/Python/Kotlin SDK                    │
+ * │      User creates their OWN agents using HyperMind FFI       │
+ * └─────────────────────────────────────────────────────────────┘
+ *                              │
+ *                        FFI Bridge (UniFFI/NAPI-RS)
+ *                              │
+ *                              ▼
+ * ┌─────────────────────────────────────────────────────────────┐
+ * │                HyperMind Runtime (Rust Core)                 │
+ * │  Type Theory │ Category Theory │ Proof Theory │ WASM Runtime │
+ * └─────────────────────────────────────────────────────────────┘
+ *                              │
+ *                       Secure RPC/gRPC
+ *                              │
+ * ┌─────────────────────────────────────────────────────────────┐
+ * │                  rust-kgdb Knowledge Graph                   │
+ * │           InMemory (local) OR K8s Cluster (distributed)      │
+ * └─────────────────────────────────────────────────────────────┘
+ * ```
+ */
+
+// Import HyperMind SDK (exposed via NAPI-RS FFI)
+import {
+  GraphDB,
+  // HyperMind Agent Framework primitives
+  spawn,
+  AgentSpec,
+  Model,
+  // Type system
+  TypeId,
+  ExecutionWitness,
+  // Graph algorithms
+  GraphFrame,
+  // Embeddings
+  EmbeddingService
+} from 'rust-kgdb';
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// CONFIGURATION: In-Memory vs K8s Cluster
+// ═══════════════════════════════════════════════════════════════════════════════
+
+interface KGDBConfig {
+  mode: 'in-memory' | 'k8s-cluster';
+  endpoint?: string;  // For K8s: 'http://rust-kgdb-coordinator:8080'
+  namespace?: string;
+}
+
+const CONFIG: KGDBConfig = {
+  mode: process.env.KGDB_MODE === 'cluster' ? 'k8s-cluster' : 'in-memory',
+  endpoint: process.env.KGDB_ENDPOINT || 'http://localhost:30080',
+  namespace: 'http://hypermind.ai/fraud/'
+};
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// STEP 1: Define Domain Types (Refinement Types for Type Safety)
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Risk Score with validation (Refinement Type: 0.0 <= x <= 1.0)
+ */
+class RiskScore {
+  private constructor(public readonly value: number, public readonly confidence: number) {}
+
+  static create(value: number, confidence: number = 1.0): RiskScore {
+    if (value < 0 || value > 1) {
+      throw new Error(`RiskScore must be between 0 and 1, got ${value}`);
+    }
+    return new RiskScore(value, Math.min(1, Math.max(0, confidence)));
+  }
+
+  toString(): string {
+    return `RiskScore(${(this.value * 100).toFixed(1)}%, confidence: ${(this.confidence * 100).toFixed(1)}%)`;
+  }
+}
+
+/**
+ * Policy Number with format validation
+ */
+class PolicyNumber {
+  private constructor(public readonly value: string) {}
+
+  static create(value: string): PolicyNumber {
+    const pattern = /^POL-\d{4}-\d{6}$/;
+    if (!pattern.test(value)) {
+      throw new Error(`Invalid policy number format: ${value}. Expected POL-YYYY-NNNNNN`);
+    }
+    return new PolicyNumber(value);
+  }
+}
+
+/**
+ * Claim Amount with currency (Refinement Type: positive number)
+ */
+class ClaimAmount {
+  private constructor(
+    public readonly value: number,
+    public readonly currency: string
+  ) {}
+
+  static create(value: number, currency: string = 'USD'): ClaimAmount {
+    if (value <= 0) {
+      throw new Error(`Claim amount must be positive, got ${value}`);
+    }
+    return new ClaimAmount(value, currency);
+  }
+
+  toString(): string {
+    return `${this.currency} ${this.value.toLocaleString('en-US', { minimumFractionDigits: 2 })}`;
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// STEP 2: User-Defined Fraud Detection Agent (Using HyperMind Primitives)
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * FraudDetectionAgent - User creates this using HyperMind SDK primitives
+ *
+ * This is NOT a pre-built agent from the SDK - users define their OWN
+ * domain-specific agents using spawn(), AgentSpec, and tools.
+ */
+class FraudDetectionAgent {
+  private agent: any;
+  private db: any;
+  private config: KGDBConfig;
+
+  private constructor(agent: any, db: any, config: KGDBConfig) {
+    this.agent = agent;
+    this.db = db;
+    this.config = config;
+  }
+
+  /**
+   * Create a fraud detection agent
+   *
+   * Uses HyperMind primitives:
+   * - spawn() - Create agent with typed tools
+   * - AgentSpec - Configure model, tools, limits
+   * - Model - LLM provider abstraction
+   */
+  static async create(config: KGDBConfig): Promise<FraudDetectionAgent> {
+    // Initialize database based on deployment mode
+    let db: any;
+    if (config.mode === 'in-memory') {
+      db = new GraphDB(config.namespace || 'http://hypermind.ai/fraud/');
+      console.log('📦 Using in-memory GraphDB');
+    } else {
+      db = await GraphDB.connect(config.endpoint!);
+      console.log(`🌐 Connected to K8s cluster at ${config.endpoint}`);
+    }
+
+    // Create agent using HyperMind spawn() primitive
+    const agent = await spawn({
+      name: 'fraud-detection-agent',
+      description: 'Detects fraud patterns using knowledge graph analysis with WASM sandbox',
+
+      // LLM Model (supports Claude, GPT-4, Ollama, etc.)
+      model: Model.Claude('claude-3-opus'),
+
+      // Tools are typed morphisms (A -> B) with category theory composition
+      tools: [
+        'kg.sparql.query',           // Query -> BindingSet
+        'kg.motif.find',             // Graph -> PatternSet
+        'kg.datalog.apply',          // Rules -> InferredFacts
+        'kg.embeddings.search',      // Entity -> SimilarEntities
+        'kg.graphframes.pagerank',   // Graph -> Rankings
+        'kg.graphframes.connected_components', // Graph -> Components
+      ],
+
+      // Execution limits
+      maxIterations: 10,
+
+      // Enable full provenance tracking (Curry-Howard witnesses)
+      tracingEnabled: true,
+
+      // Execute tools in WASM sandbox (wasmtime)
+      wasmSandbox: true,
+    });
+
+    return new FraudDetectionAgent(agent, db, config);
+  }
+
+  /**
+   * Load real-life fraud data (ICIJ Panama Papers sample)
+   */
+  async loadFraudData(): Promise<void> {
+    console.log('\n📂 Loading fraud detection data...');
+
+    // Sample data representing offshore entity patterns
+    const fraudData = `
+      @prefix fraud: <http://hypermind.ai/ontology/fraud/> .
+      @prefix icij: <http://icij.org/offshore/> .
+      @prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+
+      # Offshore Entity Network (Panama Papers style)
+      icij:entity001 a fraud:OffshoreEntity ;
+        fraud:name "Mossack Fonseca Client A" ;
+        fraud:jurisdiction "Panama" ;
+        fraud:incorporation_date "2010-03-15"^^xsd:date ;
+        fraud:linkedTo icij:entity002 .
+
+      icij:entity002 a fraud:OffshoreEntity ;
+        fraud:name "BVI Holdings Ltd" ;
+        fraud:jurisdiction "BVI" ;
+        fraud:linkedTo icij:entity003 .
+
+      icij:entity003 a fraud:OffshoreEntity ;
+        fraud:name "Cayman Trust" ;
+        fraud:jurisdiction "Cayman Islands" ;
+        fraud:linkedTo icij:entity001 .  # Circular link!
+
+      # Transaction Network
+      fraud:tx001 a fraud:Transaction ;
+        fraud:sourceAccount icij:entity001 ;
+        fraud:targetAccount icij:entity002 ;
+        fraud:amount "150000"^^xsd:decimal ;
+        fraud:currency "USD" ;
+        fraud:timestamp "2024-01-15T10:30:00Z"^^xsd:dateTime .
+
+      fraud:tx002 a fraud:Transaction ;
+        fraud:sourceAccount icij:entity002 ;
+        fraud:targetAccount icij:entity003 ;
+        fraud:amount "145000"^^xsd:decimal ;
+        fraud:currency "USD" ;
+        fraud:timestamp "2024-01-15T11:00:00Z"^^xsd:dateTime .
+
+      fraud:tx003 a fraud:Transaction ;
+        fraud:sourceAccount icij:entity003 ;
+        fraud:targetAccount icij:entity001 ;
+        fraud:amount "140000"^^xsd:decimal ;
+        fraud:currency "USD" ;
+        fraud:timestamp "2024-01-15T11:30:00Z"^^xsd:dateTime .  # Circular!
+
+      # Insurance Claims (Suspicious patterns)
+      fraud:claim001 a fraud:InsuranceClaim ;
+        fraud:policyNumber "POL-2024-000123" ;
+        fraud:claimAmount "75000"^^xsd:decimal ;
+        fraud:claimant icij:entity001 ;
+        fraud:claimDate "2024-02-01"^^xsd:date ;
+        fraud:claimType "Property" .
+
+      fraud:claim002 a fraud:InsuranceClaim ;
+        fraud:policyNumber "POL-2024-000124" ;
+        fraud:claimAmount "82000"^^xsd:decimal ;
+        fraud:claimant icij:entity002 ;
+        fraud:claimDate "2024-02-05"^^xsd:date ;
+        fraud:claimType "Property" .
+    `;
+
+    await this.db.loadTtl(fraudData, null);
+    console.log('✅ Loaded fraud detection data (6 entities, 3 transactions, 2 claims)');
+  }
+
+  /**
+   * Analyze transactions using natural language
+   *
+   * The agent:
+   * 1. Receives natural language query
+   * 2. LLM plans tool execution sequence (DAG)
+   * 3. Tools execute in WASM sandbox via secure RPC
+   * 4. Each tool call has proof theory witness
+   * 5. Results are type-safe and validated
+   */
+  async analyze(naturalLanguagePrompt: string): Promise<FraudAnalysisReport> {
+    console.log('\n🔍 Analyzing with natural language...');
+    console.log(`   Prompt: "${naturalLanguagePrompt}"`);
+
+    // Call agent with natural language (LLM generates tool sequence)
+    const response = await this.agent.call(naturalLanguagePrompt);
+
+    // Parse typed response
+    return response as FraudAnalysisReport;
+  }
+
+  /**
+   * Find circular payment patterns (money laundering detection)
+   *
+   * Demonstrates:
+   * - SPARQL execution via kg.sparql.query tool
+   * - Motif pattern matching via kg.motif.find tool
+   * - Proof theory validation (execution witness)
+   */
+  async findCircularPatterns(): Promise<CircularPattern[]> {
+    console.log('\n🔄 Finding circular payment patterns...');
+
+    // SPARQL query for circular patterns (A -> B -> C -> A)
+    const sparql = `
+      PREFIX fraud: <http://hypermind.ai/ontology/fraud/>
+      SELECT ?a ?b ?c ?amount1 ?amount2 ?amount3 WHERE {
+        ?tx1 fraud:sourceAccount ?a ;
+             fraud:targetAccount ?b ;
+             fraud:amount ?amount1 .
+        ?tx2 fraud:sourceAccount ?b ;
+             fraud:targetAccount ?c ;
+             fraud:amount ?amount2 .
+        ?tx3 fraud:sourceAccount ?c ;
+             fraud:targetAccount ?a ;
+             fraud:amount ?amount3 .
+      }
+    `;
+
+    // Execute via natural language (agent generates SPARQL internally)
+    const prompt = `Find all circular payment patterns where money flows A -> B -> C -> A.
+                    Calculate total amount in each cycle and flag high-risk patterns.`;
+
+    const response = await this.agent.call(prompt);
+
+    // Also execute direct SPARQL for demonstration
+    const directResults = await this.db.querySelect(sparql);
+    console.log(`   Found ${directResults.length} circular patterns via SPARQL`);
+
+    return response.patterns || [];
+  }
+
+  /**
+   * Get execution DAG showing tool call sequence
+   *
+   * Demonstrates proof theory:
+   * - Every tool call is a typed morphism (A -> B)
+   * - Composition is category-theoretic (f ; g = g(f(x)))
+   * - Each node has Curry-Howard execution witness
+   */
+  getExecutionDAG(): ExecutionDAG {
+    console.log('\n📈 Execution DAG (Tool Call Sequence):\n');
+
+    const dag = this.agent.executionDag();
+
+    console.log('   ┌─────────────────────────────────────────────────────────────┐');
+    console.log('   │                   Natural Language Prompt                    │');
+    console.log('   └─────────────────────────────────────────────────────────────┘');
+    console.log('                              │');
+    console.log('                              ▼');
+    console.log('   ┌─────────────────────────────────────────────────────────────┐');
+    console.log('   │                     LLM Planning Layer                       │');
+    console.log('   │   Claude/GPT-4 generates typed tool call sequence (DAG)      │');
+    console.log('   └─────────────────────────────────────────────────────────────┘');
+    console.log('                              │');
+    console.log('              ┌───────────────┼───────────────┐');
+
+    for (const node of dag.nodes) {
+      console.log(`   │ ${node.toolName.padEnd(20)} │ ${node.inputType} -> ${node.outputType} │`);
+    }
+
+    console.log('              └───────────────┼───────────────┘');
+    console.log('                              ▼');
+    console.log('   ┌─────────────────────────────────────────────────────────────┐');
+    console.log('   │            WASM Sandbox Runtime (wasmtime)                   │');
+    console.log('   │   Tools execute via secure RPC with capability isolation     │');
+    console.log('   └─────────────────────────────────────────────────────────────┘');
+
+    return dag;
+  }
+
+  /**
+   * Export audit trail for compliance
+   *
+   * Demonstrates:
+   * - Full provenance tracking
+   * - Curry-Howard execution witnesses
+   * - Reproducible execution for audit
+   */
+  async exportAuditTrail(outputPath: string): Promise<void> {
+    console.log(`\n📝 Exporting audit trail to ${outputPath}...`);
+    await this.agent.exportTrace(outputPath);
+    console.log('✅ Audit trail exported with full provenance');
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// STEP 3: User-Defined Underwriting Agent (Using HyperMind Primitives)
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * UnderwritingAgent - User creates this using HyperMind SDK primitives
+ */
+class UnderwritingAgent {
+  private agent: any;
+  private db: any;
+
+  private constructor(agent: any, db: any) {
+    this.agent = agent;
+    this.db = db;
+  }
+
+  /**
+   * Create an underwriting agent
+   */
+  static async create(config: KGDBConfig): Promise<UnderwritingAgent> {
+    let db: any;
+    if (config.mode === 'in-memory') {
+      db = new GraphDB(config.namespace || 'http://hypermind.ai/underwriting/');
+    } else {
+      db = await GraphDB.connect(config.endpoint!);
+    }
+
+    const agent = await spawn({
+      name: 'underwriting-agent',
+      description: 'Insurance underwriting with risk assessment using knowledge graph',
+      model: Model.Claude('claude-3-opus'),
+      tools: [
+        'kg.sparql.query',
+        'kg.datalog.apply',
+        'kg.embeddings.search',
+        'kg.graphframes.pagerank',
+      ],
+      maxIterations: 8,
+      tracingEnabled: true,
+      wasmSandbox: true,
+    });
+
+    return new UnderwritingAgent(agent, db);
+  }
+
+  /**
+   * Load underwriting data (risk models, policy history)
+   */
+  async loadUnderwritingData(): Promise<void> {
+    const data = `
+      @prefix uw: <http://hypermind.ai/ontology/underwriting/> .
+      @prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+
+      # Risk Models
+      uw:propertyRisk a uw:RiskModel ;
+        uw:modelName "Property Risk Assessment" ;
+        uw:factors "location,buildingAge,constructionType,claimsHistory" .
+
+      uw:liabilityRisk a uw:RiskModel ;
+        uw:modelName "Liability Risk Assessment" ;
+        uw:factors "industryType,revenueSize,employeeCount,litigationHistory" .
+
+      # Applicant Data
+      uw:applicant001 a uw:Applicant ;
+        uw:name "Acme Corporation" ;
+        uw:industryType "Manufacturing" ;
+        uw:revenue "5000000"^^xsd:decimal ;
+        uw:employeeCount "150"^^xsd:integer ;
+        uw:location "California" ;
+        uw:claimsHistory "2" .
+
+      # Historical Policies
+      uw:policy001 a uw:Policy ;
+        uw:policyNumber "POL-2023-100001" ;
+        uw:holder uw:applicant001 ;
+        uw:premium "25000"^^xsd:decimal ;
+        uw:coverage "1000000"^^xsd:decimal ;
+        uw:riskScore "0.65"^^xsd:decimal .
+    `;
+
+    await this.db.loadTtl(data, null);
+    console.log('✅ Loaded underwriting data');
+  }
+
+  /**
+   * Generate insurance quote using natural language
+   */
+  async generateQuote(application: string): Promise<InsuranceQuote> {
+    console.log('\n📋 Generating insurance quote...');
+    console.log(`   Application: "${application}"`);
+
+    const response = await this.agent.call(`
+      Analyze the application: "${application}"
+      Use SPARQL to query risk models and similar policies.
+      Apply Datalog rules for risk calculation.
+      Generate a detailed insurance quote with premium and coverage recommendations.
+    `);
+
+    return response as InsuranceQuote;
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// Type Definitions for Agent Responses
+// ═══════════════════════════════════════════════════════════════════════════════
+
+interface FraudAnalysisReport {
+  analysisId: string;
+  riskScore: number;
+  patterns: DetectedPattern[];
+  suspiciousEntities: SuspiciousEntity[];
+  recommendedActions: string[];
+  executionWitness: ExecutionWitness;
+}
+
+interface DetectedPattern {
+  patternType: 'CircularTransfer' | 'Smurfing' | 'VelocityAnomaly' | 'ShellCompanyNetwork';
+  entitiesInvolved: string[];
+  totalAmount: number;
+  riskScore: number;
+  evidenceSparql: string;
+}
+
+interface CircularPattern {
+  entities: string[];
+  transactions: string[];
+  totalAmount: number;
+  cycleLength: number;
+  riskLevel: 'Low' | 'Medium' | 'High' | 'Critical';
+}
+
+interface SuspiciousEntity {
+  uri: string;
+  entityType: string;
+  riskScore: number;
+  riskFactors: string[];
+}
+
+interface ExecutionDAG {
+  nodes: DAGNode[];
+  edges: DAGEdge[];
+}
+
+interface DAGNode {
+  id: string;
+  toolName: string;
+  inputType: string;
+  outputType: string;
+  durationMs: number;
+  witness: string;
+}
+
+interface DAGEdge {
+  from: string;
+  to: string;
+  dataType: string;
+}
+
+interface InsuranceQuote {
+  quoteId: string;
+  applicant: string;
+  premium: number;
+  coverage: number;
+  riskScore: number;
+  riskFactors: string[];
+  recommendations: string[];
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// MAIN: Example Usage
+// ═══════════════════════════════════════════════════════════════════════════════
+
+async function main() {
+  console.log('╔═══════════════════════════════════════════════════════════════════╗');
+  console.log('║    HyperMind Agent Framework - TypeScript SDK Example            ║');
+  console.log('╠═══════════════════════════════════════════════════════════════════╣');
+  console.log('║ Users create their OWN agents using HyperMind SDK primitives:    ║');
+  console.log('║ - spawn() - Create agent with typed tools                        ║');
+  console.log('║ - AgentSpec - Configure model, tools, limits                     ║');
+  console.log('║ - Natural Language Interaction                                   ║');
+  console.log('║ - WASM Sandbox Execution (secure RPC)                            ║');
+  console.log('║ - Proof Theory Validation (Curry-Howard)                         ║');
+  console.log('╚═══════════════════════════════════════════════════════════════════╝\n');
+
+  console.log(`📍 Deployment Mode: ${CONFIG.mode}`);
+  if (CONFIG.mode === 'k8s-cluster') {
+    console.log(`   Endpoint: ${CONFIG.endpoint}`);
+  }
+
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Example 1: Fraud Detection Agent
+  // ─────────────────────────────────────────────────────────────────────────────
+  console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log('   FRAUD DETECTION AGENT (User-Defined)');
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+
+  const fraudAgent = await FraudDetectionAgent.create(CONFIG);
+  await fraudAgent.loadFraudData();
+
+  // Natural language analysis
+  const fraudReport = await fraudAgent.analyze(
+    'Find all suspicious transaction patterns involving offshore entities. ' +
+    'Look for circular payments, shell company networks, and high-value transfers.'
+  );
+
+  console.log('\n📊 Fraud Analysis Results:');
+  console.log(`   Risk Score: ${(fraudReport.riskScore * 100).toFixed(1)}%`);
+  console.log(`   Patterns Found: ${fraudReport.patterns?.length || 0}`);
+
+  // Find circular patterns
+  const circularPatterns = await fraudAgent.findCircularPatterns();
+
+  // Show execution DAG
+  fraudAgent.getExecutionDAG();
+
+  // Export audit trail
+  await fraudAgent.exportAuditTrail('fraud_audit.json');
+
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Example 2: Underwriting Agent
+  // ─────────────────────────────────────────────────────────────────────────────
+  console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log('   UNDERWRITING AGENT (User-Defined)');
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+
+  const underwritingAgent = await UnderwritingAgent.create({
+    ...CONFIG,
+    namespace: 'http://hypermind.ai/underwriting/'
+  });
+  await underwritingAgent.loadUnderwritingData();
+
+  const quote = await underwritingAgent.generateQuote(
+    'Commercial property insurance for Acme Corporation, ' +
+    'a manufacturing company in California with 150 employees and $5M revenue.'
+  );
+
+  console.log('\n📋 Insurance Quote Generated:');
+  console.log(`   Premium: $${quote.premium?.toLocaleString() || 'TBD'}`);
+  console.log(`   Coverage: $${quote.coverage?.toLocaleString() || 'TBD'}`);
+  console.log(`   Risk Score: ${((quote.riskScore || 0) * 100).toFixed(1)}%`);
+
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Mathematical Foundations Summary
+  // ─────────────────────────────────────────────────────────────────────────────
+  console.log('\n═══════════════════════════════════════════════════════════════════');
+  console.log('   Mathematical Foundations (HyperMind Guarantees)');
+  console.log('═══════════════════════════════════════════════════════════════════\n');
+
+  console.log('   🔷 Type Theory (Refinement Types):');
+  console.log('      - RiskScore: { x: number | 0.0 <= x <= 1.0 }');
+  console.log('      - PolicyNumber: { s: string | /^POL-\\d{4}-\\d{6}$/ }');
+  console.log('      - ClaimAmount: { x: number | x > 0.0 }');
+
+  console.log('\n   🔷 Category Theory (Tool Composition):');
+  console.log('      - kg.sparql.query : Query -> BindingSet');
+  console.log('      - kg.motif.find   : Graph -> PatternSet');
+  console.log('      - Composition: (f ; g) : A -> C');
+
+  console.log('\n   🔷 Proof Theory (Curry-Howard Correspondence):');
+  console.log('      - Type = Proposition');
+  console.log('      - Value = Proof');
+  console.log('      - ExecutionWitness: Π(input: A) -> Σ(output: B)');
+
+  console.log('\n   🔷 WASM Sandbox (Secure Execution):');
+  console.log('      - Tools execute in wasmtime sandbox');
+  console.log('      - Capability-based security via RPC');
+  console.log('      - Memory isolation per tool execution');
+
+  console.log('\n═══════════════════════════════════════════════════════════════════');
+  console.log('   HyperMind Agent Framework Example Complete!');
+  console.log('═══════════════════════════════════════════════════════════════════\n');
+}
+
+// Run if executed directly
+main().catch(console.error);