agentic-flow 2.0.14 → 2.1.0

package/README.md

@@ -1,12 +1,23 @@
-# 🚀 Agentic-Flow v2
+# 🚀 Agentic-Flow v2 — the Agentic Meta-Harness
 
-> **Production-ready AI agent orchestration with 66 self-learning agents, 213 MCP tools, and autonomous multi-agent swarms.**
+> **Freeze the model, evolve the harness.** Agentic-Flow is an open _agentic meta-harness_: a runtime whose product is the **harness around a model**, not the model. It routes each query to the cost-optimal model, evolves its own harness and autonomously repairs code, then orchestrates 66 self-learning agents, 213 MCP tools, and multi-agent swarms on top.
 
 [![npm version](https://badge.fury.io/js/agentic-flow.svg)](https://www.npmjs.com/package/agentic-flow)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.9-blue.svg)](https://www.typescriptlang.org/)
 [![Node.js](https://img.shields.io/badge/Node.js-18%2B-green.svg)](https://nodejs.org/)
 
+### The four pillars of the meta-harness
+
+| Pillar             | What it does                                                                                                                            | Powered by                                                                                           |
+| ------------------ | --------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------- |
+| 🧭 **Route**       | Send each query to the _cheapest model predicted to clear a quality bar_, learned from eval logs                                        | `@metaharness/router` ([ADR-073](docs/adr/ADR-073-metaharness-router-cost-optimal-model-routing.md)) |
+| 🧬 **Evolve**      | Improve the harness itself (planner/context/reviewer/retry/tool/memory/score) and autonomously repair code — same model, better results | `@metaharness/darwin` ([ADR-074](docs/adr/ADR-074-metaharness-darwin-test-driven-repair.md))         |
+| 🤝 **Orchestrate** | Run 66 agents, 213 MCP tools, ReasoningBank memory, and multi-agent swarms                                                              | Claude Agent SDK + AgentDB                                                                           |
+| 🔏 **Verify**      | Frozen scorer + safety gate on every harness change; signed harness provenance                                                          | Darwin safety gate ([ADR-075](docs/adr/ADR-075-metaharness-harness-evolution-and-provenance.md))     |
+
+> **Why a meta-harness?** The measured lever in modern agentic systems is the _harness_, not a bigger model: a cheap model in a well-built, self-improving harness matches a frontier model at a fraction of the cost (see the [DRACO/Darwin](https://github.com/ruvnet/agent-harness-generator) findings). Agentic-Flow is the open runtime that operates that harness.
+
 ---
 
 ## ⚡ Quick Start (60 seconds)
@@ -23,6 +34,7 @@ claude
 ```
 
 That's it! Your project now has:
+
 - 🧠 **Self-learning hooks** that improve agent routing over time
 - 🤖 **80+ specialized agents** (coder, tester, reviewer, architect, etc.)
 - ⚡ **Background workers** triggered by keywords (ultralearn, optimize, audit)
@@ -47,13 +59,13 @@ npx agentic-flow mcp start
 ### Use in Code
 
 ```typescript
-import { AgenticFlow } from 'agentic-flow';
+import { AgenticFlow } from "agentic-flow";
 
 const flow = new AgenticFlow();
 await flow.initialize();
 
 // Route task to best agent
-const result = await flow.route('Fix the login bug');
+const result = await flow.route("Fix the login bug");
 console.log(`Best agent: ${result.agent} (${result.confidence}% confidence)`);
 ```
 
@@ -64,14 +76,14 @@ Build systems, IDEs, and CI can drive orchestration **in-process** without spawn
 **Generic client** (recommended for build agents — stable input/output: task description, memory seed, paths, provenance):
 
 ```ts
-import { createOrchestrationClient } from 'agentic-flow/orchestration';
+import { createOrchestrationClient } from "agentic-flow/orchestration";
 
-const client = createOrchestrationClient({ config: { backend: 'safe-exec' } });
+const client = createOrchestrationClient({ config: { backend: "safe-exec" } });
 const { runId } = await client.startRun({
-  taskDescription: 'Your task',
-  acceptanceCriteria: ['Tests pass'],
-  allowedPaths: ['src/'],
-  provenance: { runId: 'build-1', cardId: 'card-42' },
+  taskDescription: "Your task",
+  acceptanceCriteria: ["Tests pass"],
+  allowedPaths: ["src/"],
+  provenance: { runId: "build-1", cardId: "card-42" },
 });
 const status = await client.getStatus(runId);
 ```
@@ -105,6 +117,75 @@ Agentic-Flow v2 now includes **ALL** advanced vector/graph, GNN, and attention c
 
 **Performance Grade: A+ (100% Pass Rate)**
 
+### **Cost-Optimal Model Routing (ADR-073)** 💰
+
+Route each query to the **cheapest model predicted to clear a quality bar**, learned
+from your own eval logs — the productized [DRACO](https://github.com/ruvnet/agent-harness-generator)
+finding, powered by [`@metaharness/router`](https://www.npmjs.com/package/@metaharness/router)
+(dependency-free k-NN / kernel-ridge, optional native FastGRNN via the already-bundled
+`@ruvector/tiny-dancer`). This is **additive** to the existing config-rule routing — it
+selects a _model_ by predicted cost-quality rather than a provider by static rule, and
+degrades gracefully to best-predicted on a cold start.
+
+```ts
+import { ModelRouter } from "agentic-flow";
+import { CostOptimalRouter } from "agentic-flow/router/cost-optimal";
+
+// Build from your eval logs: rows of (query embedding → quality each model achieved)
+const router = CostOptimalRouter.fromDataset(
+  rows,
+  {
+    "anthropic/claude-haiku-4.5": 1, // $/Mtok
+    "anthropic/claude-sonnet-4.5": 3,
+    "anthropic/claude-opus-4": 15,
+  },
+  { qualityBar: 0.8 },
+);
+
+const model = new ModelRouter();
+model.enableCostOptimalRouting({ router, embed: yourEmbedder });
+// chat() now routes each query to the cheapest model predicted to clear 0.8.
+```
+
+**Measured** (`node benchmarks/cost-optimal-router-benchmark.mjs`, 3-tier lineup,
+1000-query held-out test, bar=0.8):
+
+| Strategy         | avg $/query | mean quality | % ≥ bar   |
+| ---------------- | ----------- | ------------ | --------- |
+| always-haiku     | 1.00        | 0.412        | 14.1%     |
+| always-opus      | 15.00       | 0.930        | 100%      |
+| **cost-optimal** | **10.73**   | **0.895**    | **98.1%** |
+
+→ **28.5% cheaper than always-opus** while holding **98.1%** of queries at/above the bar.
+Routing decision latency: **p50 73µs · p99 125µs**.
+
+### **Autonomous Repair — Darwin Mode (ADR-074)** 🔧
+
+Freeze the model, **evolve the harness**: `@metaharness/darwin` mutates one policy
+surface at a time (planner / context / reviewer / retry / tool / memory / score),
+tests each in a **shell-free, env-scrubbed sandbox**, and keeps only what
+_measurably_ improves under a frozen scorer + safety gate. Exposed as a typed
+`repair()` wrapper and the `agentic-flow-repair` CLI:
+
+```bash
+# Test-Driven Repair: the repo's own tests gate every promotion
+npx agentic-flow-repair ./my-repo --generations 3
+# Deterministic, Docker-free smoke run
+npx agentic-flow-repair ./my-repo --mock
+```
+
+```ts
+import { repair } from "agentic-flow/repair";
+const result = await repair({ repoRoot: "./my-repo", generations: 3 }); // sandbox 'real'
+// → { improved, winnerId, winnerLineage, baselineScore, winnerScore, deltaOverBaseline }
+```
+
+The sandbox is consistent with the repo's CWE-78 hardening (test command run via
+`execFile`, never a shell; only `PATH` + identifying vars reach a variant). The
+headline SWE-bench-Lite TDR _product_ (≈68.3% with-test, ~$0.01–0.08/instance)
+additionally needs the official `swebench` Docker harness — see
+[ADR-074](docs/adr/ADR-074-metaharness-darwin-test-driven-repair.md).
+
 ---
 
 ## 📖 Table of Contents
@@ -128,30 +209,35 @@ Agentic-Flow v2 now includes **ALL** advanced vector/graph, GNN, and attention c
 ### 🎓 SONA: Self-Optimizing Neural Architecture
 
 **Adaptive Learning** (<1ms Overhead)
+
 - Sub-millisecond pattern learning and retrieval
 - 300x faster than traditional approaches (150ms → 0.5ms)
 - Real-time adaptation during task execution
 - No performance degradation
 
 **LoRA Fine-Tuning** (99% Parameter Reduction)
+
 - Rank-2 Micro-LoRA: 2211 ops/sec
 - Rank-16 Base-LoRA: +55% quality improvement
 - 10-100x faster training than full fine-tuning
 - Minimal memory footprint (<5MB for edge devices)
 
 **Continual Learning** (EWC++)
+
 - No catastrophic forgetting
 - Learn new tasks while preserving old knowledge
 - EWC lambda 2000-2500 for optimal memory preservation
 - Cross-agent pattern sharing
 
 **LLM Router** (60% Cost Savings)
+
 - Intelligent model selection (Sonnet vs Haiku)
 - Quality-aware routing (0.8-0.95 quality scores)
 - Budget constraints and fallback handling
 - $720/month → $288/month savings
 
 **Quality Improvements by Domain**:
+
 - Code tasks: +5.0%
 - Creative writing: +4.3%
 - Reasoning: +3.6%
@@ -159,6 +245,7 @@ Agentic-Flow v2 now includes **ALL** advanced vector/graph, GNN, and attention c
 - Math: +1.2%
 
 **5 Configuration Profiles**:
+
 - **Real-Time**: 2200 ops/sec, <0.5ms latency
 - **Batch**: Balance throughput & adaptation
 - **Research**: +55% quality (maximum)
@@ -168,32 +255,38 @@ Agentic-Flow v2 now includes **ALL** advanced vector/graph, GNN, and attention c
 ### 🧠 Advanced Attention Mechanisms
 
 **Flash Attention** (Production-Ready)
+
 - 2.49x speedup in JavaScript runtime
 - 7.47x speedup with NAPI runtime
 - 50-75% memory reduction
 - <0.1ms latency for all operations
 
 **Multi-Head Attention** (Standard Transformer)
+
 - 8-head configuration
 - Compatible with existing systems
 - <0.1ms latency
 
 **Linear Attention** (Scalable)
+
 - O(n) complexity
 - Perfect for long sequences (>2048 tokens)
 - <0.1ms latency
 
 **Hyperbolic Attention** (Hierarchical)
+
 - Models hierarchical structures
 - Queen-worker swarm coordination
 - <0.1ms latency
 
 **MoE Attention** (Expert Routing)
+
 - Sparse expert activation
 - Multi-agent routing
 - <0.1ms latency
 
 **GraphRoPE** (Topology-Aware)
+
 - Graph structure awareness
 - Swarm coordination
 - <0.1ms latency
@@ -208,12 +301,14 @@ Agentic-Flow v2 now includes **ALL** advanced vector/graph, GNN, and attention c
 ### 🤖 66 Self-Learning Specialized Agents
 
 **All agents now feature v2.0.0-alpha self-learning capabilities**:
+
 - 🧠 **ReasoningBank Integration**: Learn from past successes and failures
 - 🎯 **GNN-Enhanced Context**: +12.4% better accuracy in finding relevant information
 - ⚡ **Flash Attention**: 2.49x-7.47x faster processing
 - 🤝 **Attention Coordination**: Smarter multi-agent consensus
 
 **Core Development** (Self-Learning Enabled)
+
 - `coder` - Learns code patterns, implements faster with GNN context
 - `reviewer` - Pattern-based issue detection, attention consensus reviews
 - `tester` - Learns from test failures, generates comprehensive tests
@@ -221,6 +316,7 @@ Agentic-Flow v2 now includes **ALL** advanced vector/graph, GNN, and attention c
 - `researcher` - GNN-enhanced pattern recognition, attention synthesis
 
 **Swarm Coordination** (Advanced Attention Mechanisms)
+
 - `hierarchical-coordinator` - Hyperbolic attention for queen-worker models
 - `mesh-coordinator` - Multi-head attention for peer consensus
 - `adaptive-coordinator` - Dynamic mechanism selection (flash/multi-head/linear/hyperbolic/moe)
@@ -228,14 +324,17 @@ Agentic-Flow v2 now includes **ALL** advanced vector/graph, GNN, and attention c
 - `swarm-memory-manager` - Cross-agent learning patterns
 
 **Consensus & Distributed**
+
 - `byzantine-coordinator`, `raft-manager`, `gossip-coordinator`
 - `crdt-synchronizer`, `quorum-manager`, `security-manager`
 
 **Performance & Optimization**
+
 - `perf-analyzer`, `performance-benchmarker`, `task-orchestrator`
 - `memory-coordinator`, `smart-agent`
 
 **GitHub & Repository** (Intelligent Code Analysis)
+
 - `pr-manager` - Smart merge strategies, attention-based conflict resolution
 - `code-review-swarm` - Pattern-based issue detection, GNN code search
 - `issue-tracker` - Smart classification, attention priority ranking
@@ -243,6 +342,7 @@ Agentic-Flow v2 now includes **ALL** advanced vector/graph, GNN, and attention c
 - `workflow-automation` - Pattern-based workflow generation
 
 **SPARC Methodology** (Continuous Improvement)
+
 - `specification` - Learn from past specs, GNN requirement analysis
 - `pseudocode` - Algorithm pattern library, MoE optimization
 - `architecture` - Flash attention for large docs, pattern-based design
@@ -297,24 +397,28 @@ Agentic-Flow v2 now includes **ALL** advanced vector/graph, GNN, and attention c
 ### For Developers
 
 ✅ **Faster Development**
+
 - Pre-built agents for common tasks
 - Auto-spawning based on file types
 - Smart code completion and editing
 - 352x faster local code edits with Agent Booster
 
 ✅ **Better Performance**
+
 - 2.49x-7.47x speedup with Flash Attention
 - 150x-12,500x faster vector search
 - 50% memory reduction for long sequences
 - <0.1ms latency for all attention operations
 
 ✅ **Easier Integration**
+
 - Type-safe TypeScript APIs
 - Comprehensive documentation (2,500+ lines)
 - Quick start guides and examples
 - 100% backward compatible
 
 ✅ **Production-Ready**
+
 - Battle-tested in real-world scenarios
 - Enterprise-grade error handling
 - Performance metrics tracking
@@ -323,24 +427,28 @@ Agentic-Flow v2 now includes **ALL** advanced vector/graph, GNN, and attention c
 ### For Businesses
 
 💰 **Cost Savings**
+
 - 32.3% token reduction with smart coordination
 - Faster task completion (2.8-4.4x speedup)
 - Reduced infrastructure costs
 - Open-source, no vendor lock-in
 
 📈 **Scalability**
+
 - Horizontal scaling with swarm coordination
 - Distributed consensus protocols
 - Dynamic topology optimization
 - Auto-scaling based on load
 
 🔒 **Security**
+
 - Quantum-resistant cryptography
 - Byzantine fault tolerance
 - Ed25519 signature verification
 - Secure QUIC transport
 
 🎯 **Competitive Advantage**
+
 - State-of-the-art attention mechanisms
 - +12.4% better recall with GNN
 - Attention-based multi-agent consensus
@@ -349,6 +457,7 @@ Agentic-Flow v2 now includes **ALL** advanced vector/graph, GNN, and attention c
 ### For Researchers
 
 🔬 **Cutting-Edge Features**
+
 - Flash Attention implementation
 - GNN query refinement
 - Hyperbolic attention for hierarchies
@@ -356,12 +465,14 @@ Agentic-Flow v2 now includes **ALL** advanced vector/graph, GNN, and attention c
 - GraphRoPE position embeddings
 
 📊 **Comprehensive Benchmarks**
+
 - Grade A performance validation
 - Detailed performance analysis
 - Open benchmark suite
 - Reproducible results
 
 🧪 **Extensible Architecture**
+
 - Modular design
 - Custom agent creation
 - Plugin system
@@ -406,6 +517,7 @@ console.log(`Best solution: ${response.consensus}`);
 ```
 
 **Benefits**:
+
 - 2.49x faster response times
 - +12.4% better solution accuracy
 - Handles 50% more concurrent requests
@@ -414,27 +526,32 @@ console.log(`Best solution: ${response.consensus}`);
 #### 2. **Automated Code Review & CI/CD**
 
 ```typescript
-import { Task } from 'agentic-flow';
+import { Task } from "agentic-flow";
 
 // Spawn parallel code review agents
 await Promise.all([
-  Task('Security Auditor', 'Review for vulnerabilities', 'reviewer'),
-  Task('Performance Analyzer', 'Check optimization opportunities', 'perf-analyzer'),
-  Task('Style Checker', 'Verify code standards', 'code-analyzer'),
-  Task('Test Engineer', 'Validate test coverage', 'tester'),
+  Task("Security Auditor", "Review for vulnerabilities", "reviewer"),
+  Task(
+    "Performance Analyzer",
+    "Check optimization opportunities",
+    "perf-analyzer",
+  ),
+  Task("Style Checker", "Verify code standards", "code-analyzer"),
+  Task("Test Engineer", "Validate test coverage", "tester"),
 ]);
 
 // Automatic PR creation and management
-import { mcp__claude_flow__github_pr_manage } from 'agentic-flow/mcp';
+import { mcp__claude_flow__github_pr_manage } from "agentic-flow/mcp";
 
 await mcp__claude_flow__github_pr_manage({
-  repo: 'company/product',
-  action: 'review',
+  repo: "company/product",
+  action: "review",
   pr_number: 123,
 });
 ```
 
 **Benefits**:
+
 - 84.8% SWE-Bench solve rate
 - 2.8-4.4x faster code reviews
 - Parallel agent execution
@@ -464,6 +581,7 @@ const specializedRecs = await coordinator.routeToExperts(
 ```
 
 **Benefits**:
+
 - Better recommendations with hierarchical attention
 - Specialized agents for different product categories
 - 50% memory reduction for large catalogs
@@ -478,7 +596,7 @@ const specializedRecs = await coordinator.routeToExperts(
 const paperAnalysis = await wrapper.linearAttention(
   queryEmbedding,
   paperSectionEmbeddings,
-  paperSectionEmbeddings
+  paperSectionEmbeddings,
 );
 
 // GNN-enhanced citation network search
@@ -496,6 +614,7 @@ console.log(`Recall improved by ${relatedPapers.improvementPercent}%`);
 ```
 
 **Benefits**:
+
 - O(n) complexity for long documents
 - +12.4% better citation discovery
 - Graph-aware literature search
@@ -534,6 +653,7 @@ console.log(`Top contributors: ${consensus.topAgents.map(a => a.agentId)}`);
 ```
 
 **Benefits**:
+
 - Models hierarchical research structures
 - Queens (PIs) have higher influence
 - Better consensus than simple voting
@@ -544,14 +664,14 @@ console.log(`Top contributors: ${consensus.topAgents.map(a => a.agentId)}`);
 ```typescript
 // Use attention-based multi-agent analysis
 const dataAnalysisAgents = [
-  { agentId: 'statistician', output: 'p < 0.05', embedding: statEmbed },
-  { agentId: 'ml-expert', output: '95% accuracy', embedding: mlEmbed },
-  { agentId: 'domain-expert', output: 'Novel finding', embedding: domainEmbed },
+  { agentId: "statistician", output: "p < 0.05", embedding: statEmbed },
+  { agentId: "ml-expert", output: "95% accuracy", embedding: mlEmbed },
+  { agentId: "domain-expert", output: "Novel finding", embedding: domainEmbed },
 ];
 
 const analysis = await coordinator.coordinateAgents(
   dataAnalysisAgents,
-  'flash' // 2.49x faster
+  "flash", // 2.49x faster
 );
 
 console.log(`Consensus analysis: ${analysis.consensus}`);
@@ -559,6 +679,7 @@ console.log(`Confidence scores: ${analysis.attentionWeights}`);
 ```
 
 **Benefits**:
+
 - Multi-perspective data analysis
 - Attention-weighted consensus
 - 2.49x faster coordination
@@ -585,6 +706,7 @@ console.log(`Pipeline result: ${docPipeline.consensus}`);
 ```
 
 **Benefits**:
+
 - Topology-aware coordination (ring, mesh, hierarchical, star)
 - GraphRoPE position embeddings
 - <0.1ms coordination latency
@@ -594,17 +716,14 @@ console.log(`Pipeline result: ${docPipeline.consensus}`);
 
 ```typescript
 // Fast, accurate enterprise search
-const searchResults = await wrapper.gnnEnhancedSearch(
-  searchQuery,
-  {
-    k: 50,
-    graphContext: {
-      nodes: documentEmbeddings,
-      edges: documentRelations,
-      edgeWeights: relevanceScores,
-    },
-  }
-);
+const searchResults = await wrapper.gnnEnhancedSearch(searchQuery, {
+  k: 50,
+  graphContext: {
+    nodes: documentEmbeddings,
+    edges: documentRelations,
+    edgeWeights: relevanceScores,
+  },
+});
 
 console.log(`Found ${searchResults.results.length} documents`);
 console.log(`Baseline recall: ${searchResults.originalRecall}`);
@@ -613,6 +732,7 @@ console.log(`Improvement: +${searchResults.improvementPercent}%`);
 ```
 
 **Benefits**:
+
 - 150x-12,500x faster than brute force
 - +12.4% better recall with GNN
 - Graph-aware document relations
@@ -621,25 +741,24 @@ console.log(`Improvement: +${searchResults.improvementPercent}%`);
 #### 3. **Intelligent Workflow Automation**
 
 ```typescript
-import { mcp__claude_flow__workflow_create } from 'agentic-flow/mcp';
+import { mcp__claude_flow__workflow_create } from "agentic-flow/mcp";
 
 // Create automated workflow
 await mcp__claude_flow__workflow_create({
-  name: 'invoice-processing',
+  name: "invoice-processing",
   steps: [
-    { agent: 'ocr', task: 'Extract text from PDF' },
-    { agent: 'nlp', task: 'Parse invoice fields' },
-    { agent: 'validator', task: 'Validate amounts' },
-    { agent: 'accountant', task: 'Record in ledger' },
-    { agent: 'notifier', task: 'Send confirmation email' },
-  ],
-  triggers: [
-    { event: 'email-received', pattern: 'invoice.*\\.pdf' },
+    { agent: "ocr", task: "Extract text from PDF" },
+    { agent: "nlp", task: "Parse invoice fields" },
+    { agent: "validator", task: "Validate amounts" },
+    { agent: "accountant", task: "Record in ledger" },
+    { agent: "notifier", task: "Send confirmation email" },
   ],
+  triggers: [{ event: "email-received", pattern: "invoice.*\\.pdf" }],
 });
 ```
 
 **Benefits**:
+
 - Event-driven automation
 - Multi-agent task orchestration
 - Error handling and recovery
@@ -651,66 +770,66 @@ await mcp__claude_flow__workflow_create({
 
 ### Flash Attention Performance (Grade A)
 
-| Metric | Target | Achieved | Status |
-|--------|--------|----------|--------|
-| **Speedup (JS Runtime)** | 1.5x-4.0x | **2.49x** | ✅ PASS |
-| **Speedup (NAPI Runtime)** | 4.0x+ | **7.47x** | ✅ EXCEED |
-| **Memory Reduction** | 50%-75% | **~50%** | ✅ PASS |
-| **Latency (P50)** | <50ms | **<0.1ms** | ✅ EXCEED |
+| Metric                     | Target    | Achieved   | Status    |
+| -------------------------- | --------- | ---------- | --------- |
+| **Speedup (JS Runtime)**   | 1.5x-4.0x | **2.49x**  | ✅ PASS   |
+| **Speedup (NAPI Runtime)** | 4.0x+     | **7.47x**  | ✅ EXCEED |
+| **Memory Reduction**       | 50%-75%   | **~50%**   | ✅ PASS   |
+| **Latency (P50)**          | <50ms     | **<0.1ms** | ✅ EXCEED |
 
 **Overall Grade: A (100% Pass Rate)**
 
 ### All Attention Mechanisms
 
-| Mechanism | Avg Latency | Min | Max | Target | Status |
-|-----------|------------|-----|-----|--------|--------|
-| **Flash** | 0.00ms | 0.00ms | 0.00ms | <50ms | ✅ EXCEED |
-| **Multi-Head** | 0.07ms | 0.07ms | 0.08ms | <100ms | ✅ EXCEED |
-| **Linear** | 0.03ms | 0.03ms | 0.04ms | <100ms | ✅ EXCEED |
-| **Hyperbolic** | 0.06ms | 0.06ms | 0.06ms | <100ms | ✅ EXCEED |
-| **MoE** | 0.04ms | 0.04ms | 0.04ms | <150ms | ✅ EXCEED |
-| **GraphRoPE** | 0.05ms | 0.04ms | 0.05ms | <100ms | ✅ EXCEED |
+| Mechanism      | Avg Latency | Min    | Max    | Target | Status    |
+| -------------- | ----------- | ------ | ------ | ------ | --------- |
+| **Flash**      | 0.00ms      | 0.00ms | 0.00ms | <50ms  | ✅ EXCEED |
+| **Multi-Head** | 0.07ms      | 0.07ms | 0.08ms | <100ms | ✅ EXCEED |
+| **Linear**     | 0.03ms      | 0.03ms | 0.04ms | <100ms | ✅ EXCEED |
+| **Hyperbolic** | 0.06ms      | 0.06ms | 0.06ms | <100ms | ✅ EXCEED |
+| **MoE**        | 0.04ms      | 0.04ms | 0.04ms | <150ms | ✅ EXCEED |
+| **GraphRoPE**  | 0.05ms      | 0.04ms | 0.05ms | <100ms | ✅ EXCEED |
 
 ### Flash vs Multi-Head Speedup by Candidate Count
 
-| Candidates | Flash Time | Multi-Head Time | Speedup | Status |
-|-----------|-----------|----------------|---------|--------|
-| 10 | 0.03ms | 0.08ms | **2.77x** | ✅ |
-| 50 | 0.07ms | 0.08ms | **1.13x** | ⚠️ |
-| 100 | 0.03ms | 0.08ms | **2.98x** | ✅ |
-| 200 | 0.03ms | 0.09ms | **3.06x** | ✅ |
-| **Average** | - | - | **2.49x** | ✅ |
+| Candidates  | Flash Time | Multi-Head Time | Speedup   | Status |
+| ----------- | ---------- | --------------- | --------- | ------ |
+| 10          | 0.03ms     | 0.08ms          | **2.77x** | ✅     |
+| 50          | 0.07ms     | 0.08ms          | **1.13x** | ⚠️     |
+| 100         | 0.03ms     | 0.08ms          | **2.98x** | ✅     |
+| 200         | 0.03ms     | 0.09ms          | **3.06x** | ✅     |
+| **Average** | -          | -               | **2.49x** | ✅     |
 
 ### Vector Search Performance
 
-| Operation | Without HNSW | With HNSW | Speedup | Status |
-|-----------|-------------|-----------|---------|--------|
-| **1M vectors** | 1000ms | 6.7ms | **150x** | ✅ |
-| **10M vectors** | 10000ms | 0.8ms | **12,500x** | ✅ |
+| Operation       | Without HNSW | With HNSW | Speedup     | Status |
+| --------------- | ------------ | --------- | ----------- | ------ |
+| **1M vectors**  | 1000ms       | 6.7ms     | **150x**    | ✅     |
+| **10M vectors** | 10000ms      | 0.8ms     | **12,500x** | ✅     |
 
 ### GNN Query Refinement
 
-| Metric | Baseline | With GNN | Improvement | Status |
-|--------|----------|----------|-------------|--------|
-| **Recall@10** | 0.65 | 0.73 | **+12.4%** | 🎯 Target |
-| **Precision@10** | 0.82 | 0.87 | **+6.1%** | ✅ |
+| Metric           | Baseline | With GNN | Improvement | Status    |
+| ---------------- | -------- | -------- | ----------- | --------- |
+| **Recall@10**    | 0.65     | 0.73     | **+12.4%**  | 🎯 Target |
+| **Precision@10** | 0.82     | 0.87     | **+6.1%**   | ✅        |
 
 ### Multi-Agent Coordination Performance
 
-| Topology | Agents | Latency | Throughput | Status |
-|----------|--------|---------|-----------|--------|
-| **Mesh** | 10 | 2.1ms | 476 ops/s | ✅ |
-| **Hierarchical** | 10 | 1.8ms | 556 ops/s | ✅ |
-| **Ring** | 10 | 1.5ms | 667 ops/s | ✅ |
-| **Star** | 10 | 1.2ms | 833 ops/s | ✅ |
+| Topology         | Agents | Latency | Throughput | Status |
+| ---------------- | ------ | ------- | ---------- | ------ |
+| **Mesh**         | 10     | 2.1ms   | 476 ops/s  | ✅     |
+| **Hierarchical** | 10     | 1.8ms   | 556 ops/s  | ✅     |
+| **Ring**         | 10     | 1.5ms   | 667 ops/s  | ✅     |
+| **Star**         | 10     | 1.2ms   | 833 ops/s  | ✅     |
 
 ### Memory Efficiency
 
 | Sequence Length | Standard | Flash Attention | Reduction | Status |
-|----------------|----------|----------------|-----------|--------|
-| 512 tokens | 4.0 MB | 2.0 MB | **50%** | ✅ |
-| 1024 tokens | 16.0 MB | 4.0 MB | **75%** | ✅ |
-| 2048 tokens | 64.0 MB | 8.0 MB | **87.5%** | ✅ |
+| --------------- | -------- | --------------- | --------- | ------ |
+| 512 tokens      | 4.0 MB   | 2.0 MB          | **50%**   | ✅     |
+| 1024 tokens     | 16.0 MB  | 4.0 MB          | **75%**   | ✅     |
+| 2048 tokens     | 64.0 MB  | 8.0 MB          | **87.5%** | ✅     |
 
 ### Overall Performance Grade
 
@@ -734,13 +853,13 @@ Every agent in Agentic-Flow v2.0.0-alpha features **autonomous self-learning** p
 ```typescript
 // Agents automatically search for similar past solutions
 const similarTasks = await reasoningBank.searchPatterns({
-  task: 'Implement user authentication',
-  k: 5,              // Top 5 similar tasks
-  minReward: 0.8     // Only successful patterns (>80% success)
+  task: "Implement user authentication",
+  k: 5, // Top 5 similar tasks
+  minReward: 0.8, // Only successful patterns (>80% success)
 });
 
 // Apply lessons from past successes
-similarTasks.forEach(pattern => {
+similarTasks.forEach((pattern) => {
   console.log(`Past solution: ${pattern.task}`);
   console.log(`Success rate: ${pattern.reward}`);
   console.log(`Key learnings: ${pattern.critique}`);
@@ -748,8 +867,8 @@ similarTasks.forEach(pattern => {
 
 // Avoid past mistakes
 const failures = await reasoningBank.searchPatterns({
-  task: 'Implement user authentication',
-  onlyFailures: true // Learn from failures
+  task: "Implement user authentication",
+  onlyFailures: true, // Learn from failures
 });
 ```
 
@@ -757,16 +876,15 @@ const failures = await reasoningBank.searchPatterns({
 
 ```typescript
 // Use GNN for +12.4% better context accuracy
-const relevantContext = await agentDB.gnnEnhancedSearch(
-  taskEmbedding,
-  {
-    k: 10,
-    graphContext: buildCodeGraph(), // Related code as graph
-    gnnLayers: 3
-  }
-);
+const relevantContext = await agentDB.gnnEnhancedSearch(taskEmbedding, {
+  k: 10,
+  graphContext: buildCodeGraph(), // Related code as graph
+  gnnLayers: 3,
+});
 
-console.log(`Context accuracy improved by ${relevantContext.improvementPercent}%`);
+console.log(
+  `Context accuracy improved by ${relevantContext.improvementPercent}%`,
+);
 
 // Process large contexts 2.49x-7.47x faster
 const result = await agentDB.flashAttention(Q, K, V);
@@ -779,14 +897,14 @@ console.log(`Processed in ${result.executionTimeMs}ms`);
 // Agents automatically store every task execution
 await reasoningBank.storePattern({
   sessionId: `coder-${agentId}-${Date.now()}`,
-  task: 'Implement user authentication',
-  input: 'Requirements: OAuth2, JWT tokens, rate limiting',
+  task: "Implement user authentication",
+  input: "Requirements: OAuth2, JWT tokens, rate limiting",
   output: generatedCode,
-  reward: 0.95,      // Success score (0-1)
+  reward: 0.95, // Success score (0-1)
   success: true,
-  critique: 'Good test coverage, could improve error messages',
+  critique: "Good test coverage, could improve error messages",
   tokensUsed: 15000,
-  latencyMs: 2300
+  latencyMs: 2300,
 });
 ```
 
@@ -794,12 +912,12 @@ await reasoningBank.storePattern({
 
 Agents continuously improve through iterative learning:
 
-| Iterations | Success Rate | Accuracy | Speed | Tokens |
-|-----------|-------------|----------|-------|--------|
-| **1-5** | 70% | Baseline | Baseline | 100% |
-| **6-10** | 82% (+12%) | +8.5% | +15% | -18% |
-| **11-20** | 91% (+21%) | +15.2% | +32% | -29% |
-| **21-50** | 98% (+28%) | +21.8% | +48% | -35% |
+| Iterations | Success Rate | Accuracy | Speed    | Tokens |
+| ---------- | ------------ | -------- | -------- | ------ |
+| **1-5**    | 70%          | Baseline | Baseline | 100%   |
+| **6-10**   | 82% (+12%)   | +8.5%    | +15%     | -18%   |
+| **11-20**  | 91% (+21%)   | +15.2%   | +32%     | -29%   |
+| **21-50**  | 98% (+28%)   | +21.8%   | +48%     | -35%   |
 
 ### Agent-Specific Learning Examples
 
@@ -808,22 +926,22 @@ Agents continuously improve through iterative learning:
 ```typescript
 // Before: Search for similar implementations
 const codePatterns = await reasoningBank.searchPatterns({
-  task: 'Implement REST API endpoint',
-  k: 5
+  task: "Implement REST API endpoint",
+  k: 5,
 });
 
 // During: Use GNN to find related code
-const similarCode = await agentDB.gnnEnhancedSearch(
-  taskEmbedding,
-  { k: 10, graphContext: buildCodeDependencyGraph() }
-);
+const similarCode = await agentDB.gnnEnhancedSearch(taskEmbedding, {
+  k: 10,
+  graphContext: buildCodeDependencyGraph(),
+});
 
 // After: Store successful pattern
 await reasoningBank.storePattern({
-  task: 'Implement REST API endpoint',
+  task: "Implement REST API endpoint",
   output: generatedCode,
   reward: calculateCodeQuality(generatedCode),
-  success: allTestsPassed
+  success: allTestsPassed,
 });
 ```
 
@@ -831,15 +949,15 @@ await reasoningBank.storePattern({
 
 ```typescript
 // Enhanced research with GNN (+12.4% better)
-const relevantDocs = await agentDB.gnnEnhancedSearch(
-  researchQuery,
-  { k: 20, graphContext: buildKnowledgeGraph() }
-);
+const relevantDocs = await agentDB.gnnEnhancedSearch(researchQuery, {
+  k: 20,
+  graphContext: buildKnowledgeGraph(),
+});
 
 // Multi-source synthesis with attention
 const synthesis = await coordinator.coordinateAgents(
   researchFindings,
-  'multi-head' // Multi-perspective analysis
+  "multi-head", // Multi-perspective analysis
 );
 ```
 
@@ -848,15 +966,15 @@ const synthesis = await coordinator.coordinateAgents(
 ```typescript
 // Learn from past test failures
 const failedTests = await reasoningBank.searchPatterns({
-  task: 'Test authentication',
-  onlyFailures: true
+  task: "Test authentication",
+  onlyFailures: true,
 });
 
 // Generate comprehensive tests with Flash Attention
 const testCases = await agentDB.flashAttention(
   featureEmbedding,
   edgeCaseEmbeddings,
-  edgeCaseEmbeddings
+  edgeCaseEmbeddings,
 );
 ```
 
@@ -868,11 +986,14 @@ Agents learn to work together more effectively:
 // Attention-based consensus (better than voting)
 const coordinator = new AttentionCoordinator(attentionService);
 
-const teamDecision = await coordinator.coordinateAgents([
-  { agentId: 'coder', output: 'Approach A', embedding: embed1 },
-  { agentId: 'reviewer', output: 'Approach B', embedding: embed2 },
-  { agentId: 'architect', output: 'Approach C', embedding: embed3 },
-], 'flash');
+const teamDecision = await coordinator.coordinateAgents(
+  [
+    { agentId: "coder", output: "Approach A", embedding: embed1 },
+    { agentId: "reviewer", output: "Approach B", embedding: embed2 },
+    { agentId: "architect", output: "Approach C", embedding: embed3 },
+  ],
+  "flash",
+);
 
 console.log(`Team consensus: ${teamDecision.consensus}`);
 console.log(`Confidence: ${teamDecision.attentionWeights.max()}`);
@@ -885,15 +1006,15 @@ All agents share learning patterns via ReasoningBank:
 ```typescript
 // Agent 1: Coder stores successful pattern
 await reasoningBank.storePattern({
-  task: 'Implement caching layer',
+  task: "Implement caching layer",
   output: redisImplementation,
-  reward: 0.92
+  reward: 0.92,
 });
 
 // Agent 2: Different coder retrieves the pattern
 const cachedSolutions = await reasoningBank.searchPatterns({
-  task: 'Implement caching layer',
-  k: 3
+  task: "Implement caching layer",
+  k: 3,
 });
 // Learns from Agent 1's successful approach
 ```
@@ -905,8 +1026,8 @@ Track learning progress:
 ```typescript
 // Get performance stats for a task type
 const stats = await reasoningBank.getPatternStats({
-  task: 'implement-rest-api',
-  k: 20
+  task: "implement-rest-api",
+  k: 20,
 });
 
 console.log(`Success rate: ${stats.successRate}%`);
@@ -1010,22 +1131,23 @@ Agentic-Flow v2 includes a powerful **self-learning hooks system** powered by Ru
 
 ### Hooks Overview
 
-| Hook | Purpose | When Triggered |
-|------|---------|----------------|
-| `pre-edit` | Get context and agent suggestions | Before file edits |
-| `post-edit` | Record edit outcomes for learning | After file edits |
-| `pre-command` | Assess command risk | Before Bash commands |
-| `post-command` | Record command outcomes | After Bash commands |
-| `route` | Route task to optimal agent | On task assignment |
-| `explain` | Explain routing decision | On demand |
-| `pretrain` | Bootstrap from repository | During setup |
-| `build-agents` | Generate agent configs | After pretrain |
-| `metrics` | View learning dashboard | On demand |
-| `transfer` | Transfer patterns between projects | On demand |
+| Hook           | Purpose                            | When Triggered       |
+| -------------- | ---------------------------------- | -------------------- |
+| `pre-edit`     | Get context and agent suggestions  | Before file edits    |
+| `post-edit`    | Record edit outcomes for learning  | After file edits     |
+| `pre-command`  | Assess command risk                | Before Bash commands |
+| `post-command` | Record command outcomes            | After Bash commands  |
+| `route`        | Route task to optimal agent        | On task assignment   |
+| `explain`      | Explain routing decision           | On demand            |
+| `pretrain`     | Bootstrap from repository          | During setup         |
+| `build-agents` | Generate agent configs             | After pretrain       |
+| `metrics`      | View learning dashboard            | On demand            |
+| `transfer`     | Transfer patterns between projects | On demand            |
 
 ### Core Hook Commands
 
 #### Pre-Edit Hook
+
 Get context and agent suggestions before editing a file:
 
 ```bash
@@ -1047,6 +1169,7 @@ npx agentic-flow@alpha hooks pre-edit src/api/users.ts --task "Add validation"
 ```
 
 #### Post-Edit Hook
+
 Record edit outcome for learning:
 
 ```bash
@@ -1068,6 +1191,7 @@ npx agentic-flow@alpha hooks post-edit src/api/users.ts --fail --error "Type err
 ```
 
 #### Pre-Command Hook
+
 Assess command risk before execution:
 
 ```bash
@@ -1086,6 +1210,7 @@ npx agentic-flow@alpha hooks pre-command "rm -rf node_modules"
 ```
 
 #### Route Hook
+
 Route task to optimal agent using learned patterns:
 
 ```bash
@@ -1112,6 +1237,7 @@ npx agentic-flow@alpha hooks route "Fix authentication bug in login flow"
 ```
 
 #### Explain Hook
+
 Explain routing decision with full transparency:
 
 ```bash
@@ -1139,6 +1265,7 @@ npx agentic-flow@alpha hooks explain "Implement caching layer"
 ### Learning & Training Commands
 
 #### Pretrain Hook
+
 Analyze repository to bootstrap intelligence:
 
 ```bash
@@ -1164,6 +1291,7 @@ npx agentic-flow@alpha hooks pretrain --depth 100
 ```
 
 #### Build-Agents Hook
+
 Generate optimized agent configurations from pretrain data:
 
 ```bash
@@ -1191,6 +1319,7 @@ npx agentic-flow@alpha hooks build-agents --focus security
 ```
 
 #### Metrics Hook
+
 View learning metrics and performance dashboard:
 
 ```bash
@@ -1220,6 +1349,7 @@ npx agentic-flow@alpha hooks metrics --timeframe 7d --detailed
 ```
 
 #### Transfer Hook
+
 Transfer learned patterns from another project:
 
 ```bash
@@ -1246,6 +1376,7 @@ npx agentic-flow@alpha hooks transfer ../other-project --mode merge
 The `intelligence` (alias: `intel`) subcommand provides access to the full RuVector stack:
 
 #### Intelligence Route
+
 Route task using SONA + MoE + HNSW (150x faster than brute force):
 
 ```bash
@@ -1269,6 +1400,7 @@ npx agentic-flow@alpha hooks intel route "Optimize database queries" --top-k 3
 ```
 
 #### Trajectory Tracking
+
 Track reinforcement learning trajectories for agent improvement:
 
 ```bash
@@ -1286,6 +1418,7 @@ npx agentic-flow@alpha hooks intel trajectory-end 42 --success --quality 0.95
 ```
 
 #### Pattern Storage & Search
+
 Store and search patterns using HNSW-indexed ReasoningBank:
 
 ```bash
@@ -1308,6 +1441,7 @@ npx agentic-flow@alpha hooks intel pattern-search "hydration mismatch"
 ```
 
 #### Intelligence Stats
+
 Get RuVector intelligence layer statistics:
 
 ```bash
@@ -1349,30 +1483,65 @@ The `init` command automatically configures hooks in `.claude/settings.json`:
     "PreToolUse": [
       {
         "matcher": "Edit|Write|MultiEdit",
-        "hooks": [{"type": "command", "command": "npx agentic-flow@alpha hooks pre-edit \"$TOOL_INPUT_file_path\""}]
+        "hooks": [
+          {
+            "type": "command",
+            "command": "npx agentic-flow@alpha hooks pre-edit \"$TOOL_INPUT_file_path\""
+          }
+        ]
       },
       {
         "matcher": "Bash",
-        "hooks": [{"type": "command", "command": "npx agentic-flow@alpha hooks pre-command \"$TOOL_INPUT_command\""}]
+        "hooks": [
+          {
+            "type": "command",
+            "command": "npx agentic-flow@alpha hooks pre-command \"$TOOL_INPUT_command\""
+          }
+        ]
       }
     ],
     "PostToolUse": [
       {
         "matcher": "Edit|Write|MultiEdit",
-        "hooks": [{"type": "command", "command": "npx agentic-flow@alpha hooks post-edit \"$TOOL_INPUT_file_path\" --success"}]
+        "hooks": [
+          {
+            "type": "command",
+            "command": "npx agentic-flow@alpha hooks post-edit \"$TOOL_INPUT_file_path\" --success"
+          }
+        ]
       }
     ],
     "PostToolUseFailure": [
       {
         "matcher": "Edit|Write|MultiEdit",
-        "hooks": [{"type": "command", "command": "npx agentic-flow@alpha hooks post-edit \"$TOOL_INPUT_file_path\" --fail --error \"$ERROR_MESSAGE\""}]
+        "hooks": [
+          {
+            "type": "command",
+            "command": "npx agentic-flow@alpha hooks post-edit \"$TOOL_INPUT_file_path\" --fail --error \"$ERROR_MESSAGE\""
+          }
+        ]
       }
     ],
     "SessionStart": [
-      {"hooks": [{"type": "command", "command": "npx agentic-flow@alpha hooks intelligence stats --json"}]}
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "npx agentic-flow@alpha hooks intelligence stats --json"
+          }
+        ]
+      }
     ],
     "UserPromptSubmit": [
-      {"hooks": [{"type": "command", "timeout": 3000, "command": "npx agentic-flow@alpha hooks route \"$USER_PROMPT\" --json"}]}
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "timeout": 3000,
+            "command": "npx agentic-flow@alpha hooks route \"$USER_PROMPT\" --json"
+          }
+        ]
+      }
     ]
   }
 }
@@ -1419,18 +1588,19 @@ Agentic-Flow v2 includes a powerful **background workers system** that runs non-
 
 Workers are automatically dispatched when trigger keywords are detected in prompts:
 
-| Trigger | Description | Priority |
-|---------|-------------|----------|
-| `ultralearn` | Deep codebase learning and pattern extraction | high |
-| `optimize` | Performance analysis and optimization suggestions | medium |
-| `audit` | Security and code quality auditing | high |
-| `document` | Documentation generation and analysis | low |
-| `refactor` | Code refactoring analysis | medium |
-| `test` | Test coverage and quality analysis | medium |
+| Trigger      | Description                                       | Priority |
+| ------------ | ------------------------------------------------- | -------- |
+| `ultralearn` | Deep codebase learning and pattern extraction     | high     |
+| `optimize`   | Performance analysis and optimization suggestions | medium   |
+| `audit`      | Security and code quality auditing                | high     |
+| `document`   | Documentation generation and analysis             | low      |
+| `refactor`   | Code refactoring analysis                         | medium   |
+| `test`       | Test coverage and quality analysis                | medium   |
 
 ### Worker Commands
 
 #### Dispatch Workers
+
 Detect triggers in prompt and dispatch background workers:
 
 ```bash
@@ -1446,6 +1616,7 @@ npx agentic-flow@alpha workers dispatch "ultralearn how authentication works"
 ```
 
 #### Monitor Status
+
 Get worker status and progress:
 
 ```bash
@@ -1471,6 +1642,7 @@ npx agentic-flow@alpha workers status
 ```
 
 #### View Results
+
 View worker analysis results:
 
 ```bash
@@ -1494,6 +1666,7 @@ npx agentic-flow@alpha workers results
 ```
 
 #### List Triggers
+
 List all available trigger keywords:
 
 ```bash
@@ -1511,6 +1684,7 @@ npx agentic-flow@alpha workers triggers
 ```
 
 #### Worker Statistics
+
 Get worker statistics:
 
 ```bash
@@ -1543,12 +1717,14 @@ npx agentic-flow@alpha workers stats --timeframe 7d
 Create and manage custom workers with specific analysis phases:
 
 #### List Presets
+
 ```bash
 npx agentic-flow@alpha workers presets
 # Shows available worker presets: quick-scan, deep-analysis, security-audit, etc.
 ```
 
 #### Create Custom Worker
+
 ```bash
 npx agentic-flow@alpha workers create <name> [options]
 
@@ -1562,6 +1738,7 @@ npx agentic-flow@alpha workers create security-check --preset security-audit --t
 ```
 
 #### Run Custom Worker
+
 ```bash
 npx agentic-flow@alpha workers run <nameOrTrigger> [options]
 
@@ -1656,6 +1833,7 @@ npx agentic-flow@alpha workers integration
 ```
 
 #### Agent Recommendations
+
 Get recommended agents for a worker trigger:
 
 ```bash
@@ -1686,20 +1864,24 @@ Workers are automatically configured in `.claude/settings.json` via hooks:
   "hooks": {
     "UserPromptSubmit": [
       {
-        "hooks": [{
-          "type": "command",
-          "timeout": 5000,
-          "background": true,
-          "command": "npx agentic-flow@alpha workers dispatch-prompt \"$USER_PROMPT\" --session \"$SESSION_ID\" --json"
-        }]
+        "hooks": [
+          {
+            "type": "command",
+            "timeout": 5000,
+            "background": true,
+            "command": "npx agentic-flow@alpha workers dispatch-prompt \"$USER_PROMPT\" --session \"$SESSION_ID\" --json"
+          }
+        ]
       }
     ],
     "SessionEnd": [
       {
-        "hooks": [{
-          "type": "command",
-          "command": "npx agentic-flow@alpha workers cleanup --age 24"
-        }]
+        "hooks": [
+          {
+            "type": "command",
+            "command": "npx agentic-flow@alpha workers cleanup --age 24"
+          }
+        ]
       }
     ]
   }
@@ -1779,20 +1961,20 @@ node -e "console.log(require('@ruvector/attention').runtime)"
 ```typescript
 class EnhancedAgentDBWrapper {
   // Attention mechanisms
-  async flashAttention(Q, K, V): Promise<AttentionResult>
-  async multiHeadAttention(Q, K, V): Promise<AttentionResult>
-  async linearAttention(Q, K, V): Promise<AttentionResult>
-  async hyperbolicAttention(Q, K, V, curvature): Promise<AttentionResult>
-  async moeAttention(Q, K, V, numExperts): Promise<AttentionResult>
-  async graphRoPEAttention(Q, K, V, graph): Promise<AttentionResult>
+  async flashAttention(Q, K, V): Promise<AttentionResult>;
+  async multiHeadAttention(Q, K, V): Promise<AttentionResult>;
+  async linearAttention(Q, K, V): Promise<AttentionResult>;
+  async hyperbolicAttention(Q, K, V, curvature): Promise<AttentionResult>;
+  async moeAttention(Q, K, V, numExperts): Promise<AttentionResult>;
+  async graphRoPEAttention(Q, K, V, graph): Promise<AttentionResult>;
 
   // GNN query refinement
-  async gnnEnhancedSearch(query, options): Promise<GNNRefinementResult>
+  async gnnEnhancedSearch(query, options): Promise<GNNRefinementResult>;
 
   // Vector operations
-  async vectorSearch(query, options): Promise<VectorSearchResult[]>
-  async insertVector(vector, metadata): Promise<void>
-  async deleteVector(id): Promise<void>
+  async vectorSearch(query, options): Promise<VectorSearchResult[]>;
+  async insertVector(vector, metadata): Promise<void>;
+  async deleteVector(id): Promise<void>;
 }
 ```
 
@@ -1801,16 +1983,24 @@ class EnhancedAgentDBWrapper {
 ```typescript
 class AttentionCoordinator {
   // Agent coordination
-  async coordinateAgents(outputs, mechanism): Promise<CoordinationResult>
+  async coordinateAgents(outputs, mechanism): Promise<CoordinationResult>;
 
   // Expert routing
-  async routeToExperts(task, agents, topK): Promise<ExpertRoutingResult>
+  async routeToExperts(task, agents, topK): Promise<ExpertRoutingResult>;
 
   // Topology-aware coordination
-  async topologyAwareCoordination(outputs, topology, graph?): Promise<CoordinationResult>
+  async topologyAwareCoordination(
+    outputs,
+    topology,
+    graph?,
+  ): Promise<CoordinationResult>;
 
   // Hierarchical coordination
-  async hierarchicalCoordination(queens, workers, curvature): Promise<CoordinationResult>
+  async hierarchicalCoordination(
+    queens,
+    workers,
+    curvature,
+  ): Promise<CoordinationResult>;
 }
 ```