ruvnet/RuVector

This system is a high-performance, Rust-based platform that integrates vector search, graph databases, and autonomous agent infrastructure. It provides core capabilities for similarity search, graph analysis, and neural operations, extending them with specialized modules for robotics, time-series forecasting, and bio-inspired simulations. The architecture supports diverse deployment environments, including embedded systems, browsers, and SQL databases, while enforcing cryptographic integrity and formal verification.

125 changes.

This period established the foundational repository structure and introduced core vector database capabilities with HNSW indexing and multiple quantization strategies. It simultaneously launched comprehensive bindings for Node.js, WebAssembly, and PostgreSQL, while deploying graph and transformer libraries to WebAssembly for browser and embedded environments. Significant work also expanded neuromorphic capabilities within the nervous system and DAG crates, adding biological-inspired components and self-learning attention mechanisms.

178 changes.

The project expanded its WebAssembly footprint by exposing advanced attention mechanisms and vector search to browser environments while establishing the foundational infrastructure for the RuVix Cognition Kernel and RVM microhypervisor. This period also introduced core microhypervisor architecture for partitioning and scheduling, alongside significant enhancements to vector search capabilities including new index types and specialized agent tooling.

The npm/core package now includes a CommonJS wrapper (index.cjs.js) that allows projects using require() to load the native Rust bindings. This wrapper automatically detects the platform and architecture to load the correct native module, provides a DistanceMetric enum for similarity calculations, and optionally re-exports the @ruvector/attention module if installed.

npm/core · high confidence

The \examples/refrag-pipeline\ directory now contains a complete example implementation of the REFRAG (Rethinking RAG) framework, which aims to reduce RAG latency by storing pre-computed embeddings as binary tensors rather than raw text. This example introduces a three-layer architecture: a Compress layer for tensor quantization (supporting Float16, Int8, and Binary strategies), a Sense layer with a policy network to route queries between tensor and text responses, and an Expand layer for projecting tensors to target LLM dimensions. The package includes a demo application (\main.rs\) for interactive testing and a benchmark suite (\benchmark.rs\) to measure performance across different compression strategies and pipeline configurations.

examples/refrag-pipeline · high confidence

Introduces a new Rust-based ONNX embedding example for RuVector that supports loading models from HuggingFace, local files, or URLs, and includes optional GPU acceleration via WebGPU or CUDA-WASM for pooling and similarity operations.

examples/onnx-embeddings · high confidence

The min-cut brain node now includes the required V1 ABI stubs (\malloc\, \feature\_extract\_dim\, \feature\_extract\) to conform to the brain server's node publish endpoint. These stubs allow the graph algorithm node to be published and recognized by the server, with \feature\_extract\ explicitly returning an error code since the node does not perform embedding extraction.

crates/ruvector-mincut-brain-node · high confidence

The npm/wasm package now exposes separate entry points for browser and Node.js environments. The new browser entry point (\browser.ts/js/d.ts\) provides a \VectorDB\ class that persists data to IndexedDB via \saveToIndexedDB\ and \loadFromIndexedDB\, while the Node.js entry point (\node.ts/js/d.ts\) provides a \VectorDB\ class with stubbed \saveToFile\ and \loadFromFile\ methods that currently warn that file persistence is not yet implemented. Both entry points share the core vector operations (insert, search, delete, get) and utility functions (detectSIMD, version, benchmark) but load their respective WASM modules (\../pkg/ruvector\_wasm.js\ for browser, \../pkg-node/ruvector\_wasm.js\ for Node.js). A test file (\index.test.ts\) has been added to verify basic operations and error handling for the Node.js entry point.

npm/wasm · high confidence

The examples/gene-consciousness directory now includes a Rust application that applies Integrated Information Theory (IIT) Phi analysis to synthetic gene regulatory networks. The example builds normal and oncogenic (cancer) network variants, computes full-system and module-level Phi values, performs causal emergence and SVD emergence analysis, and runs null hypothesis testing to compare integrated information. It outputs a text summary and an SVG report visualizing the network graph, Phi comparisons, and null distributions.

examples/gene-consciousness · high confidence

Added a new example application in \examples/apify/neural-trader-system\ that implements a neural network-based trading system using the Apify Actor framework. The code includes a custom \NeuralEngine\ for forward propagation and training, an \LSTMCell\ for time-series prediction, and a \SignalGenerator\ that produces trading signals with confidence scores based on market data and predictions.

examples/apify/neural-trader-system · high confidence

Added ten runnable examples in examples/robotics/src/bin/ that demonstrate the ruvector-robotics crate's capabilities: basic perception with spatial indexing (01), obstacle avoidance and classification (02), scene graph building and merging (03), behavior tree execution with decorators and parallel nodes (04), a perceive-think-act-learn cognitive loop (05), multi-robot task assignment and formation control (06), skill learning from demonstrations (07), world modeling with occupancy grids and object tracking (08), an MCP tool registry with JSON schema generation (09), and an integrated full pipeline combining all modules (10).

examples/robotics · high confidence

The \sevensense-analysis\ crate is added as a new example within the \vibecast-7sense\ workspace, providing advanced acoustic analysis tools for bioacoustic pattern discovery. It introduces a domain-driven architecture with application services for clustering (HDBSCAN and K-Means), motif detection, sequence analysis via Markov chains, and anomaly detection. The implementation includes domain entities for clusters, prototypes, and motifs, along with repository traits and an in-memory storage implementation for development and testing.

(repo-wide) · high confidence

The \cognitum-gate-wasm\ package now includes example files demonstrating how to integrate the coherence gate into different environments. This includes a basic Node.js usage example, an Express middleware implementation for API protection, and a React hook with a \GateProvider\ and \ProtectedButton\ component for frontend applications.

npm/packages/cognitum-gate-wasm · high confidence

This change introduces two new scripts to the \crates/ruvector-postgres/scripts\ directory. The \docker-test.sh\ script provides an automated way to build Docker images, run the test suite, execute performance benchmarks, and manage PostgreSQL container environments across different versions. Additionally, \download\_models.rs\ is a utility that pre-downloads ONNX embedding models (specifically \all-MiniLM-L6-v2\ and optionally \BAAI/bge-small-en-v1.5\) during the Docker build process, ensuring they are available at runtime without requiring network access.

crates/ruvector-postgres/scripts · high confidence

This change introduces a set of shell scripts and configuration files to automate the deployment and operation of the RuVector Brain server on Google Cloud. The new \deploy-all.sh\ script handles building the container, deploying it to Cloud Run with specific resource limits (4Gi memory, 4 CPU) and environment variables (including Gemini grounding and various feature flags), and setting up Pub/Sub and Scheduler. \deploy-scheduler.sh\ and \scheduler-jobs.yaml\ define scheduled jobs for brain optimization tasks like training, drift monitoring, and graph rebalancing. \setup-pubsub.sh\ configures Pub/Sub topics and subscriptions for data injection and event monitoring. Finally, \monitoring-dashboard.json\ provides a pre-configured Google Cloud Monitoring dashboard for tracking request latency, error rates, memory count, graph edges, and training cycles.

crates/mcp-brain-server/cloud · high confidence

Three new example programs have been added to the \ruvector-diskann\ crate to help users evaluate performance characteristics. \bench\_delete\_recall.rs\ measures recall and delete latency when removing 20% of vectors, comparing deferred tombstone deletes against repaired deletes. \bench\_search\_hot.rs\ benchmarks search latency (p50/p99) and queries per second for a hot-index scenario. \mmap\_674\_bench.rs\ provides an A/B measurement harness to compare the memory usage and latency of the new memory-mapped vector storage mode (\load\_mmap\) against the standard owned storage mode (\load\).

crates/ruvector-diskann/examples · high confidence

This change introduces new benchmark data files (CSV, JSON, and Markdown) in the bench\_results directory, comparing the performance of ruvector (optimized and non-quantized), a Python baseline, and brute-force methods on synthetic datasets, alongside latency benchmarks for various threading and search configurations. It also adds a detailed technical specification document (spec.txt.rtfd) in the examples/ruvLLM/modules/plans directory, outlining a frontier plan for Rust, SIMD, WASM, and Edge LLM serving, covering KV cache optimizations, multi-adapter LoRA serving, and the Rust ML ecosystem.

_bench\results, examples/ruvLLM/modules/plans · high confidence

The \crates/ruvector-bench/src/lib.rs\ file introduces a new benchmarking library for Ruvector. This includes tools for generating synthetic vector datasets (uniform, normal, and clustered distributions), collecting latency statistics using HDR histograms, and writing benchmark results to JSON, CSV, and Markdown formats. This enables standardized performance testing and profiling of the vector database.

crates/ruvector-bench/src · high confidence

New research examples have been added to the repository, introducing three distinct simulation engines. The quantum cognition module (02-quantum-superposition) implements Cognitive Amplitude Field Theory, modeling attention as wavefunction collapse and decisions via amplitude interference, with SIMD-optimized probability and inner-product calculations. The time-crystal cognition module (03-time-crystal-cognition) simulates discrete time translation symmetry breaking in neural-inspired systems, featuring Floquet cognitive systems and a temporal memory model that uses limit-cycle attractors for working memory. The persistent homology module (04-sparse-persistent-homology) introduces an apparent pairs optimization to accelerate topological data analysis by reducing matrix reduction complexity. These are experimental research components, not for production use.

(repo-wide) · high confidence

The \crates/profiling\ directory now includes a comprehensive suite of shell scripts and documentation for analyzing Ruvector's performance. Users can install required tools (perf, valgrind, heaptrack, cargo-flamegraph), run CPU and memory profiling, generate flamegraphs, and execute benchmark suites for distance metrics and HNSW search across various thread counts. A master script aggregates these into a single comprehensive report covering system info, benchmark results, CPU hotspots, cache stats, and memory analysis.

crates/profiling · high confidence

The \crates/ruvector-mincut-gated-transformer/examples\ directory now includes demonstration code for the library's core capabilities. \flash\_attention\_demo.rs\ illustrates CPU-based tiled attention, including multi-head attention and INT8 quantization. \mamba\_example.rs\ demonstrates the Mamba State Space Model, covering single-step recurrent inference, sequence processing, and state persistence. \scorer.rs\ showcases the primary mincut-gated transformer use case, detailing how gate and spike packets control inference behavior under various coherence and anomaly scenarios.

crates/ruvector-mincut-gated-transformer/examples · high confidence

The \ruvector-core\ crate now exposes an \AgenticDB\ compatibility layer that provides a higher-level API for storing and retrieving reflexion episodes, skills, causal edges, and learning sessions, alongside a pluggable embedding system. Users can now choose between a default hash-based embedding provider for fast, non-semantic testing or real semantic embedding providers (such as OpenAI API, ONNX Runtime, or native Lattice models) for production use, with the system handling the necessary vector space identity and dimension configuration automatically.

crates/ruvector-core/src · high confidence

The PhotonLayer WASM bindings now expose the deterministic optical pipeline to the browser, enabling the five-view studio UI to render without server-side inference. Users can run simulations client-side and verify experiment receipts to ensure data integrity (anti-swap guarantee).

crates/photonlayer-wasm · high confidence

The new \run\_on\_cli.rs\ example in the decompiler crate now includes a \fix\_module\_syntax\ function that automatically repairs syntactically invalid JavaScript output. It handles unbalanced braces, parentheses, and brackets by prepending or appending the necessary delimiters, fixes missing \catch\/\finally\ blocks for \try\ statements, and wraps \await\ expressions used outside of \async\ contexts in an async IIFE. If these strategies fail to balance the code, it falls back to wrapping the entire source in a void function scope to ensure validity.

crates/ruvector-decompiler/examples · high confidence

Added the \ruvector-entropy-ann\ crate containing a proof-of-concept for entropy-adaptive approximate nearest-neighbour search. This includes a flat k-NN graph implementation, three search variants (\FixedEfSearch\, \EntropyThresholdBeam\, and \EntropyScaledEf\) that use Shannon entropy of candidate distances to control beam width, and a synthetic dataset generator for clustering-based testing. A benchmark binary was added to measure recall and latency across easy, hard, and mixed query sets, though the PoC results indicate the entropy signal tracks local density rather than routing ambiguity in this configuration.

crates/ruvector-entropy-ann · high confidence

The \ruvector-cnn\ crate now includes infrastructure for INT8 quantization, enabling 2-4x faster inference and 4x smaller model sizes with less than 1% accuracy loss. This change introduces a graph rewrite system (\src/quantize/graph\_rewrite.rs\) that fuses BatchNorm layers into convolutions, merges zero-point corrections into biases, inserts quantize/dequantize nodes at precision boundaries, and fuses activations like ReLU and HardSwish (using lookup tables). It also provides scalar reference kernels for INT8 convolutions, matrix multiplications, and depthwise convolutions, along with comprehensive tests validating calibration, cosine similarity, and kernel equivalence against FP32 baselines.

crates/ruvector-cnn · high confidence

The \ruvix-aarch64\ crate now provides the low-level hardware abstraction layer for AArch64 targets, enabling the RuVix Cognition Kernel to boot and run on 64-bit ARM hardware. This addition introduces the complete boot sequence (assembly entry, BSS initialization, and handoff to Rust), a 4-level MMU implementation with split user/kernel address spaces, and a full exception handling framework for synchronous exceptions, IRQs, FIQs, and SError interrupts. It also includes safe wrappers for AArch64 system register access and defines the memory layout and page table structures required for kernel operation.

crates/ruvix/crates/aarch64 · high confidence

This change introduces the \ruvector-node\ crate, providing NAPI-RS bindings that expose the Ruvector core vector database to JavaScript/TypeScript environments. It enables users to create databases with configurable dimensions, distance metrics (Euclidean, Cosine, DotProduct, Manhattan), and HNSW index parameters. The bindings support vector insertion with optional JSON metadata, search queries with top-k and metadata filtering, and various quantization strategies including a new Turbo4 4-bit quantization mode. The implementation handles zero-copy buffer sharing for vectors and async/await support for database operations.

crates/ruvector-node/src · high confidence

The @ruvector/agentic-synth package is introduced as a new npm module for AI-powered synthetic data generation. This location provides the core SDK entry point, a CLI tool for generating structured data, and configuration examples for providers like Gemini and OpenRouter. The package includes a benchmarking script and a GitHub Actions workflow for performance regression detection, establishing the foundational tooling for the synthetic data generation capability.

npm/packages/agentic-synth · high confidence

This change introduces the initial version of the @ruvector/attention package, providing high-performance attention mechanisms for Node.js applications via a Rust backend. The package exposes a comprehensive API including Dot-Product, Multi-Head, Flash, Linear, Hyperbolic, and Mixture-of-Experts (MoE) attention classes, along with utilities for training (Trainer, AdamOptimizer) and batch processing (BatchProcessor, parallelAttentionCompute). The release includes the necessary build configuration (build.rs) and packaging metadata (.npmignore, LICENSE, README) to support distribution and usage in JavaScript/TypeScript environments.

crates/ruvector-attention-node · high confidence

This change introduces the initial codebase for the Agentic Robotics framework, adding several new Rust crates. The \agentic-robotics-core\ crate provides the foundational robotics middleware, including a ROS3-compatible pub/sub system, message definitions (RobotState, PointCloud, Pose), and serialization support for CDR and JSON formats. The \agentic-robotics-embedded\ crate adds support for bare-metal embedded systems with RTIC and Embassy integration. Additionally, the \agentic-robotics-mcp\ crate implements the Model Context Protocol (MCP), allowing AI assistants to control robots via natural language tools. The \agentic-robotics-benchmarks\ crate adds performance benchmarks for executor creation, task spawning, and message serialization to validate the system's high-performance claims.

(repo-wide) · high confidence

This change introduces the RuVector Attention CLI tool and its corresponding WebAssembly (WASM) JavaScript bindings. The CLI provides commands to compute attention (scaled dot-product, multi-head, hyperbolic, flash, linear, and MoE), run performance benchmarks, convert data formats (JSON, binary, MessagePack, CSV), start an HTTP server with REST endpoints, and use an interactive REPL. The WASM bindings expose a TypeScript API for browser or Node.js environments, allowing developers to initialize the module and use classes for the same attention mechanisms, along with configuration types for training and scheduling.

crates/ruvector-attention-cli, crates/ruvector-attention-wasm/js, crates/ruvector-attention-wasm/pkg, crates/ruvector-gnn-wasm · high confidence

This change introduces the initial implementation of the \ruvector-attention-wasm\ crate, exposing core attention mechanisms (scaled dot-product, multi-head, hyperbolic, linear, flash, local-global, and MoE) and training utilities (InfoNCE loss, Adam/AdamW/SGD optimizers, and learning rate schedulers) to JavaScript via WASM. It also provides utility functions for vector operations such as cosine similarity, normalization, softmax, batch normalization, and pairwise distance calculations, enabling users to perform attention-based computations and model training steps directly in the browser.

crates/ruvector-attention-wasm/src · high confidence

The \rvm-kernel\ crate is introduced as the top-level integration point for the RVM coherence-native microhypervisor. It re-exports all 12 subsystem crates (HAL, capabilities, witness, proof, partitions, scheduler, memory, coherence, boot, Wasm, and security) into a single API surface. The crate provides a bare-metal entry point for AArch64 that initializes hardware, runs a boot sequence, and enters a scheduler loop, while also including a host-target stub for testing. It enforces strict safety constraints (\no\_std\, \forbid(unsafe\_code)\) and includes a cryptographic signer bridge to adapt between proof and witness signing interfaces.

crates/rvm/crates/rvm-kernel · high confidence

The repository is initialized with essential configuration files including a comprehensive .env.example template for environment variables, a .dockerignore file to exclude build artifacts and local files from Docker contexts, a .gcloudignore for Cloud Build, and a .gitignore that excludes generated data, build outputs, and secrets. A .gitmodules file is added to include external submodules for VectorVroom, ruqu, and rvdna. The project also includes a CLAUDE.md configuration file defining behavioral rules, file organization, and architecture guidelines for Claude Code, a SECURITY.md outlining vulnerability reporting procedures, and a deny.toml for Rust supply-chain policy enforcement. An install.sh script is provided for automated installation of Rust, CLI tools, and npm packages across different platforms.

(repo-wide) · high confidence

The new @ruvector/agentic-synth-examples package (v0.1.0) provides production-ready examples, progressive tutorials, and a CLI tool for the agentic-synth ecosystem. It includes a CLI (\agentic-synth-examples\) for listing and running examples, alongside comprehensive TypeScript implementations for DSPy multi-model training, self-learning systems, and various data generators (stock market, security, CI/CD). The package also ships with a 250+ test suite using Vitest and detailed documentation to help users get started with synthetic data generation and AI training workflows.

npm/packages/agentic-synth-examples · high confidence

The new @ruvector/cnn package enables running CNN-based image feature extraction directly in the browser or Node.js without external APIs. It provides a CnnEmbedder class to convert images into searchable vectors and compute cosine similarity, along with InfoNCELoss and TripletLoss classes to support contrastive and metric learning for custom model training. The implementation is backed by a WebAssembly module that exposes SIMD-optimized operations (such as dot product, ReLU, and L2 normalization) and layer utilities (batch normalization, global average pooling) to accelerate these computations.

npm/packages/ruvector-cnn · high confidence

The npm package now includes @ruvector/core, a high-performance Rust vector database for Node.js featuring HNSW indexing, SIMD optimizations, and support for multiple distance metrics (Cosine, Euclidean, Dot Product, Manhattan). The package ships with platform-specific native bindings for Linux (x64, ARM64), macOS (Intel, Apple Silicon), and Windows (x64), ensuring correct binary installation across environments. TypeScript configuration (tsconfig.json) and ESLint rules have been added to enforce strict type checking and code quality, while comprehensive test scripts verify native module loading, vector operations, and cross-platform compatibility.

npm · high confidence

Added the new @ruvector/diskann package, which provides approximate-nearest-neighbor (ANN) search using the DiskANN (Vamana) algorithm. This feature enables efficient billion-scale vector search on a single machine by keeping the graph and optional Product Quantization (PQ) codes in RAM while persisting vectors to disk via memory-mapped files. The package exposes a Node.js API for batch insertion, graph building, and k-NN search, with support for cross-platform prebuilds (Linux, macOS, Windows) and TypeScript types.

npm/packages/diskann · high confidence

The \@ruvector/emergent-time\ npm package is now available, exposing the agentic-time layer of the Rust \emergent-time\ crate to JavaScript and TypeScript environments via a \~55 KB WASM build. This package provides an \AgenticClock\ that measures an AI agent's internal structural change (rather than wall-clock time) by processing six channel deltas—belief, memory, retrieval, goal-graph, contradiction, and plan—and returns an explainable tick, a cumulative agentic time reading, the Agentic Time Index (ATI), and a 7-state health classification. It also includes fair-baseline change-point detectors (\WindowedDeltaClock\ and \PageHinkleyDetector\) and a \LearnedWeights\ inference class for scoring failure-approach probabilities, enabling developers to monitor agent health and internal state transitions directly in the browser, edge, or Node.js.

crates/emergent-time-wasm, npm/packages/emergent-time · high confidence

The @ruvector/graph-node package is now available, providing native Node.js bindings (via NAPI-RS) for the RuVector Graph Database. This package supports hypergraph relationships, vector similarity search, and ACID-compliant persistence using a redb backend. It includes a practical subset of the Cypher query language for graph traversal and filtering, with explicit error reporting for unsupported constructs. The release also includes a benchmark suite, platform-specific binaries for Linux, macOS, and Windows, and a publish script to handle platform distribution.

npm/packages/graph-node · high confidence

The @ruvector/node package is now available, providing a single entry point that re-exports core vector database capabilities (VectorDB, CollectionManager) alongside new Graph Neural Network (GNN) features (RuvectorLayer, TensorCompress, differentiableSearch). This allows users to import both functionalities from one package, with the GNN-specific exports also accessible via a dedicated @ruvector/node/gnn subpath. The package is configured to support both CommonJS and ES Module targets.

npm/packages/node · high confidence

This release adds the @ruvector/ospipe TypeScript SDK, which replaces Screenpipe's keyword-based FTS5 search with semantic vector search powered by the RuVector ecosystem. Users can now perform semantic, graph, temporal, and hybrid queries, with built-in PII redaction, frame deduplication, and age-based quantization to reduce storage. The SDK includes a WASM module for browser-side vector operations and maintains backward compatibility with existing Screenpipe code via queryScreenpipe(). Additionally, a new @ruvector/rvf-mcp-server is introduced, exposing RuVector Format (RVF) vector store operations as MCP tools for AI agents like Claude Code and Cursor.

npm/packages/ospipe · high confidence

The new @ruvector/pi-brain package provides a CLI and SDK to interact with the π.ruv.io shared AI brain. Users can search, share, vote on, and manage knowledge memories via commands like \pi-brain search\ and \pi-brain share\, or programmatically using the \PiBrainClient\. The package also exposes MCP server capabilities for integration with tools like Claude Code, enabling agents to access brain functions. Additionally, it introduces a \consciousnessCompute\ method to calculate IIT 4.0 metrics (Φ, CES, etc.) for transition systems.

npm/packages/pi-brain · high confidence

The new @ruvector/postgres-cli package provides a command-line interface to install and manage the RuVector PostgreSQL extension. Users can run a single command (e.g., \npx @ruvector/postgres-cli install\) to automatically detect their OS, install PostgreSQL and Rust if needed, and build the extension, supporting both Docker and native installation methods. The CLI also exposes commands for managing the server (start, stop, logs), connecting via psql, and performing vector operations (create, insert, search) directly from the terminal.

npm/packages/postgres-cli · high confidence

The new @ruvector/raft package provides a TypeScript implementation of the Raft consensus algorithm, enabling distributed systems to achieve leader election, log replication, and fault tolerance. It exposes a \RaftNode\ class that manages node states (follower, candidate, leader), handles RPC communication via a configurable \RaftTransport\, and applies committed commands through a \StateMachine\ interface. The package includes a \RaftLog\ for managing replicated log entries with optional persistence callbacks, and a \RaftState\ manager for handling persistent and volatile state. Users can start nodes, propose commands (if leader), and listen for events like state changes and leader elections.

npm/packages/raft, npm/packages/replication · high confidence

The npm/packages/router location now provides the @ruvector/router package, enabling AI agents to route queries to specific intents using vector-based semantic matching. This new capability includes a SemanticRouter class for managing intents and a VectorDb class for high-performance vector storage with HNSW indexing. The router supports multiple distance metrics (cosine, euclidean, dot, manhattan), allows adding intents with pre-computed embeddings or via an external embedder function, and persists state to disk. It is distributed with native Rust binaries (NAPI-RS) for Linux, macOS, and Windows to ensure SIMD-accelerated performance.

npm/packages/router · high confidence

The npm workspace now includes the @ruvector/ruvllm-wasm and @ruvector/ruvllm-cli packages. The CLI package provides a command-line interface for local LLM inference and benchmarking, supporting hardware acceleration (Metal, CUDA, CPU), GGUF model loading, interactive chat, benchmarking, and an OpenAI-compatible HTTP server. The WASM package exposes a browser-side runtime facade that checks WebGPU, SIMD, and SharedArrayBuffer capabilities, but model loading and text generation are not yet implemented; instead, loadModel, generate, and chat throw RuvLLMWasmNotImplementedError, and INFERENCE\_AVAILABLE is set to false. A guard-publish script prevents publishing the TypeScript wrapper while inference is unavailable, ensuring users are not misled by placeholder behavior.

npm/packages/ruvllm-wasm · high confidence

The new @ruvector/rvf package provides a unified TypeScript/JavaScript SDK for the RuVector Format (RVF), enabling developers to store vectors, manage models, and execute compute kernels within a single .rvf file. The SDK supports Node.js (via native N-API) and WASM runtimes (Deno, browsers, Cloudflare Workers, Bun), offering a consistent API for creating stores, ingesting and querying vectors, and managing copy-on-write branches. It includes robust features such as string-to-numeric ID mapping with atomic sidecar persistence, witness-based audit chains, and the ability to embed and extract Linux kernels or eBPF programs directly into the store.

npm/packages/rvf · high confidence

The \npm/packages/rvf-node\ package now provides native Node.js bindings for the RuVector Format (RVF) vector database, built with Rust via N-API for high performance. This release adds the core SDK API, allowing users to create and manage single-file vector stores with support for k-NN search using HNSW indexing, metadata filtering, and lineage tracking. The package includes a platform loader (\index.js\) that automatically selects the correct native binary for macOS (x64/arm64), Windows (x64), and Linux (x64/arm64, gnu/musl), alongside TypeScript definitions (\index.d.ts\) and comprehensive documentation (\README.md\) detailing the \RvfDatabase\ class methods for ingestion, querying, and state management.

npm/packages/rvf-node · high confidence

The new @ruvector/rvf-solver package exposes a self-learning temporal solver that runs in Node.js, browsers, and edge runtimes via a \~160 KB WebAssembly binary. It provides a three-loop adaptive architecture (fast constraint propagation, medium PolicyKernel skip-mode selection, slow KnowledgeCompiler pattern distillation) with Thompson Sampling, 18 context-bucketed bandits, and SHAKE-256 tamper-evident witness chains. Users can create instances via RvfSolver.create(), train on puzzles with configurable difficulty and seeds, run acceptance tests across three ablation modes (fixed, compiler, learned), inspect policy state, and retrieve witness chains for auditability. The package includes TypeScript definitions, CJS/ESM interop support, and a test suite validating imports, type structures, and WASM integration.

npm/packages/rvf-solver · high confidence

The package now provides a low-level C-ABI WASM module exposing raw \rvf\\\ functions for in-memory vector operations (HNSW indexing, quantization, and query paths) without a high-level \WasmRvfStore\ class. Users are directed to use the \@ruvector/rvf\ package for ergonomic browser usage, while this module serves as the underlying engine. The JavaScript glue code (\rvf\_wasm.js\) and entry points (\rvf\_wasm.mjs\) support both Node.js (CJS/ESM) and browser environments, handling WASM loading via \fs\ in Node and \fetch\ in browsers. The README has been updated to reflect this architecture, clarifying that \WasmRvfStore\ is not exported and that persistence requires manual serialization via \exportBytes\.

npm/packages/rvf-wasm · high confidence

The new @ruvector/scipix package provides a TypeScript client for the SciPix OCR API, enabling users to extract LaTeX, MathML, and text from scientific images, equations, and documents. The client supports single and batch OCR operations, automatic image type detection (PNG, JPEG, WebP, PDF, TIFF, BMP), and configurable options for equation and table detection. It exposes types for OCR results, confidence levels, and health status, allowing integration with local or remote SciPix services.

npm/packages/scipix · high confidence

This release adds the \@ruvector/sona\ npm package, providing Node.js bindings for the SONA (Self-Optimizing Neural Architecture) engine. The package exposes a \SonaEngine\ class that enables sub-millisecond inference-time adaptation via micro-LoRA and deeper background learning through base-LoRA, while using EWC++ to prevent catastrophic forgetting. Users can record inference trajectories, apply learned transformations to inputs, and search for similar learned patterns. The package includes TypeScript definitions, platform-specific native binaries (Linux, macOS, Windows, ARM), and comprehensive examples demonstrating basic usage, custom configuration, and LLM integration.

npm/packages/sona · high confidence

The new @ruvector/tiny-dancer package provides a FastGRNN-based neural router for AI agent orchestration, featuring uncertainty estimation, circuit breaker fault tolerance, and hot-reload capabilities. It exposes a \Router\ class for routing queries to candidates and a new \trainRouter\ function that allows users to train models from DRACO datasets and export them as .safetensors files. The package supports Linux (glibc and musl/Alpine), macOS, and Windows on x64 and ARM64 architectures, with automatic native binary resolution at load time.

npm/packages/tiny-dancer · high confidence

The \npm/packages/typesafe\ package now includes a comprehensive benchmark harness (\bench/\) to measure the local engine's performance against Jev baselines. This addition introduces dataset loaders for Banking77, CLINC150, and HWU64, which fetch and cache canonical public data sources with SHA-256 verification. The harness supports running benchmarks on these datasets, comparing local results against frozen Jev baselines, and enforcing release gates based on accuracy and calibration metrics. It also includes utilities for handling out-of-scope inputs and generating detailed receipts for each run.

npm/packages/typesafe · high confidence

The new @ruvector/wasm-unified package provides a unified TypeScript interface to the RuVector WASM runtime, exposing a comprehensive set of capabilities including 14+ attention mechanisms (such as scaled-dot, multi-head, flash, MoE, Mamba, and various DAG-based attention types), adaptive learning features (Micro-LoRA, SONA, BTSP one-shot learning, and RL algorithms), nervous system simulation (spiking neural networks and synaptic plasticity), a compute credit economy (credit balance, staking, rewards, and transaction history), and exotic computations (quantum-inspired and hyperbolic geometry). The package includes the full TypeScript type definitions, JavaScript implementations, and source maps for these engines, allowing developers to initialize the unified engine and interact with these advanced neural and computational features through a clean, type-safe API.

npm/packages/ruvector-wasm-unified · high confidence

The \crates/rvf\ crate now includes a new \rvf-adapters/agentdb\ module that bridges the agentdb reasoning framework to the RuVector Format. This adapter maps agentdb's vector storage, HNSW index, and memory pattern APIs onto RVF segments: raw vectors are stored in \VEC\_SEG\, HNSW index layers (A/B/C progressive indexing) are serialized into \INDEX\_SEG\, and metadata (task descriptions, rewards, critiques) is stored in \META\_SEG\. The adapter provides \RvfVectorStore\ for CRUD operations, \RvfIndexAdapter\ for building and extracting progressive HNSW layers, and \RvfPatternStore\ for similarity search with reward filtering.

crates/rvf · high confidence

The Ruvector CLI now integrates with Claude Code via a comprehensive hooks system, enabling self-learning capabilities such as Q-learning based agent routing, error pattern recognition, and file sequence prediction. This includes a new \hooks\ subcommand for managing these intelligence features, a PostgreSQL schema (\hooks\_schema.sql\) for persistent storage of learning data, and configuration files (\.claude/settings.json\) to trigger hooks on tool use and session start. Additionally, shell scripts for displaying intelligence status lines in bash and PowerShell have been added to provide real-time feedback on learning metrics.

crates/ruvector-cli · high confidence

Users can now write queries using the Cypher query language against the RuVector graph database. This change adds a complete parser implementation (lexer, parser, AST, semantic analyzer, and optimizer) that converts Cypher text into an Abstract Syntax Tree. The parser supports standard Cypher features including pattern matching (MATCH, OPTIONAL MATCH), filtering (WHERE), projections (RETURN, WITH), mutations (CREATE, MERGE, DELETE, SET), aggregations, and path patterns. It also introduces support for hyperedges (N-ary relationships), allowing queries that involve multiple target nodes in a single relationship pattern. The semantic analyzer validates variable scopes, type compatibility, and aggregation contexts, while the query optimizer applies optimizations like constant folding, predicate pushdown, and join reordering.

crates/ruvector-graph/src/cypher · high confidence

This change adds a new DiskANN (Vamana) approximate nearest-neighbor index to the \ruvector-diskann\ crate. The index supports memory-mapped (mmap) vector storage, allowing large datasets to be searched with resident memory usage proportional only to the active working set rather than the full dataset. It includes a Product Quantization (PQ) module for compressed distance computation and a Vamana graph builder with configurable parameters. Additionally, a feature-gated \reuse-under-drift\ module is introduced, enabling the index to reuse its navigation topology across metric drifts with periodic rebuilds, significantly reducing update costs compared to full rebuilds.

crates/ruvector-diskann/src · high confidence

Users can now run transformer neural networks on FPGA hardware (via PCIe or a network daemon) or simulate them on native CPUs and WebAssembly browsers, achieving predictable, low-latency inference with early-exit gating and cryptographic witness logging. This change adds the \ruvector-fpga-transformer\ crate and its \ruvector-fpga-transformer-wasm\ bindings, along with a signed model-artifact format (manifest, weights, bitstream, and Ed25519 signatures) and a suite of correctness, latency, and gating benchmarks to validate determinism and quantization accuracy.

crates/ruvector-fpga-transformer · high confidence

The new \ruvector-gnn-rerank\ crate provides a second-stage reranking layer for approximate ANN search results. It builds a k-NN graph over the full-precision candidate vectors and applies graph neural score diffusion to smooth out quantization noise, recovering recall lost by the first-stage index. The crate exposes four reranking strategies: \NoisyScoreReranker\ (baseline passthrough), \GnnDiffusionReranker\ (1-hop score propagation), \GnnMincutReranker\ (coherence-gated diffusion), and \ExactL2Reranker\ (exact Euclidean re-scoring). To ensure robustness against adversarial or corrupted inputs, the rerankers validate candidate sets and fail-fast with typed errors (e.g., \RerankerError::NonFinite\) if they encounter NaN/Infinity values or dimension mismatches, preventing silently corrupted rankings. Benchmarks and regression tests confirm that the GNN diffusion variant significantly improves recall@10 compared to the noisy baseline.

crates/ruvector-gnn-rerank · high confidence

The \mcp-gate\ crate now provides a complete MCP server implementation that exposes three tools (\permit\_action\, \get\_receipt\, \replay\_decision\) for AI agents to request permissions and audit decisions. This release introduces a content-addressed schema cache (\SchemaResourceCache\) that uses SHA-256 hashes of canonical JSON to enable order-independent context assembly, significantly reducing recompilation overhead for tool schemas. Additionally, it implements an adaptive runtime monitoring system based on a value-of-information escalation ladder, which uses a cheap keyword detector for initial risk scoring and progressively purchases more expensive investigators only when the value of information justifies the cost, while enforcing 100% inspection for five mandatory high-risk operation classes (privilege escalation, network access, credential use, runtime mutation, and destructive operations).

crates/mcp-gate · high confidence

The \ruvector-matryoshka\ crate now provides three ANN search variants—\FullDimSearch\, \CoarseFineFunnel\, and \HybridSearch\—that exploit Matryoshka Representation Learning to deliver 3–8× faster search with minimal recall loss. Users can build indices that traverse a coarse prefix (e.g., 64 dimensions) to filter candidates, then re-rank the shortlist at full dimension (e.g., 1536 dimensions), optimizing the tradeoff between latency and accuracy for compatible embedding models.

crates/ruvector-matryoshka · high confidence

The \ruvector-maxsim\ crate now provides ColBERT-style late-interaction search that scores documents using multiple token vectors instead of a single averaged embedding. It ships with four index implementations: \FlatMaxSim\ for exact, exhaustive scoring; \BucketMaxSim\ for centroid-filtered approximate search; \HnswMaxSim\ for a greedy small-world (NSW) token-level index; and \GraphMaxSim\ for a centroid-based kNN graph with beam search and MaxSim reranking. A shared \MultiVecIndex\ trait unifies these variants, and a demo binary along with Criterion benchmarks are included to compare latency, throughput, recall, and memory across the different strategies.

crates/ruvector-maxsim · high confidence

This change adds a new Rust crate, \ruvector-diskann-node\, which exposes the core DiskANN index functionality to Node.js via NAPI-RS bindings. It provides a JavaScript-accessible \DiskAnn\ class that supports inserting vectors (single or batched), building the index (synchronously or asynchronously), searching for nearest neighbors, deleting vectors, and persisting/loading the index to disk. The bindings allow users to configure index parameters such as dimension, degree, and PQ settings directly from JavaScript.

crates/ruvector-diskann-node · high confidence

This change introduces the initial implementation of the RuVector Neural Trader (ADR-084) components in the \neural-trader-coherence\ and \neural-trader-replay\ crates. The coherence module provides a threshold-based gate that evaluates market graph state using MinCut, CUSUM drift detection, and boundary stability metrics to control access for retrieval, writing, learning, and actuation. The replay module supplies the data structures and in-memory storage implementations for this system, including a bounded reservoir store for replay segments and a witness receipt logger to ensure auditability of state mutations.

crates/neural-trader-coherence, crates/neural-trader-replay · high confidence

This change adds the \ruvector-gnn-node\ crate, providing Node.js bindings for Ruvector's Graph Neural Network (GNN) features. Users can now install the \@ruvector/gnn\ package to access GNN layers with multi-head attention and GRU cells, perform tensor compression with adaptive levels (None, Half, PQ8, PQ4, Binary), execute differentiable search, and run hierarchical forward passes. The bindings support zero-copy data transfer, TypeScript definitions, and layer serialization/deserialization via JSON.

crates/ruvector-gnn-node · high confidence

Added a new NAPI-RS binding crate (\ruvector-gnn-node\) that exposes the Ruvector GNN library to Node.js applications. This enables JavaScript developers to instantiate and use the \RuvectorLayer\ for graph neural network forward passes (accepting \Float32Array\ inputs for embeddings, neighbors, and edge weights) and to perform tensor compression via \TensorCompress\ with configurable levels (none, half, PQ8, PQ4, binary). The bindings also support serializing and deserializing the GNN layer state to/from JSON.

crates/ruvector-gnn-node/src · high confidence

The \ruvector-tiny-dancer-node\ crate now provides native Node.js bindings for the Tiny Dancer neural router via NAPI-RS. This allows server-side applications to run FastGRNN inference for intelligent request routing with async/await support and multi-threading. The package exposes a \Router\ class with methods for initialization, routing requests, training custom models, and retrieving performance metrics, along with TypeScript type definitions for the configuration, request, and response structures.

crates/ruvector-tiny-dancer-node · high confidence

This change adds the \ruvector-mincut-node\ package, providing native Node.js bindings for the Rust \ruvector-mincut\ library. Users can now perform dynamic minimum cut operations (inserting, deleting, and querying edges) with subpolynomial-time performance directly from JavaScript. The package also exposes a native road routing engine (\RoadRouter\) and a privacy-aware routing variant (\RuFieldRoadRouter\) that adjusts costs based on verified spatial events. The API includes typed batch operations for performance, full TypeScript type definitions, and support for Linux, macOS, and Windows platforms.

crates/ruvector-mincut-node · high confidence

This change adds a new FFI crate (\crates/ruvector-router-ffi\) that exposes the Rust-based vector database and neural routing engine to JavaScript and TypeScript applications using NAPI-RS. Users can now install the \router-ffi\ npm package to perform vector operations such as insert, search, and delete with sub-millisecond latency. The bindings support both synchronous and asynchronous (async/await) APIs, allowing non-blocking execution via Tokio. Key features include zero-copy buffer sharing for \Float32Array\, support for multiple distance metrics (Euclidean, Cosine, Dot Product, Manhattan), HNSW indexing configuration, and persistent storage with memory-mapped I/O. The implementation ensures thread safety through Arc-based concurrency and provides type-safe TypeScript definitions.

crates/ruvector-router-ffi · high confidence

This crate now provides a new sparse inference engine that exploits activation locality to achieve significant performance gains (up to 6× speedup) with minimal accuracy loss. The engine uses a low-rank predictor to identify active neurons and computes only the necessary feed-forward network operations, skipping cold weights entirely. It includes SIMD-optimized backends for CPU (AVX2, SSE4.1, NEON) and WebAssembly, supports GGUF model loading with various quantization types (Q4\_0 through Q6\_K), and features hot/cold neuron caching with LRU/LFU strategies. The implementation also includes comprehensive error handling, configuration options for sparsity and activation types, and integration points for Ruvector and RuvLLM ecosystems.

crates/ruvector-sparse-inference · high confidence

The \ruvector-rairs\ crate now provides an Inverted File (IVF) approximate nearest-neighbor index family featuring three variants: \IvfFlat\ (a classic single-assignment baseline), \RairsStrict\ (which uses dual assignment to improve recall near cluster boundaries), and \RairsSeil\ (which applies the same dual assignment but uses a shared-block layout to reduce memory overhead). The implementation includes the core indexing logic, a k-means clustering module for centroid training, and a comprehensive benchmark suite to evaluate recall and throughput across different probe counts.

crates/ruvector-rairs · high confidence

The new \@ruvector/rvforge\ package provides a zero-dependency CLI (\forge\) that turns a single canonical \.rvf\ agent into signed platform installers for Windows, macOS, Linux, and RVM. It introduces commands to scaffold project configurations (\init\), author and sign agent artifacts (\create\), and perform local builds (\build\) that stage identical embedded payloads or signed locators across all targets. The tool enforces a strict compatibility matrix to reject unsupported runtime and packaging combinations, ensures deterministic output, and includes a typed client for a hosted build service to submit, track, and download verified artifacts.

npm/packages/rvforge · high confidence

The new \rvforge-registry\ crate provides the core data structures and validation logic for the RVForge package registry. It defines a content-addressed object model (PublisherRecord, Release, CapabilityManifest, etc.) where IDs are SHA-256 hashes of canonical JSON, and enforces publication rules such as deny-by-default capabilities and publisher signatures. The crate also implements an append-only Merkle transparency log (RFC 6962) for auditability, along with Ed25519 cryptographic helpers and a comprehensive set of stable error codes for registry operations.

crates/rvforge-registry · high confidence

Adds the \rvm-coherence\ crate, a \no\_std\ real-time coherence scoring engine that monitors inter-partition communication to drive resource allocation and topology changes. The engine computes coherence scores using an Exponential Moving Average (EMA) filter on raw Phi values and tracks cut pressure to trigger split or merge recommendations when partitions become too externally coupled or mutually coherent. It features a two-tier split-decision architecture: a hot-path Fennel-style greedy placer for O(degree) incremental placement of new nodes, and a budgeted Stoer-Wagner mincut algorithm that runs periodically (with adaptive frequency based on CPU load) to produce precise split boundaries. The system is designed to degrade gracefully if the coherence feature is disabled and includes a bridge layer to support future integration with the \ruvector\ ecosystem for advanced mincut and scoring backends.

crates/rvm/crates/rvm-coherence · high confidence

The \rvm-types\ crate now provides the foundational type vocabulary for the RVM coherence-native microhypervisor, defining strongly-typed identifiers for partitions and vCPUs, unforgeable capability tokens with access rights, and fixed-point coherence metrics. It introduces structured types for memory regions, device leases, and proof systems, alongside a comprehensive unified error type (\RvmError\) and 64-byte cache-aligned witness records for tamper-evident auditing. These types are designed for \no\_std\ environments with zero heap allocation and no unsafe code, establishing the shared interface for all RVM subsystems.

crates/rvm/crates/rvm-types · high confidence

The \ruvector-rabitq\ crate now provides a new set of vector indexes (\RabitqIndex\, \RabitqPlusIndex\, \RabitqAsymIndex\) that use rotation-based 1-bit quantization to significantly reduce memory usage while maintaining high recall. These indexes support symmetric (Charikar-style) and asymmetric (inner-product) distance estimators, with an optional reranking phase for higher accuracy. The implementation includes a Struct-of-Arrays storage layout, a cosine lookup table, and padding-safe popcount to handle arbitrary dimensions efficiently. A \VectorKernel\ trait is also introduced to allow pluggable execution backends (e.g., CPU, GPU, WASM) for scan and rerank operations.

crates/ruvector-rabitq · high confidence

The new \ruvector-router-core\ crate provides the foundational vector database and neural routing engine for Ruvector. It enables high-performance vector similarity search using a custom HNSW index with configurable parameters (M, ef\_construction, ef\_search) and supports multiple distance metrics (Euclidean, Cosine, Dot Product, Manhattan) with SIMD-optimized calculations. The crate includes a persistent storage layer backed by \redb\ with memory-mapped file support, advanced quantization techniques (Scalar, Product, Binary) for memory compression, and a neural routing system with strategies like Round-Robin, Latency-Based, and Semantic routing for intelligent request distribution across model endpoints. The implementation includes path traversal security validation in the storage layer and addresses HNSW neighbor-selection heuristics to improve recall on clustered data.

crates/ruvector-router-core · high confidence

The npm CLI package now includes a command-line interface for the RuVector vector database, providing commands for hooks, memory, learning, and swarm operations. The CLI introduces a local intelligence system that persists patterns, memories, trajectories, and error data to a JSON file in the user's home directory, enabling offline usage and basic pattern recognition. Additionally, the package implements a hooks storage layer that supports PostgreSQL as the preferred backend (configured via the RUVECTOR\_POSTGRES\_URL or DATABASE\_URL environment variables) with a JSON file fallback, allowing users to store and retrieve vector embeddings, agent coordination data, and learning trajectories.

npm/packages/cli · high confidence

This change introduces the \ruvector-graph-transformer\ crate, providing a graph neural network where every mutation to graph state requires a formal proof (proof-gated mutation) to prevent silent data corruption. The library includes eight specialized, feature-gated modules: sublinear attention (O(n log n) via LSH/PPR), physics-informed layers (Hamiltonian dynamics with energy conservation), biological layers (spiking attention, Hebbian/STDP learning), verified training (delta-apply rollback with BLAKE3 certificates), manifold operations (product manifolds S^n x H^m x R^k), temporal-causal attention (Granger causality), self-organizing capabilities (morphogenetic fields), and economic/game-theoretic attention (Nash equilibrium). A Node.js binding (\ruvector-graph-transformer-node\) is also added via NAPI-RS, exposing these capabilities to JavaScript/TypeScript with prebuilt binaries for Linux, macOS, Windows, and Android.

crates/ruvector-graph-transformer · high confidence

The new \ruvector-server\ crate provides a production-ready HTTP API for the Ruvector vector database, built on Axum and Tokio. It exposes RESTful endpoints for managing vector collections (create, list, delete) and performing vector operations (upsert, search, retrieve) with support for batch operations and metadata filtering. The server includes built-in CORS, GZIP compression, and request tracing, along with health and readiness probes for deployment. To prevent resource exhaustion, the API enforces strict limits on search result counts (max 10,000), upsert batch sizes (max 10,000 points), and query vector dimensions (max 65,536).

crates/ruvector-server · high confidence

A new \ruvector-sparsifier\ crate is added, providing a dynamic spectral graph sparsifier that maintains a compressed shadow graph preserving the Laplacian energy of the full graph within a configurable error margin. The implementation supports continuous monitoring, fast graph diagnostics, and early anomaly detection via structural drift monitoring. It includes a WebAssembly binding (\ruvector-sparsifier-wasm\) for browser-side and edge-deployed sparsification, exposing methods for building from edges, dynamic insertions/deletions, embedding updates, and spectral audits.

crates/ruvector-sparsifier · high confidence

This change adds the \crates/ruvix\ crate, introducing the RuVix Cognition Kernel—a purpose-built OS for AI agents that replaces traditional process abstractions with capability-gated task spawning and typed semantic queues. The kernel exposes twelve syscalls (including \CapGrant\, \QueueSend\, \RegionMap\, and \VectorPutProved\) that enforce proof-gated mutation across three verification tiers (Reflex, Standard, Deep). The entry also includes the AArch64 bare-metal boot infrastructure (\aarch64-boot\), featuring a custom linker script, target specification, and QEMU integration, alongside a comprehensive benchmark suite (\ruvix\_bench\) that compares RuVix syscall performance and memory overhead against Linux equivalents.

crates/ruvllm · high confidence

The \ruvllm-cli\ crate is added, providing a command-line interface for downloading, managing, and running LLM models optimized for Apple Silicon. Users can download models from HuggingFace Hub (with alias routing to GGUF twins and 307 redirect handling), list and inspect model details, and run interactive chats with speculative decoding support. The CLI also includes a benchmark command for performance metrics and an OpenAI-compatible inference server (\serve\) that supports mock mode for development and a \--strict\ flag to fail on load errors. A \quantize\ command is included but currently fails closed as the GGUF writer is not yet implemented.

crates/ruvllm-cli · high confidence

The \burst-scaling\ package now provides a production-ready auto-scaling infrastructure designed to handle massive traffic spikes (up to 50x baseline, e.g., 25 billion concurrent streams) while maintaining strict latency SLAs (\<50ms p99). This system introduces a predictive scaling engine (\BurstPredictor\) that uses event calendars and historical patterns to pre-warm capacity, alongside a reactive scaler for real-time adjustments based on CPU, memory, and latency metrics. A global \CapacityManager\ orchestrates cross-region scaling across GCP Cloud Run instances with sophisticated budget controls, traffic prioritization (premium/standard/free), and graceful degradation strategies to prevent cost overages during unexpected surges.

npm/packages/burst-scaling · high confidence

Users can now interact with the Ruvector vector database via a new command-line interface (\ruvector\) and a WebAssembly module (\router-wasm\) for browser environments. The CLI provides commands to create databases, insert vectors, perform similarity searches, view statistics, and run benchmarks, supporting multiple distance metrics like cosine and Euclidean. The WASM bindings enable client-side vector search with sub-millisecond latency, allowing developers to integrate vector database capabilities directly into web applications without server dependencies.

crates/ruvector-router-cli, crates/ruvector-router-wasm · high confidence

RvLite is a new standalone vector database crate designed to run entirely in WebAssembly, enabling vector search and graph capabilities in browsers, Node.js, Deno, Bun, and edge environments. It provides a unified orchestration layer over existing WASM crates (ruvector-core, ruvector-graph-wasm, ruvector-gnn-wasm, sona) to support SQL, SPARQL, and Cypher query interfaces, along with graph neural networks and self-learning features. The initial proof-of-concept release (v0.1.0) establishes the WASM build configuration, including a build script to configure getrandom for the wasm\_js backend, and sets up the core architecture for future integration of vector operations, indexing, and persistence.

crates/rvlite · high confidence

RvLite is a new, lightweight (\~850KB WASM) vector database that runs in Node.js, browsers, and Edge environments. It provides a unified API for vector similarity search alongside SQL, Cypher, and SPARQL query capabilities. The package includes a CLI for database initialization, data insertion, and interactive REPL usage, as well as an SDK for programmatic access with support for persistence via JSON files or IndexedDB. It also features an RVF migration tool to convert existing rvlite data to the RVF format.

npm/packages/rvlite · high confidence

The \examples/scipix\ example now includes a complete API server implementation built on Axum. This adds endpoints for text/image OCR, digital ink stroke recognition, legacy LaTeX equation processing, and asynchronous PDF job management (create, status, cancel, and streaming results). The server features configurable authentication via \app\_id\/\app\_key\ headers or query parameters, rate limiting (100 requests/minute), and a result cache. It also includes a CLI binary (\cli.rs\) for running OCR, batch processing, and serving the API, along with a benchmark tool for performance testing.

examples/scipix · high confidence

The \examples/sky-monitor\ example now includes a complete, deterministic sky-monitoring pipeline (Phases 1–4) that ingests synthetic ADS-B traffic and weather data for a fixed observer node (defaulting to the Oakville location). The pipeline stitches raw observations into tracks, projects them into an observer-relative coordinate frame, computes 32-dimensional feature embeddings, and indexes them in an in-memory vector store to calculate novelty scores. These scores feed a composite anomaly-scoring engine that classifies tracks into interpretation bands (Normal through Rare) and generates a daily sky brief summarizing aircraft counts, weather events, and the most unusual track. The example binary demonstrates the full flow, printing track tables, graph stats, similarity pairs, anomaly reports with human-readable reasons, and the daily brief, with an optional \--emit-json\ flag to export the run data for a dashboard.

examples/sky-monitor · high confidence

This change adds the \cognitum-gate-tilezero\ crate, which implements the central arbiter for a 256-tile WASM fabric. TileZero merges worker tile reports into a unified supergraph, applies a three-filter decision pipeline (Structural, Shift, Evidence) to Permit, Defer, or Deny actions, and issues cryptographically signed Ed25519 permit tokens backed by a Blake3 hash-chained receipt log. The release includes the core decision and evidence logic, report merging strategies, cryptographic token handling, and a full suite of benchmarks and usage examples to demonstrate integration.

crates/cognitum-gate-tilezero · high confidence

This change introduces the \ruvector-turbovec\ crate, a new multi-bit TurboQuant approximate nearest-neighbor index that fills the recall gap between 1-bit and 4-bit scalar quantization by adding 3-bit support. The index uses Lloyd-Max centroids for 2, 3, and 4-bit quantization, applies per-coordinate calibration to correct for rotation residuals, and includes an \IdMapIndex\ wrapper that enables O(1) deletion and allowlist-filtered search using external \u64\ identifiers.

crates/ruvector-turbovec · high confidence

Users can now run sparse neural network inference directly in web browsers and Node.js environments via the new \ruvector-sparse-inference-wasm\ crate. This release exposes a \SparseInferenceEngine\ that loads quantized GGUF models and applies PowerInfer-style sparse activation for improved performance, along with dedicated \EmbeddingModel\ and \LLMModel\ wrappers for sentence transformers and text generation. The API supports streaming model loading for large files, runtime calibration to improve predictor accuracy, dynamic sparsity threshold adjustment, and performance measurement utilities.

crates/ruvector-sparse-inference-wasm · high confidence

This change adds the \ruvector-mincut-wasm\ crate, providing JavaScript/TypeScript bindings for the core Rust \ruvector-mincut\ library. Users can now run dynamic minimum cut operations (insert/delete/query edges) directly in browsers and Node.js via WebAssembly. The bindings expose the \WasmMinCut\ class for basic min-cut computations, as well as \WasmThreeLevelHierarchy\ for decomposition and \WasmLocalKCut\ for local k-cut discovery. Additionally, it includes \WasmRoadRouter\ for integer-cost routing and \WasmRuFieldRouter\ for routing with spatial awareness (RuField), enabling real-time risk ingestion and zone/cell binding in web environments.

crates/ruvector-mincut-wasm · high confidence

This change adds the \ruvector-graph-transformer-wasm\ crate, exposing the core graph transformer as a size-optimized WebAssembly module for client-side browser execution. The \JsGraphTransformer\ class provides a JavaScript API for proof-gated graph attention, sublinear attention, physics-informed symplectic integration, biological spiking attention, verified training steps, manifold distance calculations, temporal causal masking, and game-theoretic attention. The package includes generated JavaScript bindings, TypeScript definitions, and a README with installation and usage instructions, enabling users to run the transformer entirely in the browser without server calls.

crates/ruvector-graph-transformer-wasm · high confidence

Added the \ruvector-bounded-rag\ crate, which provides research implementations for context-budgeted retrieval. It introduces three retrieval strategies—TopK (cosine similarity baseline), GraphBFS (graph-based expansion), and MinCut (graph partitioning via Edmonds-Karp min-cut)—along with the necessary data structures (\Corpus\, \Query\, \RetrieverConfig\) and a benchmark binary to evaluate their precision and performance.

crates/ruvector-bounded-rag · high confidence

This change introduces two new crates to the RVM microhypervisor. The \rvm-cap\ crate implements a capability-based access control system featuring unforgeable kernel-managed tokens, a derivation tree for monotonic attenuation and revocation propagation, and a three-layer proof verification system (P1 capability check, P2 policy validation, P3 deep proof) with epoch-based stale handle detection. The \rvm-wasm\ crate adds an optional, compile-time-gated WebAssembly guest runtime, providing agent lifecycle management (spawn, suspend, resume, migrate), a fixed set of capability-gated host functions (IPC, memory, timer), and witness-logged state transitions for auditability.

crates/rvm/crates/rvm-cap · high confidence

The new \ruvector-capgated\ crate enables per-vector read access control in approximate nearest-neighbour search, addressing the limitation of collection-level access control in multi-tenant scenarios. It introduces a \CapMask\ model where each vector requires specific capability bits, and a querier must hold those bits to retrieve the vector. The crate provides three search strategies: \PostFilter\ (baseline, 100% recall, scans all vectors), \EagerMask\ (100% recall, skips distance computation for unauthorised vectors, offering significant performance gains at low access ratios), and \CapGraph\ (sub-linear graph traversal with \~90% recall). This allows users to enforce fine-grained security directly within the retrieval engine using efficient 64-bit bitwise checks.

crates/ruvector-capgated · high confidence

The new \exo-backend-classical\ crate provides a CPU-based implementation of the EXO-AI cognitive substrate, wrapping \ruvector-core\ for vector similarity search and \ruvector-graph\ for hypergraph operations. It features SIMD-accelerated vector operations (SSE4.2, AVX2, NEON), dithered quantization via \ruvector-dither\ to compress activations, and a thermodynamic layer using \thermorust\ to track Landauer energy costs. Additionally, it integrates \ruvector-domain-expansion\ to enable cross-domain knowledge transfer through a 5-phase pipeline (assess, align, project, adapt, validate) coordinated by a transfer orchestrator that uses Thompson sampling to optimize retrieval and graph traversal strategies.

examples/exo-ai-2025/crates/exo-backend-classical · high confidence

The \ruvector-coherence\ crate now provides a comprehensive toolkit for evaluating and monitoring the structural health of attention mechanisms. It introduces batched evaluation capabilities that compute mean coherence deltas, standard deviations, and 95% confidence intervals across multiple sample pairs, alongside quality guardrails that enforce cosine similarity thresholds. Users can now perform side-by-side comparisons of attention masks using Jaccard similarity and edge-flip counts, and track core behavioral metrics such as contradiction rates and entailment consistency. Additionally, the crate adds a Spectral Coherence Score module that monitors graph index health via spectral graph theory properties (including Fiedler estimation, spectral gaps, and effective resistance), featuring a custom CSR matrix implementation with NEON-accelerated sparse matrix-vector multiplication on AArch64 architectures.

crates/ruvector-coherence/src · high confidence

The \rvm-sched\ crate introduces a new 2-signal scheduler for the RVM microhypervisor that combines deadline urgency and cut-pressure boost into a single priority signal. It supports three operating modes—Reflex (hard real-time), Flow (normal), and Recovery (stabilization)—and includes a degraded mode that falls back to deadline-only scheduling when the coherence engine is unavailable. The implementation features epoch-based witness summaries for bulk logging instead of individual switch witnessing, and provides a partition switch path that is currently a validation-only stub pending hardware assembly implementation.

crates/rvm/crates/rvm-sched · high confidence

Added two new crates, \ruvector-delta-core\ and \ruvector-delta-graph\, to support incremental updates and change tracking. \ruvector-delta-core\ provides the foundational \Delta\ trait, \VectorDelta\ types with sparse/dense encoding, compression strategies (LZ4, Zstandard, Delta-of-delta), and utilities for delta streams and time-bounded windows. \ruvector-delta-graph\ builds on this to handle graph-specific changes, offering \NodeDelta\ and \EdgeDelta\ types for tracking property, label, and weight modifications, along with a \DeltaAwareTraversal\ module that performs graph traversals (BFS, DFS, Dijkstra) while accounting for pending delta operations.

crates/ruvector-delta-core, crates/ruvector-delta-graph · high confidence

The \neural-trader-core\ crate now provides the foundational data structures for the RuVector-native market intelligence stack. It defines the \MarketEvent\ envelope for normalizing raw feed messages, along with discriminants for event types (such as NewOrder, Trade, and BookSnapshot) and order sides. The crate establishes a heterogeneous typed graph schema with specific node kinds (e.g., Symbol, Venue, PriceLevel) and edge kinds (e.g., AtLevel, Matched, CorrelatedWith) to represent market structure. It also introduces \PropertyKey\ enums for efficient graph property updates and traits like \EventIngestor\, \GraphUpdater\, and \Embedder\ that define how events are processed into graph deltas and state windows for downstream AI models.

crates/neural-trader-core · high confidence

The \ruvector-delta-index\ crate now provides a vector index optimized for frequent small changes, allowing incremental updates to the HNSW graph without requiring a full rebuild. This includes an \IncrementalUpdater\ for batching and flushing delta changes, a \QualityMonitor\ to track recall metrics and trigger repairs when quality drops, and a \GraphRepairer\ with configurable strategies (Lazy, Eager, Batched, Adaptive) to maintain graph integrity after updates.

crates/ruvector-delta-index · high confidence

The delta-behavior example now includes a complete Rust library implementation featuring a core \DeltaSystem\ trait, 10 gated application modules (such as self-limiting reasoning and event horizons), and portable SIMD-optimized utilities for batch vector operations. It also provides WebAssembly bindings via \wasm\_bindgen\ and a corresponding TypeScript SDK, enabling the coherence system to be used directly in web browsers and Node.js environments.

examples/delta-behavior, examples/delta-behavior/wasm · high confidence

The RVM microhypervisor now boots through a strict, witness-gated 7-phase sequence (Reset Vector, Hardware Detect, MMU Setup, Hypervisor Mode, Kernel Object Init, First Witness, Scheduler Entry) enforced by a \BootTracker\ state machine that rejects out-of-order completion. A measured boot hash chain accumulates per-phase digests to produce an attestation root, supporting either SHA-256 (default) or a legacy FNV-1a fallback. The AArch64 HAL provides the platform-specific foundation for this boot path, including EL2 entry stubs, stage-2 page table management (2-level, 4KB granule), GICv2 interrupt routing, and ARM generic timer drivers, all gated by security checks such as SPSR sanitization and ELR address validation.

crates/rvm/crates/rvm-boot, crates/rvm/crates/rvm-hal, crates/rvm/crates/rvm-memory · high confidence

Added \ruvector-cluster\ and \ruvector-raft\ crates to enable distributed vector database capabilities. \ruvector-cluster\ provides horizontal scaling through consistent hashing, shard management, node discovery (static and gossip-based), and a DAG-based consensus protocol for transaction ordering. \ruvector-raft\ implements the Raft consensus algorithm to ensure strong consistency for cluster metadata, featuring leader election, log replication, snapshot support, and linearizable reads. These crates form the foundation for multi-node Ruvector deployments.

crates/ruvector-cluster, crates/ruvector-raft · high confidence

This change adds the core infrastructure for distributed graph operations in the \ruvector-graph\ crate. It introduces a \ShardCoordinator\ to manage query planning, routing, and result aggregation across multiple graph shards, supporting Cypher-like syntax. It also adds a \ClusterRegistry\ for cross-cluster federation, allowing queries to span independent clusters, and implements a SWIM-based gossip protocol for cluster membership and health monitoring. Additionally, it provides graph-aware replication strategies (full shard, vertex-cut, subgraph) and a gRPC-based RPC layer for inter-node communication, enabling high-performance distributed graph execution.

crates/ruvector-graph/src/distributed · high confidence

The new \emergent-time\ crate provides a dependency-free Rust library for measuring time as internal state change rather than external clock ticks. It implements four physics formalisms—Wheeler–DeWitt, Page–Wootters, entropic, and thermal time—alongside an 'Agentic Time' primitive that tracks AI agent progress through six cognitive channels (belief, memory, retrieval, goal-graph, contradiction, and plan). The crate includes an adaptive Page–Hinkley change-point detector to address baseline drift in real-world traces, a causal timeline for event ordering, and a weight-learning module with a reproducible witness chain for model provenance.

crates/emergent-time · high confidence

The new exo-core crate provides the foundational abstractions for the EXO-AI cognitive substrate, including a unified SubstrateBackend trait for pluggable classical, neuromorphic, and quantum compute backends, an Integrated Information Theory (IIT) module for computing Phi consciousness metrics, and Landauer thermodynamics primitives for tracking computational energy costs. It also introduces a CoherenceRouter for multi-estimator spectral gating, a PlasticityEngine supporting SONA EWC++ and BTSP learning modes with Phi-weighted forgetting protection, and genomic integration utilities for mapping biological age and neurotransmitter profiles to cognitive parameters.

examples/exo-ai-2025/crates/exo-core · high confidence

The new \exo-federation\ crate provides a federated cognitive mesh enabling multiple EXO-AI substrates to collaborate across trust boundaries. It implements post-quantum cryptographic sovereignty using CRYSTALS-Kyber-1024 for key exchange and onion routing for privacy-preserving queries. State consistency is managed via CRDTs (LWW-Map, G-Set, and a custom Transfer CRDT), while consensus is supported by both a PBFT-style Byzantine fault-tolerant protocol and a coherence-gated Raft-style commit mechanism that reduces message complexity from O(n²) to O(n).

examples/exo-ai-2025/crates/exo-federation · high confidence

The new \exo-manifold\ crate provides a simplified manifold storage system for the EXO-AI cognitive substrate, enabling concepts to be represented and transformed as points on learned manifolds. It features a \ManifoldEngine\ that supports storing patterns, retrieving similar patterns via vector similarity search, and strategically forgetting low-salience regions. The implementation uses SIMD-optimized distance calculations (AVX2/NEON) for fast retrieval and includes a \TransferManifold\ component to store and recall cross-domain transfer priors indexed by source and target domains. The crate replaces the previous \burn\-based neural network dependency with a simplified, standalone implementation to avoid version conflicts.

examples/exo-ai-2025/crates/exo-manifold · high confidence

The new \exo-temporal\ crate provides a temporal memory coordinator for the EXO-AI cognitive substrate, managing how memories form, persist, and decay. It features a causal timeline tracking system using a directed acyclic graph and logical clocks to maintain strict causal ordering, and a quantum decay eviction model that uses T1/T2-inspired decoherence times to probabilistically evict stale entries. The system includes an anticipation engine that predicts future states by extrapolating causal trajectories and sequential patterns, and a transfer timeline that records cross-domain knowledge transfers with full provenance. Memory consolidation is handled via a salience-based engine that moves short-term volatile patterns to a long-term store, optimized with SIMD-accelerated similarity searches and sampling-based surprise computation.

examples/exo-ai-2025/crates/exo-temporal · high confidence

Added two new experimental Rust crates: \ruvector-cluster-rag\, which implements hierarchical retrieval using k-means clustering and three search variants (FlatBrute, IVF-style ClusterSearch, and CoherenceTree), and \ruvector-namespace-merge\, which provides S-T min-cut routing to selectively search across multiple vector namespaces. Both crates include deterministic synthetic dataset generators, benchmark binaries for measuring latency and recall, and unit tests for their core algorithms.

(repo-wide) · high confidence

This change adds the \mcp-brain-server\ crate, establishing the core infrastructure for a federated knowledge system. It introduces a Byzantine-tolerant aggregation module (\aggregate.rs\) that filters outlier embeddings using 2-sigma thresholds and reputation-weighted contributions to ensure data integrity. A new authentication layer (\auth.rs\) derives contributor pseudonyms from API keys via SHAKE-256 and enforces minimum key lengths. The server integrates a cognitive engine (\cognitive.rs\) combining Hopfield networks, Dentate Gyrus pattern separation, and Hyperdimensional Computing for anomaly detection and cluster coherence assessment. Additionally, it implements an embedding engine (\embeddings.rs\) that transitions from hash-based to recursive context-aware embeddings as the corpus grows, and a knowledge graph (\graph.rs\) with off-lock rebuild capabilities to prevent service lockups during large-scale updates.

crates/mcp-brain-server/src · high confidence

The new \ruvector-verified\ crate provides proof-carrying vector operations, allowing dimension checks, HNSW inserts, and pipeline compositions to produce machine-checked proof witnesses instead of relying on runtime panics or compile-time constants. It introduces a \ProofEnvironment\ for managing type declarations and proof terms, a \ConversionCache\ for optimizing repeated verifications, and a \FastTermArena\ for efficient term allocation. The library supports verified pipeline composition via \VerifiedStage\ and \compose\_stages\, ensuring type safety across stage boundaries. It also includes a \ProofAttestation\ system that generates 82-byte cryptographic witnesses for audit trails, and a \gated\ proof router that routes verification tasks to Reflex, Standard, or Deep tiers based on complexity to optimize performance.

crates/ruvector-verified · high confidence

Users can now perform hierarchy-aware vector search using hyperbolic embeddings in the Poincaré ball model. The Rust crate (crates/ruvector-hnsw) provides a new HyperbolicHnsw index that supports configurable curvature, tangent-space pruning for faster neighbor selection, and per-shard curvature management with canary testing. A companion WebAssembly crate (crates/ruvector-hnsw-wasm) exposes these capabilities to JavaScript/TypeScript, allowing browser and Node.js environments to create indices, insert vectors, search for nearest neighbors, and use low-level hyperbolic math operations like Möbius addition and exponential/logarithmic maps.

crates/ruvector-hyperbolic-hnsw, crates/ruvector-hyperbolic-hnsw-wasm · high confidence

Added the \mcp-brain\ crate, a local MCP server that enables Claude Code sessions to share and discover learning across sessions via stdio JSON-RPC. It communicates with the \mcp-brain-server\ backend (deployed on Cloud Run) to provide 20 tools for sharing memories, semantic search, quality voting, cross-domain transfer learning, and knowledge partitioning. The implementation includes a PII-stripping pipeline, a two-stage embedding engine using structured hash features and MicroLoRA transforms, and a SHAKE-256 based witness chain for provenance.

crates/mcp-brain · high confidence

Added a new \ruvector-attn-mincut\ crate that implements dynamic min-cut gating as an alternative to standard softmax attention. The crate builds a weighted directed graph from attention logits and uses Dinic's max-flow algorithm to identify and gate irrelevant edges, which are then masked out before row-softmax normalization. It includes configuration options (lambda, tau, eps, seed), temporal hysteresis to stabilize gating decisions over consecutive steps, and witness logging with SHA-256 hashing to verify determinism of the gating process.

crates/ruvector-attn-mincut/src · high confidence

This change adds the \ruvector-mincut-gated-transformer\ crate, providing a transformer inference engine optimized for ultra-low latency through several new capabilities. It introduces a \WeightArena\ for contiguous, cache-friendly weight storage and implements multiple attention mechanisms, including sliding window, spike-driven (multiplication-free), and FlashAttention-style tiled attention. The engine features coherence-driven early exit, allowing the model to skip deeper layers when mincut λ signals indicate high confidence, and an energy-based gate policy that uses λ, boundary, and entropy metrics to dynamically adjust compute tiers, intervene on unstable states, or quarantine requests.

crates/ruvector-mincut-gated-transformer/src · high confidence

A new \ruvector-dag-wasm\ crate has been added, providing a lightweight Directed Acyclic Graph (DAG) implementation compiled to WebAssembly for use in browsers and embedded systems. This library exposes a \WasmDag\ struct via \wasm-bindgen\ that supports core graph operations including adding nodes and edges, topological sorting, and critical path analysis. It is optimized for small binary size by using compact data types (u8, u32, f32), inlining hot paths, and avoiding string operations in critical sections. The API allows users to compute attention scores and serialize the graph state to bytes using bincode.

crates/ruvector-dag-wasm · high confidence

The new \neural-trader-strategies\ crate provides a venue-agnostic strategy runtime for the RuVector Neural Trader, introducing a mandatory \RiskGate\ that enforces position caps, daily-loss kill switches, minimum edge thresholds, and cluster concentration limits before any intent reaches the exchange. It includes three concrete strategies: \ExpectedValueKelly\ for fractional Kelly sizing based on external probability priors, \CoherenceArb\ for cross-market arbitrage between correlated contracts, and \AttentionScalper\ for order-book imbalance scalping with a switchable geometric decay or scaled dot-product attention (SDPA) path. A \CoherenceChecker\ bridges the internal \neural\_trader\_coherence\ gate to the strategy pipeline, blocking actuation when internal confidence is low, while the \Intent\ type standardizes trade requests across venues.

crates/neural-trader-strategies · high confidence

The new neural-trader-wasm crate exposes Rust-based market event processing, coherence gating, and replay memory capabilities to JavaScript/TypeScript environments via WebAssembly. Users can now instantiate coherence gates to evaluate market conditions (allowing or blocking actions based on regime and thresholds), process market events with high-precision BigInt timestamps, and interact with a reservoir-based replay store for historical data retrieval. A dedicated Docker-based test runner validates that the WASM module loads correctly and that exports function as expected in Node.js.

crates/neural-trader-wasm · high confidence

This change adds a comprehensive set of Dockerfiles and supporting scripts to the \crates/ruvector-postgres/docker\ directory, enabling users to build, test, and run the RuVector-Postgres extension in containerized environments. The main \Dockerfile\ implements a multi-stage build supporting PostgreSQL versions 14 through 17 (defaulting to 17) and Rust 1.86, including the \gated-transformer\ dependency and specific features like \graph-complete\ and \gated-transformer\. Additionally, dedicated Dockerfiles are provided for integration testing (\Dockerfile.integration-test\) and unit testing (\Dockerfile.test\), alongside a benchmark runner (\benchmark/Dockerfile\) and helper scripts (\dev.sh\, \run-benchmarks.sh\, \publish-dockerhub.sh\) to streamline development, performance validation, and image publication to Docker Hub.

crates/ruvector-postgres/docker · high confidence

Added the \ruvector-diverse-beam\ crate, a research and evaluation tool for RuVector that implements and benchmarks three diverse ANN search strategies: standard greedy beam traversal, greedy traversal followed by Maximum Marginal Relevance (MMR) reranking, and coherence-pruned traversal. The crate uses an exact flat k-nearest-neighbour graph to isolate and measure the trade-offs between recall and result diversity (mean pairwise distance) on synthetic datasets, providing a benchmark binary and unit tests to validate these strategies without replacing the production HNSW index.

crates/ruvector-diverse-beam · high confidence

This release introduces ruLake, a cache layer that sits in front of existing vector backends (Parquet, BigQuery, Snowflake, etc.) to provide fast, consistent vector search. Key capabilities include witness-addressed cache sharing (using SHAKE-256 digests so identical data across backends shares one compressed entry), federated search across multiple backends with parallel fan-out and adaptive per-shard reranking, and three consistency modes (Fresh, Eventual, Frozen) to balance latency and staleness. The crate also adds bundle persistence (save/restore cache to/from disk) for warm restarts and cross-process sync via sidecar daemons, along with built-in observability (hit rate, prime time) and security hardening (path-traversal validation, JSON caps, witness verification).

crates/ruvector-rulake · high confidence

Added the \ruos-thermal\ crate and its deployment artifacts, providing a CLI tool that snapshots CPU thermal zones and cpufreq policies from sysfs on Raspberry Pi 5 hardware. The tool supports TSV, JSON, and Prometheus textfile-collector output formats, and includes a \--set-profile\ flag (guarded by \--allow-cpufreq-write\) to switch between defined clock profiles (Eco, Default, SafeOverclock, Aggressive, Max). Deployment is handled by \install.sh\, which installs a hardened systemd service and a 30-second timer to periodically write thermal metrics to \/var/lib/node\_exporter/textfile\_collector/\. The crate also includes integration tests for the CLI interface.

crates/ruos-thermal, examples/esp32-mmwave-sensor · high confidence

Adds the \ruvector-core\ package, a high-performance vector database built with Rust and exposed to Node.js via N-API. The package provides a \VectorDb\ class (with a legacy \VectorDB\ alias for compatibility) supporting vector insertion, similarity search, deletion, and retrieval, with configurable HNSW parameters and distance metrics. It automatically loads the correct platform-specific native module for Linux (x64/ARM64), macOS (x64/ARM64), and Windows (x64), ensuring cross-platform support. A publish script is included to generate and publish platform-specific native packages, and full TypeScript definitions are provided for type-safe usage.

npm/packages/core · high confidence

Added the new \ruvector-crv\ crate, which implements the 6-stage Coordinate Remote Viewing (CRV) protocol by mapping each stage to specific ruvector subsystems: Stage I uses Poincaré ball hyperbolic embeddings for gestalt primitives, Stage II employs multi-head attention for sensory data, Stage III utilizes GNN graph topology for spatial sketches, Stage IV applies spiking neural network temporal encoding for emotional/AOL data, Stage V enables differentiable search for interrogation, and Stage VI uses MinCut partitioning for composite modeling. The crate provides a \CrvSessionManager\ to coordinate these stages, manages sessions as directed acyclic graphs, and supports cross-session convergence analysis to identify agreement between multiple viewers targeting the same coordinate.

crates/ruvector-crv/src · high confidence

The new \ruvector-dither\ crate provides deterministic, low-discrepancy pre-quantization dithering for low-bit neural network inference on resource-constrained devices (WASM, Seed, STM32). It introduces \GoldenRatioDither\ and \PiDither\ sequences to decorrelate signals from quantization grid boundaries, reducing idle tones and sticky activations without using any random number generators. The crate exposes \ChannelDither\ for per-channel batch quantization and helper functions like \quantize\_dithered\ and \quantize\_slice\_dithered\ to apply sub-LSB offsets before rounding, ensuring reproducible results across platforms.

crates/ruvector-dither · high confidence

The new ruvector-extensions package adds five major capabilities to the RuVector vector database. Users can now generate embeddings via a unified interface supporting OpenAI, Cohere, Anthropic/Voyage, and local HuggingFace models, with helpers to embed-and-insert or embed-and-search directly into VectorDB. A DatabasePersistence module enables saving and loading database state to disk in JSON, binary, or SQLite formats, with Gzip/Brotli compression, incremental saves, snapshot management, export/import, and auto-save. Graph export functionality allows building similarity graphs and exporting them to GraphML, GEXF, Neo4j (Cypher/JSON), D3.js, and NetworkX formats. A TemporalTracker provides version control with change tracking, time-travel queries, diffs, and reverts. Finally, an interactive web UI server (startUIServer) visualizes vectors as a D3.js force-directed graph with search, similarity queries, and WebSocket live updates.

npm/packages/ruvector-extensions · high confidence

The new \ruvector-filter\ crate provides a filter expression language for combining vector similarity search with metadata constraints. It supports complex boolean expressions (AND, OR, NOT), range queries, string matching, and nested field access. The implementation uses efficient payload indexing (integer, float, keyword, boolean, geo, text) to accelerate filter evaluation. A higher recursion limit (4096) is set to support deeply nested filter expressions without stack overflow.

crates/ruvector-filter · high confidence

The new \ruvector-gnn\ crate provides Graph Neural Network capabilities for RuVector, including GNN layers (Linear, LayerNorm, MultiHeadAttention) operating on HNSW topology, adaptive tensor compression (Full, Half, PQ8, PQ4, Binary) based on access frequency, and continual learning features to mitigate catastrophic forgetting via Elastic Weight Consolidation (EWC) and experience replay. It also introduces cold-tier training for large graphs via block-aligned disk I/O, memory-mapped embedding management for out-of-RAM scenarios, and a query API supporting vector, neural, subgraph, and differentiable search modes.

crates/ruvector-gnn/src · high confidence

Added the \ruvector-lsm-ann\ crate, which implements a Log-Structured Merge Approximate Nearest Neighbor (LSM-ANN) index designed for high-velocity write streams. The library provides three index variants—\BaselineLsm\ (flat in-memory brute-force), \TwoTierLsm\ (in-memory table plus one frozen NSW graph segment), and \FullLsm\ (multi-tier with automatic L1-to-L2 compaction)—allowing users to balance insert throughput against search recall. The crate includes a benchmark binary to measure performance metrics like insert rate and latency, and exposes configuration options for segment sizes and graph construction parameters.

crates/ruvector-lsm-ann · high confidence

The new \ruvector-math\ crate provides a suite of advanced mathematical tools for vector search and AI systems, including implementations for Optimal Transport (Sliced Wasserstein, Sinkhorn, Gromov-Wasserstein), Information Geometry (Fisher Information, Natural Gradient, K-FAC), Product Manifolds, Spherical Geometry, Spectral Methods (Chebyshev expansions), Tropical Algebra, and Persistent Homology (TDA). It also includes comprehensive benchmarks for these modules and a dedicated error handling system (\MathError\) to manage issues like dimension mismatches, numerical instability, and convergence failures.

crates/ruvector-math · high confidence

Users can now deploy the ruvector-postgres extension via a pre-built Docker image (PostgreSQL 17) that includes the extension, pre-downloaded embedding models, and initialization scripts. This change adds the Dockerfile, a slim prebuilt variant, a .dockerignore, and a Makefile to streamline local builds with SIMD detection (AVX-512/AVX2/NEON) and feature flags (HNSW, IVFFlat, quantization, graph, attention, SONA learning). Documentation files (README, DOCKERHUB, graph/learning/sparse delivery notes) provide quick-start and usage guidance for these capabilities.

crates/ruvector-postgres · high confidence

The new \ruvector-pq-search\ crate provides a safe Rust implementation of Product Quantization with Asymmetric Distance Computation (PQ-ADC) for compressed approximate nearest-neighbor search, offering up to 64× storage compression. It exposes a unified \PqSearch\ trait implemented by three index variants: \FlatPqIndex\ for linear scans, \IvfPqIndex\ for coarse IVF clustering with PQ codes, and \ResidualPqIndex\ which improves recall by storing and re-scoring full-precision residuals. The crate includes a benchmark binary (\main.rs\) to evaluate recall, latency, and memory usage against exact brute-force ground truth.

crates/ruvector-pq-search · high confidence

The new \ruvector-replication\ crate provides multi-master vector replication with configurable consistency levels (One, Quorum, All), automatic conflict resolution using vector clocks and CRDTs, and change data capture streaming. It includes a \Replicator\ for managing replication sessions, a \FailoverManager\ for automatic health monitoring and split-brain prevention, and a \SyncManager\ supporting synchronous, asynchronous, and semi-synchronous replication modes.

crates/ruvector-replication · high confidence

The new \ruvector-robotics\ crate provides a unified platform for robotics capabilities, including a bridge for core types and spatial indexing, a perception module for scene understanding and obstacle detection, a cognitive module for autonomous intelligence and behavior trees, and an MCP module for AI agent integration. Users can now leverage features like Gaussian splatting, motion planning, sensor fusion, and swarm coordination, along with comprehensive benchmarks and examples demonstrating these capabilities.

crates/ruvector-robotics · high confidence

The new \ruvector-timesfm\ crate wraps the TimesFM 1.0 200M foundation model to provide RuVector with three core capabilities: a \Forecaster\ that generates point forecasts with calibrated p10–p90 quantile bands (supporting CPU, CUDA, and Metal via the \candle\ backend, with f16 and int8/int4 quantization options for GPU latency or edge memory savings); a forecast-band anomaly detection module that flags observed telemetry points falling outside the model's expected uncertainty range; and an HNSW index rebuild advisor that uses recall-drift forecasts to schedule index maintenance just before recall drops below a defined floor. A JSON-in/JSON-out CLI (\ruvector-timesfm-forecast\) is also provided as the shell-out entry point for the RuVector \time\_series\_forecast\ MCP tool.

crates/ruvector-timesfm · high confidence

The \rvf-forge-core\ crate now includes a new authoring module that allows publishers to construct valid RVF containers from segments and sign them with Ed25519. This change introduces the \ContainerBuilder\ API, which handles segment serialization, capability declaration, and the generation of a deterministic, 4096-byte Level-0 root manifest page at the end of the file. It also adds a \rvforge-rvf-check\ binary to verify that containers produced by the TypeScript CLI are correctly accepted and verified by the Rust core, ensuring cross-implementation interoperability.

crates/rvf-forge-core, crates/rvforge-reader · high confidence

The new rvm-partition crate provides the core partition object model for the RVM microhypervisor, defining partitions as containers for scoped capability tables, communication edges, and coherence metrics rather than emulated VMs. It introduces PartitionManager for creating and tracking up to 256 partitions, a CapabilityTable for managing per-partition access rights, and a zero-copy IPC system using fixed-size MessageQueues and CommEdges for inter-partition messaging. The crate also implements device lease management for time-bounded, revocable hardware access, a strict lifecycle state machine (Created, Running, Suspended, Hibernated, Destroyed), and split/merge logic governed by coherence thresholds and adjacency checks, all built with no\_std and no unsafe code.

crates/rvm/crates/rvm-partition · high confidence

The \ruvector-context\ crate now provides a persistent vector index that physically partitions data by exact context scope, ensuring that tenant data is never mixed. This change introduces a new error contract (\ContextIndexError\) and a quarantine mechanism to handle corrupted or malicious shard files without denying service to other scopes. Security is significantly hardened: the index root must be private to the running user (Unix-only), symlinks are strictly rejected to prevent path substitution attacks, and shard creation uses atomic hard links with inode verification to prevent adoption of pre-existing or aliased files. The index also enforces resource limits on scope counts, search fanout, and result sizes to prevent denial-of-service.

crates/ruvector-context · high confidence

The ruvector package now includes a hooks system that integrates with Claude Code to provide self-learning intelligence, including agent routing, co-edit pattern prediction, and vector memory. Users can initialize this via \npx ruvector hooks init\, which sets up configuration files, generates optimized agent configs, and creates a CLAUDE.md documentation file. The package also ships an MCP server with a new default-deny tool-access policy (ADR-256), allowing operators to restrict exposed tools via environment variables like \RUVECTOR\_MCP\_ALLOW\ and \RUVECTOR\_MCP\_DENY\. Additionally, the CLI now uses a \.meta.json\ sidecar file for database metadata to avoid JSON-parsing binary storage, and the package includes a new \mcp-policy.js\ module for enforcing these access controls.

npm/packages/ruvector · high confidence

Users can now install and use the new spiking-neural package, which provides a high-performance Spiking Neural Network (SNN) library for Node.js. The package includes a CLI for running demos, benchmarks, and training tasks, as well as an SDK for creating feedforward SNNs with features like LIF neurons, STDP learning, and lateral inhibition. A native C++ addon (snn\_simd) is included to accelerate core computations using SIMD instructions (SSE/AVX), with a pure JavaScript fallback for environments where native compilation is not possible. The package is licensed under MIT and includes comprehensive documentation, examples, and validation tests.

npm/packages/spiking-neural · high confidence

The \@ruvector/kge\ package now supports opt-in HMAC-SHA256 signing for saved model envelopes. When calling \kge.save({ key })\ with a secret key (at least 16 bytes), the resulting envelope includes an HMAC signature; \loadKge\ will then reject any model that has been edited or was saved without the correct key, throwing a \KgeError\ with \kind: 'invalid'\. This provides tamper evidence beyond the existing SHA-256 content hash, which only detects corruption but can be recomputed by anyone after an edit. Signed envelopes remain loadable without a key, but unsigned or edited models are rejected when a key is provided during load.

npm/packages/kge · high confidence

The new \ruvector-proof-gate\ crate provides a \WriteGate\ trait and three implementations—\NullGate\ (baseline), \HashChainGate\ (sequential SHA-256 chain), and \MerkleGate\ (Merkle Mountain Range)—that attach a \WriteReceipt\ to every vector write. These receipts commit the ordered write log cryptographically, allowing offline verification of integrity and detection of mutations, insertions, deletions, or reorders. The crate includes a benchmark example and acceptance tests to validate throughput and tamper-evidence guarantees.

crates/ruvector-proof-gate · high confidence

The \ruvector-temporal-coherence\ crate now provides three retrieval strategies for agent memories: a baseline \FlatSearch\ using pure cosine similarity, a \TemporalSearch\ that applies exponential time-decay to penalize older memories, and a \CoherenceSearch\ that further blends a graph-based coherence gate (measuring community relevance) into the ranking. This allows users to trade raw cosine recall for better recency and contextual relevance in memory retrieval.

crates/ruvector-temporal-coherence · high confidence

The \ruvector-temporal-tensor\ crate now provides a new compression engine that reduces vector data size by 4–10x using groupwise symmetric quantization and temporal segment reuse. It automatically selects a bit-width (8, 7, 5, or 3 bits) based on access patterns, allowing hot data to remain high-fidelity while cold data is aggressively compressed. The crate includes a \TemporalTensorCompressor\ for streaming frame compression, a \TieredStore\ for block management, and a C/WASM FFI interface (\ffi.rs\) for external integration.

crates/ruvector-temporal-tensor · high confidence

This change adds the \cognitum-gate-kernel\ crate, a \no\_std\ WASM component that implements the 'Anytime-Valid Coherence Gate' to monitor system stability and authorize autonomous agent actions. The kernel operates on a 256-tile fabric where worker tiles ingest graph deltas (edge additions, removals, and weight updates) and process them through a deterministic tick loop. It enforces safety using three stacked filters: structural coherence via dynamic min-cut, distribution shift monitoring, and e-value accumulation for sequential hypothesis testing. The module provides a public API for initializing tiles, ingesting deltas, and retrieving signed witness receipts that explain permission decisions, alongside comprehensive benchmarks and a security audit report.

crates/cognitum-gate-kernel · high confidence

The new thermorust crate provides a thermodynamic neural-motif engine for Rust, treating computation as energy-driven state transitions with Landauer-style dissipation tracking and Langevin/Metropolis noise. It supports Ising and soft-spin Hamiltonians with configurable coupling matrices and local fields, offering both Metropolis-Hastings (discrete) and overdamped Langevin (continuous) dynamics. The crate includes pre-wired motif factories for ring, fully-connected, Hopfield memory, and random soft-spin networks, along with simulated annealing helpers. Users can track thermodynamic observables such as magnetisation, pattern overlap, binary entropy, free energy, and running energy/dissipation traces. The implementation is backed by correctness tests and microbenchmarks to ensure performance and accuracy.

crates/thermorust · high confidence

The new \ruvllm\_retrieval\_diffusion\ crate provides two parameterized, training-free pipelines built on the \ruvllm\_sparse\_attention\ kernel: \Retriever::generate\_fast\ for autoregressive next-token retrieval using \KvCache\ and \decode\_step\, and \Diffuser::diffuse\ for bidirectional masked discrete diffusion with a MaskGIT cosine schedule. These pipelines allow users to plug in any small-vocab token domain (such as game levels, drum patterns, or MIDI loops) by supplying a corpus and a \RetrievalConfig\, enabling corpus-agnostic generation without autograd or learned weights. A drum-pattern example demonstrates the retriever and diffuser on a 5-token vocab, while the underlying \ruvllm\_sparse\_attention\ crate introduces a \FastGrnnGate\ for near-linear O(N) attention scaling, FP16 KV cache support, and Grouped-Query Attention (GQA) forward paths.

_crates/ruvllm\_sparse\attention · high confidence

The \ruvector-cognitive-container\ crate is now available, providing a sealed cognitive container that orchestrates graph ingest, min-cut, spectral analysis, evidence accumulation, and witness generation within a single epoch. Users can configure memory allocation via a \MemorySlab\ and control compute budgets per phase using an \EpochController\. Each processing cycle (tick) produces a \TickResult\ and appends a hash-linked \ContainerWitnessReceipt\ to a tamper-evident chain, allowing users to verify the integrity and monotonicity of the container's history via \verify\_chain\. The crate exposes public APIs for creating containers, applying deltas (edge additions/removals, weight updates, observations), and retrieving snapshots or verification results.

crates/ruvector-cognitive-container · high confidence

The \ruvector-hailo-cluster\ crate now includes a \.cargo/config.toml\ that applies Cortex-A76 specific compiler flags (including Large System Extensions and FP16 support) to the \aarch64-unknown-linux-gnu\ target, providing a 10-15% latency reduction on Raspberry Pi 5 hardware. This change is accompanied by the addition of udev rules (\99-hailo-ruvector.rules\, \99-radar-ruvector.rules\) to grant the \ruvector-worker\ and \ruvector-bridge\ groups access to Hailo NPU and radar UART devices, as well as Python scripts (\compile-hef.py\, \compile-encoder-hef.py\) to compile ONNX models into Hailo-8 HEF binaries for deployment.

crates/ruvector-hailo-cluster · high confidence

The \ruvector-hnsw-repair\ crate now provides three distinct strategies for handling vector deletions in HNSW graphs: \TombstoneOnly\ (fast, O(1) delete, but recall degrades as tombstones accumulate), \BatchRepair\ (amortizes repair costs by processing deletions in periodic batches, offering a balance of latency and recall), and \EagerRepair\ (immediately reconnects affected edges for best recall, at the cost of higher per-delete latency). These strategies allow users to choose the appropriate tradeoff between deletion speed and search accuracy based on their specific workload requirements.

crates/ruvector-hnsw-repair · high confidence

The \ruvector-sota-bench\ crate now includes a TypeScript-based MetaHarness adapter that connects the benchmark suite to an autonomous optimization loop. This adapter enables Darwin Mode to evolve ANN parameters (such as \ef\_search\ and \m\) and operating policies using Pareto selection, crossover, and curriculum learning. It introduces a signed Flywheel lineage for reproducible, auditable evolution and integrates a Dream Machine evaluation stage to provide external-grounding vetoes, ensuring that generated improvements are verified against real-world evidence before promotion.

crates/ruvector-sota-bench · high confidence

Users can now run the RuVector sublinear-time sparse solver directly in Node.js and web browsers. This change adds \ruvector-solver-node\ (using NAPI) and \ruvector-solver-wasm\ (using wasm-bindgen), exposing APIs to solve sparse linear systems (Ax=b), compute Personalized PageRank, and estimate algorithm complexity. The bindings accept matrices in CSR format, handle input validation, and ensure the heavy computation runs off the main thread in Node.js to prevent event-loop blocking.

crates/ruvector-solver · high confidence

The RuVix Cognition Kernel now includes a new boot sequence defined by ADR-087, implemented in the \ruvix-boot\ and \ruvix-cap\ crates. The boot process follows a strict five-stage pipeline: hardware initialization, RVF manifest verification, kernel object creation, component mounting, and first attestation. Security is enforced via ML-DSA-65 (NIST FIPS 204) signature verification, which panics immediately on failure to prevent fallback boot paths. The system also implements a witness log for cryptographically linked boot attestation and a capability distribution mechanism that restricts the root task to a minimum capability set after the initial mount.

crates/ruvix/crates/boot, crates/ruvix/crates/cap · high confidence

The \ruvector-graph\ crate is added, providing a Neo4j-compatible property graph database with support for nodes, edges, and hyperedges. It includes a schema-first type layer that validates property types and vector dimensions, in-memory indexes for labels and properties, and a BM25 keyword index for text search. The crate also features schema-driven code generation for TypeScript, Python, and Rust, and a pluggable embedding interface with a built-in hash-based embedder for testing.

crates/ruvector-graph/src · high confidence

This change adds the RuVix command-line interface (CLI) and low-level hardware drivers for the Broadcom BCM2711 (Raspberry Pi 4) and BCM2712 (Raspberry Pi 5) SoCs. The CLI provides commands to build kernel images (with support for secure boot signing and release optimizations), manage configuration files, manipulate Device Tree Blobs (DTBs), and flash kernel images to target devices. The hardware driver crate implements essential peripherals including GPIO, Mini UART, VideoCore Mailbox communication, and the legacy interrupt controller, enabling the kernel to interact with Raspberry Pi hardware.

(repo-wide) · high confidence

The RuVix Cognition Kernel now includes a platform-agnostic Hardware Abstraction Layer (HAL) defining traits for Console, Interrupt Controller, Timer, MMU, and Power Management, alongside concrete AArch64 device drivers for the PL011 UART, GICv2 interrupt controller, and ARM Generic Timer. These drivers implement the HAL traits to provide serial console I/O, interrupt routing and prioritization, and monotonic timekeeping with deadline scheduling on the QEMU virt machine, while the MMIO utility module ensures safe, barrier-protected memory-mapped I/O operations.

(repo-wide) · high confidence

The \ruvector-spann\ crate now provides three partition-index variants—\SinglePartition\ (hard IVF baseline), \SpillPartition\ (fixed-threshold spilling), and \CoherenceSpill\ (dynamic coherence-ratio spilling)—to address the boundary problem in approximate nearest neighbor search. By spilling boundary vectors into adjacent partitions at build time, these variants allow queries to achieve higher recall with fewer partitions probed compared to hard-assignment IVF. The crate also includes L2 and cosine distance utilities, a deterministic k-means implementation, and a benchmark binary to measure recall, throughput, and memory across different spill strategies.

crates/ruvector-spann · high confidence

The \ruvector-turboquant\ crate now provides a new 4-bit quantized vector datatype (Turbo4) that stores vectors as packed nibbles (D/2 + 8 bytes) using deterministic randomized rotation and Lloyd-Max quantization, eliminating the need to store original float vectors. It supports three scoring tiers: symmetric code-to-code distance for graph construction, asymmetric int8-query-to-code distance for fast traversal, and exact f32 rescoring for final ranking. Additionally, it introduces a 1-bit candidate generation plane (RaBitQ-style) that uses pure AND+POPCNT operations for bandwidth-efficient initial candidate selection, alongside AVX2 SIMD kernels for accelerated dot-product calculations.

crates/ruvector-turboquant · high confidence

Adds a new \ruvector-typesafe-wasm\ crate that exposes the core decision engine to JavaScript via \wasm-bindgen\. This allows users to create typed decision engines (supporting hash or ONNX embedders) and perform operations such as training with optional calibration data, making decisions, running optimization campaigns, and retrieving statistics, all through a JSON-based API that mirrors the native binding contract.

crates/ruvector-typesafe-wasm · high confidence

Adds a new \ruvector-coherence-hnsw\ crate that implements a traversal-direction coherence gate for beam search on flat proximity graphs. This feature introduces two search modes—\CoherenceGatedSearch\ (fixed threshold) and \AdaptiveCoherenceSearch\ (dynamic threshold)—that prune neighbor expansion when candidates are directionally off-path relative to the query, aiming to reduce computational overhead while maintaining recall. The crate also includes a benchmark binary and supporting modules for graph construction and dataset generation to validate these search behaviors.

crates/ruvector-coherence-hnsw · high confidence

Adds the \ruvector-speculative-ann\ crate, which implements a draft-then-verify approximate nearest-neighbour search strategy. This feature introduces three search variants: a full-precision linear scan baseline, a scalar-quantized (u8) draft index, and a speculative index that uses the draft to propose candidates and exact f32 distances to verify and re-rank them. The speculative index includes an adaptive controller that adjusts the number of candidate proposals based on rolling recall feedback to balance latency and accuracy. The release also includes a benchmark binary and deterministic synthetic dataset generation tools to evaluate these variants.

crates/ruvector-speculative-ann · high confidence

The \ruvector-graph\ crate now includes a complete query execution engine located in \src/executor\. This adds support for logical and physical query plans, vectorized operators (such as NodeScan, EdgeScan, Filter, Join, and Aggregate), and a Volcano-style pipeline execution model. Users benefit from query result caching with LRU eviction and TTL support, as well as parallel execution capabilities powered by the \rayon\ crate. The engine also integrates cost-based optimization using collected table and column statistics to improve query performance.

crates/ruvector-graph/src/optimization · high confidence

The \ruvector-graph\ crate now includes a new \hybrid\ module that enables combining vector similarity search with graph traversal. This adds support for semantic search via a Cypher-like parser (recognizing \SIMILAR TO\ and \SEMANTIC PATH\ syntax), Graph Neural Network (GNN) inference for node classification and link prediction, and RAG (Retrieval Augmented Generation) integration for multi-hop reasoning. The module also provides a \HybridIndex\ that indexes node, edge, and hyperedge embeddings using either HNSW or Flat indexes, allowing users to perform hybrid queries that match graph patterns while filtering by vector similarity.

crates/ruvector-graph/src/hybrid · high confidence

The RuVix Cognition Kernel now provides the core primitives for inter-task communication and memory management. The \ruvix-queue\ crate implements an io\_uring-style, lock-free ring buffer for message passing, supporting zero-copy semantics via descriptors (restricted to Immutable or AppendOnly regions for TOCTOU safety), priority-based delivery, and optional WIT schema validation. The \ruvix-region\ crate introduces capability-protected memory regions with three policies: Immutable (write-once), AppendOnly (monotonic writes), and Slab (fixed-size slot allocation), ensuring physically contiguous, demand-paging-free memory. Both crates include comprehensive benchmarks and integration tests to verify performance and correctness.

crates/ruvix/crates/queue, crates/ruvix/crates/region · high confidence

Adds the \ruvector-recall-bounded\ crate, which provides experimental implementations of threshold-driven similarity search for RuVector. The crate includes three search variants—\LinearScan\ (exact baseline), \HnswBeamSearch\ (HNSW-style greedy graph walk), and \ThresholdBeam\ (graph search with fixed expansion budget)—along with a benchmark binary to measure empirical recall, latency, and memory usage against an exact linear scan baseline.

crates/ruvector-recall-bounded · high confidence

The new \ruvector-retrieval-receipt\ crate provides cryptographic receipts that commit a query's top-k results (along with copies of each vector's ingestion \WriteReceipt\) so that a receipt/result pair, once issued, cannot be silently mutated in transit or in storage. It offers two receipt variants—\PerResultReceipt\ (sequential SHA-256 chain) and \MerkleReceipt\ (binary Merkle tree with O(log k) inclusion proofs)—and adds Ed25519 signed anchoring for origin authentication, including batched signing to amortize signing costs. A \BatchScheduler\ implements a hybrid fill policy (max size or max wait time) to manage batch assembly latency, and a \state\_anchor\ module allows periodic, query-independent anchoring of the index's write-chain root. The crate also includes benchmarks and a discrete-event simulation to measure receipt generation, verification, and end-to-end batch-fill latency.

crates/ruvector-retrieval-receipt · high confidence

The new @ruvector/rudag package provides a Directed Acyclic Graph (DAG) library that uses Rust compiled to WebAssembly for high-performance graph operations. It features automatic cycle detection, topological sorting, and critical path analysis to identify execution bottlenecks. The library includes a self-learning attention mechanism that scores nodes by importance, helping users prioritize optimizations. It supports both browser and Node.js environments, with automatic persistence to IndexedDB in browsers and file storage in Node.js. A CLI tool is included for command-line DAG operations, and the package provides TypeScript definitions for type-safe usage.

npm/packages/rudag · high confidence

The DrAgnes example application is now available, providing a complete, client-side workflow for skin lesion analysis. It features a camera capture component for dermoscopic images, a MobileNetV3 WASM classifier for lesion identification, and a Grad-CAM overlay for visualizing model attention. The app also implements the ABCDE dermoscopic scoring rule, a lesion history timeline, and a 'collective intelligence' client that shares de-identified, differentially private embeddings to a central brain service. This entry covers the UI components, classification logic, and privacy-preserving sync client within the DrAgnes example.

examples/dragnes, examples/dragnes/.svelte-kit/types · high confidence

This change introduces the \ruvector-kge\ crate, providing holographic knowledge-graph embeddings (HolE) with approximate nearest-neighbor (ANN) retrieval via an HNSW index and a governed self-optimization loop. For users, this enables scalable link prediction by combining batched mat-vec scoring with exact reranking, while enforcing strict input limits (e.g., 1M entities, 100M triples) to prevent resource exhaustion. The implementation includes security checks against symmetry-pattern poisoning and membership inference attacks, ensuring that confidence drops under attack rather than silently degrading. Evaluation metrics (MR, MRR, Hits@K) are computed with filtered ranking and randomized tie-breaking for reproducible, fair comparisons.

crates/ruvector-kge · high confidence

The Micro HNSW WASM crate has been updated to version 2.3, introducing a suite of 22 new neuromorphic computing functions including spike-timing vector encoding, homeostatic plasticity, oscillatory resonance, winner-take-all circuits, and dendritic computation. These features integrate a Spiking Neural Network (SNN) layer with the existing HNSW vector search, allowing vector similarity to drive neural currents and enabling temporal pattern recognition. The update also includes significant performance optimizations, such as replacing division operations with pre-computed reciprocal constants, which resulted in a 5.5x speedup for SNN tick operations and an 18% improvement in STDP processing. The binary size remains under the 12KB target, and the crate now includes a Verilog hardware description for ASIC deployment.

crates/micro-hnsw-wasm · high confidence

This change introduces the \ruvector-kge-ffi\ crate, providing a native Node.js binding (via napi-rs) for the \@ruvector/kge\ knowledge-graph embedding library. It exposes the same JSON-in/JSON-out \Model\ API as the existing WebAssembly build, supporting HolE and RotatE scorers, ANN-accelerated link prediction, and self-optimization campaigns. The native binding adds asynchronous training via \napi::AsyncTask\ to keep CPU-intensive work off the JS thread, and includes opt-in HMAC-signed model envelopes for secure serialization and deserialization.

crates/ruvector-kge-ffi · high confidence

The \timesfm\ crate now provides a native Rust implementation of Google's TimesFM 1.0 200M decoder-only Transformer, powered by the Candle library. This enables zero-shot time-series forecasting directly within RuVector without requiring a Python microservice. The port supports CPU execution and optional GPU acceleration via CUDA or Apple Metal, and includes a weight-conversion script to bridge PyTorch checkpoints to Rust safetensors. To ensure reliability, the crate ships with parity validation tools that verify numerical agreement against the official PyTorch reference, as well as benchmarks for latency and quantized inference (int8/int4).

crates/timesfm · high confidence

Added a new set of examples in \crates/ruvector-dag/examples/exotic\ that explore systems responding to internal tension and structural coherence rather than external goals. This includes \synthetic\_reflex\_organism.rs\ (homeostasis via stress minimization), \timing\_synchronization.rs\ (phase-locked loops using DAG coherence), \coherence\_safety.rs\ (structural safety via coherence thresholds), \artificial\_instincts.rs\ (behavioral biases via MinCut boundaries), \living\_simulation.rs\ (fragility-aware modeling), \thought\_integrity.rs\ (reasoning monitored as coherence), and \federated\_coherence.rs\ (distributed consensus through structural alignment).

crates/ruvector-dag/examples/exotic · high confidence

The \crates/ruvector-attention-unified-wasm/pkg\ directory now contains the published WebAssembly artifacts for the \@ruvector/attention-unified-wasm\ npm package. This release provides a unified API for 18+ attention mechanisms across Neural, DAG, Graph, and State Space Model categories, including specific implementations like Multi-Head, Flash, GAT, GCN, and Mamba SSM. The package includes the generated JavaScript bindings, TypeScript definitions, and the WebAssembly module, enabling users to import and run these attention mechanisms in browser and edge environments.

crates/ruvector-attention-unified-wasm/pkg · high confidence

Developers can now use the ACORN predicate-agnostic filtered HNSW index and the RaBitQ 1-bit quantized index directly in browsers and edge runtimes (Cloudflare Workers, Deno, Bun). This change introduces the \@ruvector/acorn-wasm\ and \@ruvector/rabitq-wasm\ npm packages, exposing \AcornIndex\ and \RabitqIndex\ classes through WebAssembly bindings. The ACORN index supports filtered searches with configurable selectivity (gamma=1 or gamma=2) to maintain high recall at low predicate selectivity, while the RaBitQ index provides a memory-efficient, deterministic alternative for standard nearest-neighbor search.

crates/ruvector-acorn, crates/ruvector-acorn-wasm, crates/ruvector-rabitq-wasm · high confidence

The edge-net example now includes a comprehensive suite of new AI and security modules. A unified attention architecture has been added, supporting neural, DAG, graph, and state-space attention paradigms to handle context ranking and task orchestration. P2P federated learning is enabled via a gossip protocol with TopK gradient sparsification, Byzantine tolerance, and differential privacy. Model adaptation is handled by a MicroLoRA adapter pool with LRU eviction and quantization support, while an HNSW vector index provides efficient approximate nearest neighbor search. Additionally, an adversarial simulation framework allows users to test network resilience against attacks such as DDoS, Sybil, and double-spend attempts.

examples/edge-net · high confidence

Added a new example application in \examples/cmb-consciousness\ that applies Integrated Information Theory (IIT) metrics to Cosmic Microwave Background data. The tool downloads Planck power spectrum data (with a synthetic fallback), constructs transition probability matrices, and computes IIT Phi, causal emergence, and SVD emergence. It includes specific analyses for cross-frequency foreground contamination using Planck band data, an emergence sweep to identify natural resolution scales, and a HEALPix-inspired spatial sky map to detect anomalous regions with high integrated information.

examples/cmb-consciousness · high confidence

This change introduces the operational foundation for the RuVector streaming service on Google Cloud Run. It adds a multi-stage Dockerfile that builds a Rust core and Node.js service layer, alongside a comprehensive Cloud Build pipeline that automates building, security scanning, and a canary deployment strategy across US Central, Europe West, and Asia East regions with a global load balancer. The service itself is enhanced with a new \LoadBalancer\ component featuring circuit breakers, per-client rate limiting, and health-based routing, while the \streaming-service-optimized\ module implements advanced performance capabilities including adaptive batching with priority queues, multi-level compressed caching, and connection pooling with health checks.

npm/packages/cloud-run · high confidence

Added a new React-based dashboard example in examples/decompiler-dashboard that provides a unified interface for exploring and decompiling NPM packages. The app includes an Explorer page for browsing pre-loaded version data with module trees, code viewers, and diff comparisons; a Decompiler page for live decompilation of NPM packages with progress tracking and module splitting; and an RVF Viewer for inspecting vector file manifests. The implementation features statement-boundary module splitting, code beautification, syntax highlighting, and download capabilities for modules and metrics.

examples/decompiler-dashboard · high confidence

This change introduces a complete build and deployment environment for the mcp-brain-server. It adds a minimal Cargo workspace configuration to support isolated builds, along with five distinct Dockerfiles: a main server image, a minimal runtime image, a thin SSE proxy image, a worker image for Cloud Run Jobs, and a trainer image for daily discovery tasks. To support these builds, the Dockerfiles include logic to patch dependencies (such as downgrading \ruvector-mincut\ and \ruvector-solver\ to version 2.0.6 and removing unused features) and apply code fixes for compatibility. Additionally, the change provides Google Cloud Build configuration files for each image and a comprehensive deployment script that handles GCP resource provisioning, including Firestore, GCS buckets, Secret Manager, and Cloud Run services.

crates/mcp-brain-server · high confidence

The \examples/ruvLLM/esp32\ directory now contains a complete Rust crate for running large language model inference on ESP32 microcontrollers. This adds memory-efficient, INT8-quantized attention mechanisms (including a simplified single-head \MicroAttention\ and an O(n) \LinearAttention\) and rotary position embeddings optimized for chips without an FPU. It also introduces a federation module that enables distributed inference across multiple ESP32 chips, supporting pipeline and tensor parallelism, a FastGRNN-based micro-router for dynamic chip selection, and configurations for medium (100–500 chips) and massive-scale (up to 1M chips) clusters. A benchmark suite is included to measure performance metrics like tokens per second and latency, while a diagnostics module provides automated error detection and fix suggestions for common build, flash, and runtime issues.

examples/ruvLLM/esp32 · high confidence

The Edge-Net dashboard now provides a comprehensive interface for monitoring distributed compute operations and managing user contributions. Users can view real-time network statistics, visualize network topology, and track specialized network performance. The dashboard includes a Brain Status panel to monitor knowledge network connectivity and halving epochs, an Economics Overview for rUv supply and reputation tiers, and a Rewards Guide. A new Consent Widget allows users to control their contribution settings, including CPU limits, GPU usage, and battery awareness, while earning rUv credits for idle compute. The interface also features a CDN Panel for managing WASM modules and scripts, an Activity Panel for real-time event logging, and a Debug Console for filtering and exporting logs.

examples/edge-net/dashboard · high confidence

Added three new examples to the \ruvector-gnn\ crate: \diskann\_real\_trajectory.rs\ validates the reuse-under-drift policy on a real learned-GNN embedding trajectory from the ogbn-arxiv citation graph; \triggered\_rebuild.rs\ compares sampled-recall rebuild triggers against fixed periodic rebuilds under variable-rate drift; and \loss\_demo.rs\ demonstrates the usage of MSE, Binary Cross Entropy, and Cross Entropy loss functions along with their gradients and a basic training loop.

crates/ruvector-gnn/examples · high confidence

This change introduces the \ruvector-gpu-runner\ crate, a Rust-based tool for launching, supervising, and auto-destroying training jobs on rented vast.ai GPUs. It enforces strict budget caps (USD and hours), uses keyless GCS artifact uploads via signed URLs, and includes safety controls like instance recovery after SIGKILL and client-side offer filtering. Alongside the runner, a new \openjev-small-v0.toml\ configuration is added to \ruvector-typesafe-train\, defining the hyperparameters for the initial OpenJev training run.

crates/ruvector-gpu-runner, crates/ruvector-typesafe-train · high confidence

The examples/google-cloud directory now includes a comprehensive benchmark suite for RuVector on Google Cloud Run with GPU support. This adds a CLI and HTTP server (via Axum) to run and serve benchmarks for distance computations, HNSW indexing, GNNs, quantization, and CUDA-accelerated operations. It introduces SIMD-optimized vector math (AVX2/AVX-512/NEON) and GPU detection, plus self-learning industry models (e.g., healthcare diagnostics, financial trading) using RuVector's GNN and attention crates. Benchmark results can be exported as JSON, CSV, HTML, or Markdown reports.

examples/google-cloud · high confidence

This change introduces the \hnsw\_rs\ library, providing a Rust implementation of Hierarchical Navigable Small World graphs for approximate nearest neighbor search. It exposes a C-compatible API (via \libext.rs\) for integration with Julia and other languages, supporting data types such as f32, f64, and various integer sizes. The library includes robust persistence features, allowing the graph and data vectors to be dumped to and reloaded from disk, with optional memory-mapped file access (\datamap.rs\) to optimize memory usage for large datasets. Additionally, it supports parallel insertion and search operations, filtering capabilities, and the ability to flatten the graph structure for neighborhood analysis.

_patches/hnsw\rs · high confidence

Introduces the \ruvector-hailo\ crate, providing an embedding backend that leverages the Hailo-8 NPU on Raspberry Pi 5 (with AI HAT+) for accelerated inference, while maintaining a CPU-based fallback using the \candle\ library for compatibility. The implementation includes a \HailoEmbedder\ that implements the \EmbeddingProvider\ trait, allowing seamless swapping between NPU and CPU inference paths. It supports feature-gated builds for default (disabled), CPU fallback, and NPU+CPU fallback modes, with a multi-pipeline pool architecture to handle concurrent requests. The crate also includes security hardening via HEF integrity checks, dependency auditing configuration, and comprehensive documentation.

crates/ruvector-hailo · high confidence

The \ruvector-kalshi\ crate introduces a full integration layer for the Kalshi exchange, providing RSA-PSS-SHA256 request signing, a REST client with a live-trade safety gate, and WebSocket market data normalization. It includes three example runners: \live\_trade\ for executing real orders with strict risk gates, \paper\_trade\ for end-to-end simulation with replay and coherence checking, and \bench\_signing\ for performance validation of the signing internals. The crate also features a \brain\ module for sharing market resolutions and strategy P&L, a token-bucket rate limiter, and support for canceling and amending orders.

crates/ruvector-kalshi · high confidence

This change introduces a new \ruvector-graph-transformer-node\ crate that exposes the core graph transformer capabilities to Node.js applications via NAPI-RS. The bindings provide a \GraphTransformer\ class allowing JavaScript users to perform proof-gated operations (creating gates, proving dimensions, composing proof chains, and verifying attestations), as well as access to sublinear attention, physics-informed Hamiltonian layers, biologically-inspired spiking networks, verified training steps, manifold distance calculations, and temporal causal attention. This crate embeds a self-contained implementation to avoid coupling with the evolving Rust core crate.

crates/ruvector-graph-transformer-node/src · high confidence

Added the OSpipe example, which replaces Screenpipe's keyword-based FTS5 search with semantic vector search using the RuVector ecosystem. The example introduces a Rust crate and server binary that ingests screen, audio, and UI capture frames through a pipeline featuring PII redaction, cosine-similarity deduplication, and age-based vector quantization. It provides a REST API for semantic, keyword, graph, and hybrid search, along with WASM and TypeScript SDK support for browser and Node.js integration.

examples · high confidence

The \photonlayer-bench\ crate introduces a comprehensive benchmarking framework for the optical simulation core. It provides a CLI and library API to evaluate a learned optical frontend against digital baselines, demonstrating that a learned phase mask preserves classification accuracy while significantly reducing sensor resolution (compression) and digital decoder complexity. The suite includes a deterministic hill-climbing mask learner, a compact nearest-centroid digital decoder, and differential-detection readout logic. It also features real-data MNIST support, privacy leakage analysis via reconstruction attacks, and biometric-style 1:1 verification metrics.

(repo-wide) · high confidence

The \ruvector-decompiler\ crate introduces a new decompilation pipeline for minified JavaScript bundles and LLM model weight files. For JavaScript, it parses bundles into a reference graph, partitions modules using MinCut, infers human-readable names via a multi-strategy system (training corpus, string patterns, and optional neural inference), and beautifies the output with indentation and provenance witness chains. For LLM weights, it provides parsers for GGUF and Safetensors formats to reconstruct architecture, layer topology, tokenizer info, and quantization details, also generating witness chains for provenance.

crates/ruvector-decompiler/src · high confidence

The examples/edge directory now includes a complete distributed AI swarm implementation. This adds a SwarmAgent with coordinator/worker roles, P2P communication via WebSocket or shared memory, and distributed Q-learning pattern synchronization across agents. The example also introduces vector memory sharing for RAG, tensor compression using LZ4 with 8-bit and 4-bit quantization, and a GUN-based decentralized sync layer (currently running in local-only mode with a deprecation warning for the upstream Rust GUN backend).

examples/edge · high confidence

The \examples/sky-monitor/wasm\ crate introduces a WebAssembly library that brings core SkyMonitor capabilities to the browser. It exposes \SkyProjector\ for WGS-84 to observer-relative azimuth/elevation/range conversion and polar 'fisheye' screen mapping, \AnomalyScorer\ for baseline-based anomaly scoring, and \SatPropagator\ for SGP4 satellite propagation from TLEs. Additionally, it provides \embed\_track\ and \novelty\ functions to compute 32-dimensional track embeddings and vector novelty scores in the browser, mirroring the native indexer's calibration and normalization logic.

examples/sky-monitor/wasm · high confidence

The \ruvllm-wasm\ crate now exposes three new browser-compatible capabilities via WebAssembly bindings: an HNSW-based semantic router for fast pattern matching, a MicroLoRA adapter for ultra-lightweight per-request model adaptation, and Pi-quantization tools for ultra-low-bit weight compression. These are implemented in new source files (\hnsw\_router.rs\, \micro\_lora.rs\, \pi\_quant\_wasm.rs\, \quant\_bench\_wasm.rs\) and re-exported from \lib.rs\, with a new \intelligent\ feature flag added to \Cargo.toml\ to gate the combined intelligent learning system. Documentation and examples have been added to guide usage.

crates/ruvllm-wasm · high confidence

This change introduces three new WebAssembly packages available via npm: \ruvector-economy-wasm\, \ruvector-exotic-wasm\, and \ruvector-learning-wasm\. The economy module provides a CRDT-based credit ledger for P2P consistency, featuring stake/slash mechanics, reputation scoring, and an early-adopter reward curve that decays from 10x to 1x as network compute grows. The exotic module adds coordination primitives for distributed systems, including Neural Autonomous Organizations (NAO) with quadratic voting, morphogenetic networks, and time crystals. The learning module exposes reinforcement learning and optimization algorithms for agent training. All packages include comprehensive TypeScript definitions, JavaScript bindings, and documentation to facilitate integration into browser, Node.js, and edge runtime environments.

crates/ruvector-economy-wasm, crates/ruvector-exotic-wasm, crates/ruvector-learning-wasm · high confidence

The \examples/onnx-embeddings-wasm\ directory now contains a complete Rust crate that enables generating text embeddings directly in web browsers and other WebAssembly runtimes. This example exposes a \WasmEmbedder\ class via \wasm\_bindgen\, allowing JavaScript users to load an ONNX model and tokenizer, then compute single or batch embeddings, calculate cosine similarity, and configure pooling strategies (Mean, CLS, Max, etc.) and normalization. It serves as a portable, browser-side alternative to server-side embedding generation.

examples/onnx-embeddings-wasm · high confidence

This change introduces \ruvector-verified-wasm\, providing WebAssembly bindings that allow proof-carrying vector operations (dimension verification, typed HNSW indices, and 82-byte proof attestations) to run entirely client-side in the browser. It also adds two new example applications: \rvf-kernel-optimized\, which demonstrates embedding Linux kernels and eBPF programs into an RVF store with verified vector ingestion, and \verified-applications\, a suite of ten domain-specific demos (including financial routing, medical diagnostics, and agent contracts) that showcase formal verification gates for structural safety.

crates/ruvector-verified-wasm, examples/rvf-kernel-optimized, examples/verified-applications · high confidence

This change introduces the \ruvector-math-wasm\ crate, providing JavaScript/TypeScript bindings for the underlying \ruvector-math\ library. It enables browser-based vector search capabilities by exposing WebAssembly interfaces for optimal transport algorithms (including Sliced Wasserstein, Sinkhorn solver, and Gromov-Wasserstein distances), information geometry (Fisher Information, Natural Gradient), product manifolds, and spherical spaces. Users can now perform these complex mathematical computations directly in the browser via the exposed WASM API.

crates/ruvector-math-wasm/src · high confidence

This change introduces the \ruvector-mincut-gated-transformer-wasm\ crate, providing JavaScript-friendly WebAssembly bindings for the mincut-gated transformer. It enables browser-based transformer inference with deterministic latency bounds and coherence control via dynamic minimum cut signals. The API exposes \WasmTransformer\ (with micro, baseline, and custom configurations), \WasmGatePacket\ for coherence signals, and \WasmSpikePacket\ for event-driven scheduling. Users can run inference via \infer\ or \infer\_with\_spikes\, receiving results that include logits, gate decisions (e.g., Allow, ReduceScope, FlushKv), and explainable witness information. The crate includes a README with installation and usage instructions, example code for basic and intervention scenarios, and WebAssembly tests to verify functionality.

crates/ruvector-mincut-gated-transformer-wasm · high confidence

Users can now access a complete ultrasound computed tomography (USCT) simulation and reconstruction toolkit. This includes a Rust core that runs natively or compiles to a 31 KB WebAssembly module with a stable C ABI for zero-copy data access in browsers. The workbench provides a React Three Fiber UI for live, interactive visualization of ground truth, reconstructions, and tissue segmentation. It also includes CLI tools for running demos, benchmarking reconstruction algorithms (SART, Landweber, Backprojection), training segmentation models, and serving the acoustic engine as a JSON-over-stdio process for integration with other systems.

(repo-wide) · high confidence

The \ruvector-core\ crate now includes a suite of advanced indexing and search algorithms in the \advanced\_features\ module. Users can now leverage LSM-tree style streaming index compaction for write-heavy workloads, SSD-backed DiskANN (Vamana) graphs for high-recall approximate nearest neighbor search, and hybrid search combining vector similarity with BM25 keyword matching. The update also adds support for Matryoshka representation learning (adaptive-dimension search), Maximal Marginal Relevance (MMR) for diversity-aware reranking, ColBERT-style multi-vector late-interaction retrieval, and Graph RAG pipelines for entity-relation based retrieval. Additional features include conformal prediction for uncertainty quantification and filtered search with automatic strategy selection based on metadata selectivity.

_crates/ruvector-core/src/advanced\features · high confidence

The \crates/ruvector-core/src/advanced\ module now exposes experimental features for next-generation vector search. Users can model complex n-ary relationships using \HypergraphIndex\ with temporal support, accelerate lookups via Recursive Model Index (RMI) learned structures, compress embeddings with similarity-preserving neural hashing (DeepHash), and assess embedding quality using Topological Data Analysis (TDA) metrics like mode collapse detection.

crates/ruvector-core/src/advanced · high confidence

The .claude directory now includes a comprehensive set of new agent configuration files and templates, introducing specialized agents for code quality analysis, system architecture design, base template generation, browser automation, and distributed consensus protocols (Byzantine, Raft, Gossip, CRDT). These additions provide structured definitions for agent capabilities, triggers, constraints, and integration hooks, enabling more sophisticated autonomous workflows and specialized task handling within the Claude Code environment.

.claude · high confidence

The crate now includes several new attention mechanism implementations: FlashAttention-3 for IO-aware tiled attention, Multi-Head Latent Attention (MLA) for KV-cache compression, Selective State Space Models (SSM/Mamba-style) for O(n) sequence modeling, speculative decoding for inference speedup, and a KV-cache compression module with quantization and eviction policies. Additionally, a new benchmark example compares Lorentz Cascade Attention against Poincaré Attention, and the attention module exports these new types alongside existing scaled dot-product and multi-head attention implementations.

crates/ruvector-attention/src · high confidence

The ruvector-postgres extension now includes a new \attention\ module providing SIMD-accelerated Scaled Dot-Product, Multi-Head, and Flash Attention v2 implementations, exposed via SQL functions like \ruvector\_attention\_score\, \ruvector\_multi\_head\_attention\, and \ruvector\_flash\_attention\. Additionally, a \dag\ module introduces neural Directed Acyclic Graph (DAG) learning for query optimization, offering SQL functions to analyze query plans (\dag\_analyze\_plan\), identify bottlenecks (\dag\_bottlenecks\), compute critical paths, and configure SONA (Scalable On-device Neural Adaptation) parameters for self-healing and adaptive learning.

crates/ruvector-postgres/src · high confidence

The repository now includes a comprehensive suite of automation scripts organized into subdirectories (benchmark, build, ci, deploy, publish, test, validate) along with a new README.md documenting their usage. These scripts enable users to run performance benchmarks (including LLM and NEON SIMD metrics), build NAPI-RS bindings for multiple platforms (Linux, macOS, Windows), manage deployment and publishing to crates.io and npm, and execute validation checks. Additionally, new analysis scripts (analyze-evolution.js, analyze-ham10000.js) provide medical dataset analysis capabilities, while the adr-index.mjs script enforces ADR numbering hygiene with security hardening against symlinks and hostile filenames.

scripts · high confidence

Added five new command-line benchmark tools to the \ruvector-bench\ crate: \agenticdb\_benchmark\ for testing AgenticDB-specific workloads (reflexion episodes, skill libraries, causal graphs); \ann\_benchmark\ for ANN-Benchmarks-compatible testing on standard datasets (SIFT1M, GIST1M, Deep1M) with configurable HNSW parameters; \comparison\_benchmark\ for cross-system performance comparisons between Ruvector (with and without quantization) and simulated Python/brute-force baselines; \latency\_benchmark\ for profiling p50/p95/p99 latencies under single-threaded and multi-threaded conditions with varying \ef\_search\ and quantization settings; and \memory\_benchmark\ for measuring memory consumption at different vector scales and quantization levels. Additionally, \profiling\_benchmark\ provides CPU flamegraph generation and mixed workload profiling when the \profiling\ feature is enabled, while \turbo4\_ablation\ measures Turbo4/ACRP ablation results including recall, latency, and index overhead against a brute-force ground truth.

crates/ruvector-bench/src/bin · high confidence

Added a new benchmarking crate (\ruvector-bet4-ivf-bench\) that provides a controlled environment to evaluate IVF pruning strategies and Product Quantization (PQ) against standard IVF incumbents. The harness introduces a \BnBIvf\ kernel implementing lower-bound-ordered branch-and-bound probing and a \PqIvf\ kernel using Asymmetric Distance Computation (ADC) with exact re-ranking. It includes example scripts (\ivf\_pruning\_sweep.rs\, \pq\_pruning\_sweep.rs\) that run matched-recall sweeps on real arxiv embeddings and PCA-reduced controls, alongside gate tests (\oracle\_gate.rs\, \pq\_gate.rs\) to certify the exactness and shared-index consistency of these new kernels.

crates/ruvector-bet4-ivf-bench · high confidence

The examples/benchmarks directory now includes a suite of new CLI tools and supporting modules for rigorous intelligence evaluation. The \agi\_proof\_harness\ runs a full acceptance test with a frozen holdout set, measuring cost, robustness, and policy compliance against a defined AGI contract, and includes an ablation comparison (Baseline vs. Compiler vs. Learned PolicyKernel) to isolate the value of learned policies. A new \acceptance\_rvf\ binary provides a publishable, deterministic acceptance test with a SHAKE-256 witness chain for reproducible verification. Intelligence is quantified via the \intelligence\_assessment\ runner and the \rvf\_intelligence\_bench\ (comparing baseline vs. RVF-learning across six verticals), while the \superintelligence\ binary tracks a 5-level recursive IQ pathway. Additional benchmarks cover temporal reasoning (\temporal\_benchmark\), swarm regret tracking (\swarm\_regret\), and quick temporal probes (\timepuzzle\_runner\), all backed by new modules for contract health, metrics, and ablation comparisons.

examples/benchmarks · high confidence

Added a benchmarking suite under \crates/ruvector-bench/scripts\ including a dataset downloader and a runner script that executes ANN, AgenticDB workload, latency, memory, and comparison benchmarks with support for quick/full modes and profiling. Added Node.js examples in \crates/ruvector-node/examples\ demonstrating basic CRUD operations (\simple.mjs\), advanced HNSW indexing with batch inserts, metadata filtering, and concurrent operations (\advanced.mjs\), and semantic search with document indexing, updates, and category-filtered queries (\semantic-search.mjs\).

crates/ruvector-bench/scripts, crates/ruvector-node/examples · high confidence

The crate now includes a comprehensive set of benchmarks and demonstration examples. This adds standalone Rust benchmarks for real-data kernel performance (kernel\_real.rs), routing algorithms (routing\_real.rs), and spatial awareness (rufield\_real.rs), alongside Python scripts to prepare and summarize datasets from SNAP and DIMACS sources. It also introduces JavaScript runtime benchmarks for both native and WASM implementations, and provides Rust examples demonstrating the LocalKCut algorithm, graph sparsification techniques, and subpolynomial dynamic min-cut updates.

crates/ruvector-mincut/src · high confidence

Added eleven new example applications in the \examples/\ directory that demonstrate graph-structural boundary detection using \ruvector\_coherence\ and \ruvector\_mincut\. These examples cover synthetic time-series analysis (boundary-discovery), pre-seizure EEG detection (brain-boundary-discovery), CMB cold spot analysis (cmb-boundary-discovery), earthquake precursor detection (earthquake-boundary-discovery), FRB population clustering (frb-boundary-discovery), health state monitoring from wearable data (health-boundary-discovery), infrastructure failure prediction (infrastructure-boundary-discovery), market regime shifts (market-boundary-discovery), music genre classification (music-boundary-discovery), and pandemic outbreak detection (pandemic-boundary-discovery). Each example generates domain-specific synthetic data, builds a similarity or coherence graph, and applies spectral bisection or min-cut algorithms to identify structural boundaries that amplitude-based methods miss.

(repo-wide) · high confidence

This change introduces the \ruvector-collections\ crate, providing multi-tenant collection management with isolated namespaces, schema validation, alias support, and thread-safe concurrent access via DashMap. It also adds a deterministic Miller-Rabin primality kernel with build-time generated prime tables for fast path lookups, used by downstream components like the shard router and HNSW index. Additionally, the \ruvector-snapshot\ crate is introduced, offering point-in-time backup and restore capabilities with compression and integrity verification.

crates/ruvector-collections · high confidence

Added three new example applications that apply Integrated Information Theory (IIT) Phi analysis to distinct domains: a Climate Teleconnection Explorer that compares neutral vs. El Niño climate mode integration; an Ecosystem Consciousness Explorer that measures food web integration and species resilience across tropical, agricultural, and coral reef models; and a Quantum Consciousness Explorer that computes Phi for quantum circuit states (Bell, GHZ, W, Product) to compare integrated information with entanglement hierarchies. Each example includes data generation, analysis pipelines using the ruvector\_consciousness crate (Phi, causal emergence, SVD emergence), text summaries, and SVG report generation.

examples/climate-consciousness, examples/ecosystem-consciousness, examples/quantum-consciousness · high confidence

The \ruvector-consciousness\ crate introduces a suite of Integrated Information Theory (IIT) computation engines, including exact, spectral, stochastic, and quantum-inspired partition search algorithms for calculating Φ (integrated information). It also provides causal emergence analysis and Cause-Effect Structure (CES) computation. A new \ruvector-consciousness-wasm\ crate exposes these capabilities to JavaScript via WASM bindings, allowing users to compute Φ, analyze causal emergence, and perform quantum-inspired partition collapse directly in the browser or Node.js environments.

crates/ruvector-consciousness · high confidence

Added a new example application in \examples/train-discoveries\ that implements a three-stage ETL pipeline for discovering cross-domain correlations. The tool extracts discovery data from JSON files, transforms them into 64-dimensional vectors, and uses the \ruvector-solver\ ForwardPush algorithm to perform sublinear PageRank calculations. This enables the identification of hidden connections between different domains (such as space, earth, life-science, etc.) based on text similarity, outputting ranked correlations and a domain affinity matrix.

examples/train-discoveries · high confidence

The agentic-integration package now includes the AgentCoordinator and CoordinationProtocol classes, which provide distributed task distribution, load balancing (round-robin, least-connections, weighted, adaptive), health monitoring, and inter-agent consensus. To support these features, a new claude-flow-runner module was added that executes hooks via \execFile\ with argument arrays instead of shell invocation, preventing command injection vulnerabilities from remote agent identifiers. A test suite was also added to verify that shell execution is avoided in favor of the safer \execFile\ approach.

npm/packages/agentic-integration · high confidence

The \ruvector-domain-expansion\ crate introduces a new engine for cross-domain transfer learning, enabling the system to improve problem-solving capabilities across different domains (Rust program synthesis, structured planning, and tool orchestration) by sharing learned priors. This includes a meta-learning layer with five improvements: regret tracking, decaying priors, plateau detection, Pareto front optimization, and curiosity-driven exploration. The engine also features population-based policy search to tune configuration knobs and an acceleration scoreboard to measure convergence speed across domains. Additionally, it provides integration with the RuVector Format (RVF) for serializing transfer priors and creating witness chains, gated behind the \rvf\ feature flag.

crates/ruvector-domain-expansion/src · high confidence

The \ruvector-edge-analytics\ crate introduces a new capability to compute minimum cuts on tenant graphs. It provides a persisted, chunked edge-list format (RVMC v1) with SHA-256 integrity checks, and enforces strict size limits (50k vertices/200k edges for inline, 250k for async jobs) and computational budgets. Queries are routed to either an inline path or an asynchronous job queue based on cost estimates, ensuring that over-budget requests are rejected with HTTP 413 rather than causing service degradation. The service supports both exact and approximate (answered exactly) min-cut modes, with all errors mapped to stable HTTP codes and static detail strings to prevent information leakage.

(repo-wide) · high confidence

Added new example modules for integrating RuVector with external data sources: \examples/data/climate\ provides clients for NOAA and NASA Earthdata APIs, enabling sensor network graph construction, regime shift detection via min-cut algorithms, and time-series vectorization; \examples/data/edgar\ provides a client for the SEC EDGAR API, supporting XBRL financial statement parsing, filing analysis (10-K, 10-Q, etc.), and peer network coherence monitoring to detect fundamental-narrative divergence.

examples/data/climate, examples/data/edgar, examples/data/openalex · high confidence

The \ruvector-dag\ crate now includes a comprehensive suite of examples and benchmarks demonstrating its Neural Self-Learning capabilities. Users can explore core features like basic DAG construction, topological sorting, and various attention mechanisms (Topological, Causal Cone, Critical Path, MinCut) through dedicated demo files. The suite also showcases advanced workflows, including SONA-based learning pipelines, self-healing systems with anomaly detection, and a new synthetic haptic system example that implements a complete nervous system loop with event sensing, reflex arcs, and associative memory. Additionally, new benchmarks are provided to measure performance for DAG construction, attention scoring, MicroLoRA adaptation, and trajectory buffering.

crates/ruvector-dag/examples · high confidence

Added two new example applications: a temporal attractor network simulation in \examples/mincut/temporal\_attractors\ that demonstrates how minimum cut analysis detects convergence to stable network states, and a subpolynomial-time dynamic minimum cut demo in \examples/subpolynomial-time\ that showcases basic usage, dynamic edge updates, exact vs. approximate modes, real-time monitoring, and a vector-graph fusion layer with brittleness detection.

_examples/mincut/temporal\attractors, examples/subpolynomial-time · high confidence

The new \exo-exotic\ crate introduces a laboratory for speculative and frontier cognitive phenomena, providing building blocks for research into non-standard AI architectures. It includes implementations of strange loops (self-referential feedback), artificial dreams (offline generative replay for memory consolidation), free energy minimization (active inference), morphogenesis (developmental self-organization), collective consciousness (distributed awareness across substrates), temporal qualia, multiple selves, cognitive thermodynamics, emergence detection, and cognitive black holes (attractor dynamics). The crate also integrates with \ruvector-domain-expansion\ for domain transfer experiments and includes specific ADR-029 experiments for neuromorphic spiking, quantum superposition, sparse homology, and time-crystal cognition.

examples/exo-ai-2025/crates/exo-exotic · high confidence

The benchmarks directory now includes a comprehensive graph database benchmarking suite. This adds TypeScript-based scenario definitions (social network, knowledge graph, temporal graph, recommendation engine, fraud detection) and a data generator that uses the @ruvector/agentic-synth library to create synthetic datasets. A new comparison runner executes these scenarios against both RuVector (via Rust Criterion benchmarks) and Neo4j, calculating speedup metrics and generating HTML/Markdown reports. The suite also introduces a containerized benchmarking environment via a new Dockerfile and setup script, supporting k6 load testing and Node.js execution for general system benchmarks alongside the new graph-specific tests.

benchmarks · high confidence

The \crates/ruvector-dag/src/attention\ module now provides a suite of topology-aware attention mechanisms to improve DAG-based query optimization. This includes base mechanisms like Topological, Causal Cone, Critical Path, and MinCut Gated attention, as well as advanced options such as Hierarchical Lorentz (hyperbolic geometry), Parallel Branch coordination, and Temporal BTSP (biologically-inspired plasticity). An Attention Selector uses a UCB1 bandit algorithm to dynamically choose the best mechanism, while an LRU-based Attention Cache stores computed scores to avoid redundant work. These components are exposed via a unified \DagAttentionMechanism\ trait and integrated into the crate's public API.

crates/ruvector-dag/src · high confidence

This change introduces two new crates. The \hailort-sys\ crate provides raw Rust FFI bindings to Hailo's HailoRT C library, generated via bindgen at build time; it supports a \hailo\ feature flag to enable full bindings on devices with the HailoRT library installed, while providing stubs for development environments without it. The \ruvector-mmwave\ crate implements a zero-allocation, no\_std-compatible streaming parser for the Seeed MR60BHA2 60 GHz radar's UART protocol, exposing events for breathing rate, heart rate, distance, and presence detection, along with robust state-machine handling for checksum errors and resynchronization.

crates/hailort-sys, crates/ruvector-mmwave · high confidence

A new \ruvector-hybrid\ crate introduces hybrid sparse-dense search capabilities, combining Robertson BM25 lexical retrieval with flat exhaustive cosine ANN. It provides three fusion strategies for combining these signals: Score Fusion (min-max normalized weighted blend), Reciprocal Rank Fusion (RRF), and Relative Score Fusion (RSF). The crate also includes a benchmark binary to evaluate recall and latency across these strategies on synthetic corpora.

crates/ruvector-hybrid · high confidence

The \ruvector-agent-memory\ crate introduces three major capabilities. First, it adds CAMA-pattern correlation-aware arbitration (\arbitration.rs\) which clusters retrieved memories into evidence lineages based on causal provenance to prevent over-weighting repeated claims, and enforces strict-majority localization and acyclicity guards to harden the system against partial emissions and rollback attacks. Second, it implements a stage-level diagnostic gate (\diagnostic.rs\) based on the D²ACCI framework, requiring that memory strategy promotions be attributable to exactly one pipeline stage (ingestion, retrieval, filtering, or generation) to ensure fault localization. Third, it introduces Mincut-gated forgetting (\graph\_forget.rs\) as a compaction policy that uses graph partitioning to identify and protect structurally load-bearing 'bridge' memories during eviction, alongside benchmarks and probes to measure the performance and determinism of this new graph-based analysis.

crates/ruvector-agent-memory · high confidence

The nervous system crate now includes new modules for neural competition and dendritic processing. The \compete\ module adds \WTALayer\ (single-winner competition with lateral inhibition and refractory periods), \KWTALayer\ (k-winners selection for sparse coding), and \LateralInhibition\ (distance-based Mexican hat connectivity). The \dendrite\ module introduces \Compartment\ (membrane and calcium dynamics), \Dendrite\ (NMDA-like coincidence detection with plateau potentials), \PlateauPotential\ (behavioral-timescale credit assignment signals), and \DendriticTree\ (multi-branch integration). These components enable sparse activation patterns, temporal pattern matching, and biologically-inspired plasticity mechanisms within the RuVector Nervous System.

crates/ruvector-nervous-system/src · high confidence

Added two new example projects under the research directory: a neuromorphic spiking neural network library featuring bit-parallel SIMD spike propagation and Integrated Information Theory (IIT) calculations, and a conscious language interface that bridges semantic embeddings with spiking dynamics using a consciousness-aware router and advanced learning modules.

examples/exo-ai-2025/research/01-neuromorphic-spiking, examples/exo-ai-2025/research/11-conscious-language-interface · high confidence

This change introduces the \ruvector-nervous-system-wasm\ crate, exposing a suite of bio-inspired neural components to JavaScript/TypeScript via WebAssembly. Users can now perform one-shot learning with BTSP (Behavioral Timescale Synaptic Plasticity), execute ultra-fast hyperdimensional computing (HDC) operations like binding and similarity on 10,000-bit vectors, and make instant decisions using Winner-Take-All (WTA) and K-WTA layers. The package also includes a Global Workspace module for attention-based memory management, all accessible through a standard \npm install\ workflow with full TypeScript definitions.

crates/ruvector-nervous-system-wasm · high confidence

The new \ruvector-profiler\ crate provides the observability layer for the ruvector attention benchmarking pipeline, instrumenting runs with memory, power, and latency profiling hooks that export results to CSV files. It introduces \MemoryTracker\ for RSS snapshots, \PowerTracker\ with trapezoidal energy integration, and \LatencyStats\ for percentile calculations (p50/p95/p99). A \BenchConfig\ struct with SHA-256 fingerprinting ensures reproducibility across machines, while dedicated CSV emitters (\write\_results\_csv\, \write\_latency\_csv\, \write\_memory\_csv\) structure the output for downstream analysis.

crates/ruvector-profiler · high confidence

The new \rvm-checkpoint\ crate enables RVM to export witness log heads as C2SP tlog-checkpoints, making them compatible with existing transparency log tooling (such as Sigsum/Rekor v2 and Omniwitness cosigners). It implements strict, canonical RFC 4648 base64 encoding to prevent signature malleability, and supports C2SP signed-notes with Ed25519 signatures for checkpoint verification. The crate also introduces an extension line mechanism (\rvm.prev\_seal\) to bind chained seals without breaking the core checkpoint format, allowing verifiers to ignore unknown lines while maintaining chain integrity.

crates/rvm/crates/rvm-security · high confidence

The server crate now ships four new executable binaries. The \ruvllm-embedder\ binary exposes a standalone HTTP API on port 9877 for generating text embeddings. The \mcp-brain-server-local\ binary provides a local private brain backend with SQLite storage, AIDefence threat scanning, and a DiskANN-inspired vector index. The \ruvbrain\_sse\ binary acts as a thin SSE proxy that decouples MCP transport by forwarding JSON-RPC requests to the brain API and streaming responses back to clients. Finally, the \ruvbrain\_worker\ binary runs scheduled maintenance actions (training, drift checks, graph rebuilding, etc.) as a one-shot CLI.

crates/mcp-brain-server/src/bin · high confidence

The new \ruvector-memory-admission\ crate introduces write-time cluster admission for streaming agent memory, complementing the existing read-time namespace routing. It provides three admission policies: a \NearestCentroidThreshold\ baseline, a \MincutGatedAdmission\ that uses a global minimum cut (Stoer-Wagner algorithm) with a fixed coherence threshold, and an \AdaptiveMincutAdmission\ that self-calibrates the threshold online using Welford's algorithm. The crate includes a synthetic streaming dataset generator for evaluation and a benchmark binary to compare these policies on purity, recall, and latency.

crates/ruvector-memory-admission · high confidence

The \crates/ruvector-nervous-system/examples\ directory now includes a comprehensive set of runnable examples demonstrating the library's bio-inspired architecture across four maturity tiers. Tier 1 examples (\t1\_anomaly\_detection\, \t1\_edge\_autonomy\, \t1\_medical\_wearable\) showcase immediate practical applications like infrastructure monitoring, edge control, and wearable health tracking using reflex arcs and adaptive thresholds. Tier 2 examples (\t2\_self\_optimizing\, \t2\_swarm\_intelligence\, \t2\_adaptive\_simulation\) illustrate near-term transformative uses such as self-stabilizing software, decentralized swarm coordination, and digital twins with adaptive fidelity. Tier 3 examples (\t3\_self\_awareness\, \t3\_synthetic\_nervous\, \t3\_bio\_machine\) explore exotic research directions including structural self-sensing, synthetic environments, and biological-machine interfaces. Tier 4 examples (\t4\_neuromorphic\_rag\, \t4\_agentic\_self\_model\, \t4\_collective\_dreaming\, \t4\_compositional\_hdc\) push neuromorphic boundaries with coherence-gated retrieval and collective memory. A new \README.md\ provides a quick start guide and architecture overview, while \hopfield\_demo.rs\ demonstrates associative memory capabilities.

crates/ruvector-nervous-system/examples · high confidence

The \harnesses/timesfm-harness\ directory now contains a complete engineering-pod harness for the TimesFM 1.0 200M time-series forecasting crate. It provides a CLI (\bin/cli.js\) with \init\ and \doctor\ commands to verify the \@metaharness/kernel\ and \@metaharness/host-claude-code\ adapter, and defines four agent roles (architect, implementer, reviewer, test-writer) via system prompts in \src/agents/\. The harness includes a smoke test (\\_\tests\\_/smoke.test.ts\) to validate the install, a Darwin-Mode self-improvement loop (\scripts/evolve-openrouter.{sh,mjs}\) that uses the OpenRouter LLM mutator with API keys sourced from GCP Secret Manager, and a Vitest configuration (\vitest.config.ts\) that strips shebangs to allow importing the CLI entry point in tests.

harnesses, harnesses/timesfm-harness · high confidence

A new merged training corpus file, \brain\_corpus.jsonl\, has been added to the \data/training/\ directory. This file contains 230 records (approximately 530K tokens) sourced from various public web pages, including NCBI, CDC, and Elsevier, licensed under Apache 2.0. This data is now available for model training or fine-tuning pipelines that consume this directory.

data · high confidence

The \ruvector-attention-unified-wasm\ crate now exposes a comprehensive WebAssembly interface for 18+ attention mechanisms, organized into four categories: Neural (Scaled Dot-Product, Multi-Head, Hyperbolic, Linear, Flash, Local-Global, MoE), DAG (Topological, Causal Cone, Critical Path, MinCut-Gated, Hierarchical Lorentz, Parallel Branch, Temporal BTSP), Graph (GAT, GCN, GraphSAGE), and State Space Models (Mamba SSM). This release introduces new WASM-bindable types such as \WasmQueryDag\ for building and serializing directed acyclic graphs, \WasmGNNLayer\ for graph neural network forward passes, \WasmTensorCompress\ for adaptive embedding compression, and \MambaSSMAttention\ for linear-time sequence modeling. A \UnifiedAttention\ selector allows runtime routing to any of the supported mechanisms, and the library provides \availableMechanisms\ and \getStats\ utilities for introspection.

crates/ruvector-attention-unified-wasm/src · high confidence

The index module now includes three distinct vector indexing strategies. A new FlatIndex provides a parallel brute-force search baseline for small datasets. The HnswIndex implements a Hierarchical Navigable Small World graph with SIMD-accelerated distance calculations and serialization support. Additionally, a Turbo4HnswIndex introduces 4-bit quantized vector storage, significantly reducing memory usage while supporting direct scoring and adaptive search policies.

crates/ruvector-core/src/index · high confidence

This change introduces the \ruvector-attention-node\ crate, providing comprehensive Node.js bindings via NAPI-RS. Users can now access attention mechanisms (scaled dot-product, multi-head, hyperbolic, flash, linear, local-global, and Mixture of Experts) directly from JavaScript. The bindings also expose training utilities, including loss functions (InfoNCE, LocalContrastive, SpectralRegularization), optimizers (SGD, Adam, AdamW), and learning rate schedulers. Additionally, graph-specific features such as edge-featured attention (GATv2-style), Graph RoPE, and dual-space attention are available, along with async and batch processing capabilities for improved performance.

crates/ruvector-attention-node/src · high confidence

Prime-Radiant is a new Rust crate that provides a mathematical gate for autonomous systems to prove internal consistency before allowing action. It models facts, beliefs, and memories as a graph where edges represent relationships, using Sheaf Laplacian mathematics to calculate 'energy' (incoherence) and route decisions through compute lanes (Reflex, Retrieval, Heavy, Human) based on contradiction levels. The crate includes a comprehensive benchmark suite (covering energy computation, restriction maps, incremental updates, hyperbolic geometry, and SIMD/GPU optimizations) to validate performance targets, alongside a detailed README explaining the architecture, API, and integration with RuvLLM.

crates/prime-radiant · high confidence

Added the \ruvector-adaptive-ann\ crate, a research implementation that allows specifying a recall target (e.g., 0.95) instead of manually tuning the beam width (\ef\) parameter. The crate provides three search strategies: a fixed baseline, a binary-search variant that uses ground truth to find the minimum \ef\ per query, and a table-calibrated variant that uses an offline calibration table to select \ef\ in O(1) time. It includes a flat navigable small-world graph implementation, a calibration engine that builds monotone \ef\-to-recall tables, and integration tests verifying that the calibrated strategies meet their recall targets.

crates/ruvector-adaptive-ann · high confidence

The new \@ruvector/ruvbot\ package provides a self-learning AI assistant with a comprehensive CLI (commands for init, start, doctor, config, memory, security, plugins, and agent management) and a multi-stage Dockerfile optimized for Google Cloud Run. It includes GCP deployment infrastructure via Terraform and Cloud Build, a PostgreSQL schema for multi-tenancy with Row-Level Security, and an environment configuration file supporting Anthropic, OpenRouter, OpenAI, and Google AI providers. The package also features a plugin system, vector memory with HNSW indexing, and security protections including AIDefence and PII masking.

npm/packages/ruvbot · high confidence

The RuvLLM example now includes a multi-head graph attention engine (src/attention.rs) that ranks memory nodes using both node embeddings and edge features for RAG context ranking. Additionally, several new binaries are provided to demonstrate and test the system: an interactive demo (demo.rs), an HTTP server with query/feedback endpoints (server.rs), a SIMD-optimized CPU inference demo (simd\_demo.rs), a pretraining pipeline script (pretrain.rs), a HuggingFace export tool for LoRA weights and patterns (export.rs), and benchmarking utilities (bench.rs, benchmark\_suite.rs). A compression service (compression.rs) for creating concept hierarchies and a configuration module (config.rs) are also introduced.

examples/ruvLLM · high confidence

The new \crates/sona\ crate provides the SONA (Self-Optimizing Neural Architecture) engine, enabling real-time, adaptive learning for AI systems without retraining. It supports Rust, Node.js (via N-API), and browsers (via WASM). Key capabilities include MicroLoRA and BaseLoRA for fast and deep pattern learning, EWC++ to prevent catastrophic forgetting, and a ReasoningBank for storing successful interaction patterns. The crate includes a browser demo, benchmarks, and examples demonstrating online auto-tuning and evolutionary configuration.

crates/sona · high confidence

The new \ruvector-staged-workspace\ crate enforces ADR-318 by binding every artifact to a SHA-256 content hash and a monotonic revision ID. Downstream references (parser results, tool calls, diffs, approvals, and outputs) are now tied to the exact version they were derived from; if the artifact changes, those views become structurally stale and are rejected immediately rather than processed with outdated data. The workspace also implements an ADR-312 anchoring seam that aborts commits if the anchor rejects a transition record, ensuring a "no anchor, no transition" fail-closed guarantee. Additionally, a subprocess adapter binary (\staged-workspace-adapter\) provides a frozen JSON-over-stdin/stdout protocol for cross-language consumers, using specific exit codes to distinguish successful operations, integrity rejections, and adapter malfunctions.

crates/ruvector-staged-workspace · high confidence

Users can now condense large feature graphs into smaller, deployable artifacts while preserving the original cut structure and node provenance. The core \ruvector-graph-condense\ crate provides a training-free \WeakBoundary\ method (default) that collapses nodes into super-nodes based on community structure, ensuring boundary edges are retained as weighted super-edges. It also introduces a \DiffMinCut\ method that uses a differentiable min-cut loss with Adam optimization and warm-start initialization to refine cluster assignments, making it viable for large numbers of clusters. A new \ruvector-graph-condense-wasm\ crate exposes these capabilities to JavaScript and edge runtimes via WASM bindings, enabling client-side graph condensation without native threading. The release includes benchmarks and examples demonstrating accuracy retention and performance on simulated WorldGraph data.

crates/ruvector-graph-condense, crates/ruvector-graph-condense-wasm, crates/ruvector-perception · high confidence

The \ruvector-tiny-dancer-core\ crate now includes a comprehensive set of new capabilities and supporting artifacts. Users can now run benchmarks for feature engineering, routing latency, model inference, and Value-of-Information (VoI) decisions using Criterion. An optional Admin API (enabled via the \admin-api\ feature) provides a production-ready REST interface for health checks, Prometheus metrics, hot model reloading, and circuit breaker management. The crate also introduces full observability with Prometheus metrics and OpenTelemetry distributed tracing, as well as a complete FastGRNN training pipeline featuring an Adam optimizer, knowledge distillation, and early stopping. These changes are accompanied by extensive documentation and example code.

crates/ruvector-tiny-dancer-core · high confidence

This change introduces a new Rust crate, \ruvector-domain-expansion-wasm\, which exposes the Domain Expansion Engine to JavaScript via WASM bindings. It provides a \WasmDomainExpansionEngine\ class that allows users to manage domains, generate and evaluate tasks, select arms using Meta Thompson Sampling, and initiate cross-domain transfer learning. The bindings also expose population search capabilities (evolving policy kernels) and an acceleration scoreboard. When the \rvf\ feature is enabled, the engine supports RVF segment serialization for packaging transfer priors and policy kernels.

crates/ruvector-domain-expansion-wasm · high confidence

The \ruvector-decompiler-wasm\ crate now exposes the full Louvain graph-partitioning decompiler pipeline (parse, graph, partition, infer, witness) to Node.js and browser environments via WebAssembly. Users can invoke the \decompile\ function with JavaScript source code and a JSON configuration to receive a JSON result containing the detected modules, witness data, and inferred names, or handle errors via a structured JSON response.

crates/ruvector-decompiler-wasm · high confidence

The \@ruvector/mincut-wasm\ package now exposes batch APIs for the \WasmMinCut\ graph, including \batchInsert\, \batchDelete\, and a high-performance \batchInsertTyped\ for bulk edge updates, alongside a new \WasmLocalKCut\ class for local k-cut queries. Additionally, a dedicated \RoutingWorker\ class is available in the \routing\ subpath, allowing JavaScript applications to offload road and RuField-aware routing computations to a dedicated WASM worker thread with built-in support for timeouts, abort signals, and queue bounds.

npm/packages/mincut-wasm · high confidence

The \ruvector-wasm\ crate now ships with a corrected JavaScript adapter (\RuvectorWasmAdapter\) that fixes the search result contract: raw distances are converted to similarities (higher is better) and metadata is preserved via a sidecar, resolving previous gaps in flat-index scoring and metadata round-tripping. The underlying WASM build now uses a portable in-memory HNSW graph by default (with \useHnsw: false\ selecting exact flat search), and includes new kernels for RMSNorm, RoPE, and SwiGLU to support LLM-style workloads in the browser. Additionally, an IndexedDB persistence layer and LRU cache are provided for offline-first browser storage, while a trusted kernel allowlist and epoch-based interruption mechanism add security and execution budget controls for WASM modules.

crates/ruvector-wasm · high confidence

The mcp-brain-server now serves the pi.ruv.io website, including a landing page (index.html) with a dark theme and neural network visualization, an origin story page (origin.html) with an interactive narrative, and supporting assets like an Open Graph image (og-image.svg), a brain manifest (brain-manifest.json) detailing API capabilities and endpoints, an agent integration guide (agent-guide.md), and SEO files (robots.txt, sitemap.xml).

crates/mcp-brain-server/static · high confidence

The ruvector-postgres extension now includes comprehensive SQL installation scripts for versions 0.1.0, 0.3.0, and 2.0.0, along with an upgrade path from 0.3.0 to 2.0.0. These scripts define the native \ruvector\ type, SIMD-optimized distance functions (L2, cosine, inner product, Manhattan), and arithmetic operators. Version 2.0.0 introduces advanced capabilities including Solver functions (PageRank, sparse matrix solving), Math/Spectral functions (Wasserstein, Sinkhorn, spectral clustering), Topological Data Analysis (persistent homology, Betti numbers), and Extended Attention mechanisms (linear, sliding window, cross, sparse, MoE). The extension also registers custom index access methods \ruhnsw\ and \ruivfflat\ for approximate nearest neighbor search, supporting operator classes for various distance metrics. Additionally, example SQL files demonstrate graph operations with Cypher support, embedding generation workflows, and AI agent routing strategies.

crates/ruvector-postgres/sql · high confidence

The rvAgent crate now includes a formal configuration framework under \.ruv/\ that defines four specialized agent roles—Coder, Queen (swarm coordinator), Tester, and Security—along with the infrastructure to manage them. A new \config.json\ and \manifest.rvf.json\ specify capabilities, model routing tiers (Haiku, Sonnet, Opus), and default security settings such as virtual mode and environment sanitization. This is supported by shell helpers (\load-manifest.sh\, \rvagent-hooks.sh\) that initialize cognitive containers, witness chains, and swarm topologies, as well as demo scripts that demonstrate these multi-agent workflows in action.

crates/rvAgent · high confidence

A change to existing behaviour in crates/ruvector-graph-transformer-node/npm — 7 commits, 14 files.

crates/ruvector-attention-node/npm, crates/ruvector-gnn-node/npm, crates/ruvector-graph-transformer-node/npm · medium confidence · unverified

The patches directory now includes a modified version of the hnsw\_rs crate to resolve build failures on WebAssembly targets. The upstream crate relied on rand 0.9 and Rust edition 2024, which are incompatible with WASM and stable Rust toolchains; this patch reverts the dependency to rand 0.8 and targets Rust edition 2021. This local override is applied via the workspace Cargo.toml to ensure that ruvector-core and ruvector-graph compile successfully across all supported platforms.

patches · high confidence

A new pre-commit hook has been added to the repository to automatically synchronize the package-lock.json file before each commit. This ensures that lockfile consistency is maintained without manual intervention, reducing the risk of dependency mismatches during development.

.githooks · high confidence

The chat-ui project has been reorganized into a self-contained SvelteKit application that communicates exclusively with OpenAI-compatible APIs via the OPENAI\_BASE\_URL environment variable, removing legacy provider-specific integrations and GGUF discovery. The new architecture includes a Dockerfile supporting optional embedded MongoDB (MongoDB 7), GitHub Actions workflows for CI/CD, linting, testing, and documentation, and a comprehensive CLAUDE.md guide for developers. Users can now deploy the application using standard SvelteKit commands or Docker images, with configuration managed through environment variables for model routing, MCP tools, and authentication.

ui · high confidence

The external dependencies ruqu and rvdna have been moved from inline content to standalone git submodules. This change updates the project structure to manage these libraries as separate repositories, which may affect how they are cloned, updated, or maintained in the future.

external · high confidence

This update adds Dockerfiles for running benchmarks and tests in isolated environments, a CLI script to fix ESM import resolution by appending .js extensions to relative specifiers, and several model-comparison scripts to evaluate routing accuracy. It also includes documentation for the RuvLTRA models and a publishing script for HuggingFace, clarifying that the npm package's generate() and query() methods do not produce model output and require an external LLM server for inference.

npm/packages/ruvllm · high confidence

The typesafe-core engine now supports opt-in cross-fitted calibration for small label banks, an opt-in 'sigmoid' abstain mode for thresholdable out-of-scope scoring, and opt-in choice instructions so choice questions can read their own instructions. Additionally, a catch-all option is available for off-topic inputs, and the training process now correctly reports the head that the decision logic will actually use.

crates/ruvector-typesafe-core · high confidence

The witness subsystem now uses a new v2 record format (96 bytes) that replaces the legacy v1 format (64 bytes) for all new writes. The v2 format uses keyed-BLAKE3 chain MACs for tamper-evident auditing and Merkle segment sealing for efficient integrity verification. The v1 format is now read-only and retained only for verifying existing logs and supporting incremental migration. The new system includes features like chained seals for verifying append-only ordering, key ratcheting for forward security, and strict coverage policies to prevent silent data loss.

crates/rvm/crates/rvm-witness · high confidence

The RVM crate now includes a complete build and CI setup for bare-metal AArch64 targets, featuring a Cargo configuration for the \rvm.ld\ linker script, a Makefile for QEMU-based testing, and a GitHub Actions workflow that validates the \rvm-hal\ crate against the \aarch64-unknown-none\ target. Additionally, the \rvm-proof\ subsystem introduces security hardening through constant-time comparison utilities (using the \subtle\ crate) to prevent timing side-channels, and expands the P2 policy evaluator's nonce ring buffer from 64 to 4096 entries to mitigate replay attacks.

crates/rvm · high confidence

The Ruvocal interface has been rebuilt on SvelteKit, introducing a structured API client that targets the /api/v2 endpoint for conversations, user settings, and model management. The application now features a dark-mode-first design with a custom canvas-based background animation, robust mobile navigation with swipe gestures, and improved chat interactions including auto-scrolling, HTML/SVG code previewing, and background generation polling.

ui/ruvocal · high confidence

The \ruvector-graph-node\ crate now supports executing Cypher \MATCH\ patterns (including label-scoped queries, property filters, and relationship traversals) instead of silently returning empty results for unsupported shapes. To support this, the module introduces a Cypher executor and expression evaluator, and defers the replay of persistent storage into in-memory indexes until the first query is executed, preventing the previous synchronous blocking during database construction. The crate also exposes NAPI bindings for transaction management (begin, commit, rollback) and streaming result iterators, while correcting the batch-insert logic to ensure nodes are consistently registered in both the hypergraph and property-graph label indexes.

crates/ruvector-graph-node/src · high confidence

The knowledge graph rebuild process has been refactored to run the expensive O(n²) edge computation off the main lock, preventing the 504 timeouts that occurred when rebuilds blocked concurrent search and status requests. The new three-phase approach (begin, build, install) ensures that readers continue to use the previous graph version while the new one is computed, and writers can continue adding or removing memories which are logged and replayed during the brief final swap. This change eliminates the service interruptions caused by long-running rebuilds on large graphs.

crates/mcp-brain-server/src/graph · high confidence

The \ruvector-embed-core\ crate now enforces a maximum batch size of 32 texts per inference call. Previously, passing large batches (e.g., thousands of texts) to the ONNX Runtime backend could cause it to allocate excessive memory (up to 10 GB) for attention tensors. The new \embed\_in\_chunks\ utility automatically splits large input lists into chunks of at most 32, ensuring peak memory usage remains bounded while preserving result order and correctness. This change applies to both the native \OrtEmbedder\ and the WASM \TractEmbedder\.

crates/ruvector-embed-core · high confidence

Added Node.js binding tests for Ruvector GNN; Added Node.js bindings tests for VectorDB; Added allocation regression test for DiskANN search; Added benchmark suite for Cypher parser and graph operations; Added benchmark suite for parser and full pipeline performance; Added benchmark suites for attention, learning, neuromorphic, and Plaid ZK components; Added benchmark suites for ruvector-attention variants; Added comprehensive WASM binding tests; Added comprehensive benchmark suite for ruvector-postgres; Added comprehensive benchmarks for the mincut-gated transformer; Added comprehensive performance benchmarks for ruvector-core; Added comprehensive test suite for ruvector-postgres extension; Added comprehensive test suite for the mincut-gated transformer; Added comprehensive test suite for the nervous system crate; Added comprehensive test suites for advanced indexing, agentic version control, and Dockerized integration; Added example tests for the Cypher parser; Added fuzz testing for distance metrics and Cypher parsing; Added ground-truth, integration, and model decompiler tests for the ruvector-decompiler; Added integration tests for the ruvector-dag crate; Added performance benchmarks for WASM cognitive stack components; Added performance benchmarks for spectral coherence scoring; Added test harness for authority adapter structural admission; Added test suite for ruvector-graph; Added tests for GNN loss function implementations; Comprehensive benchmark suite for dynamic minimum cut algorithms; Comprehensive test suite for Ruvector Core.

Adds a new agentic-robotics workspace containing core, real-time, embedded, and Node.js crates, providing a high-performance robotics framework with ROS2 compatibility and N-API bindings for Node.js. Additionally, introduces the hailort-sys crate, which provides raw FFI bindings for Hailo's HailoRT C library to enable NPU acceleration, and registers a new @claude/ruvector-intelligence package for self-learning intelligence layers in Claude Code hooks.

(dependencies) · high confidence

A README file has been added to the ruvector-graph-node crate, detailing the installation, API, and usage of the Node.js bindings for the Ruvector graph database. The documentation highlights features such as native performance via NAPI-RS, Cypher query support, and vector search capabilities.

crates/ruvector-graph-node · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 58 → 55 (-3.1)
• Rubric changed (rubric-2026.09.11 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 70 → 69 (-0.8)
• Architecture 63 → 67 (+4.6)
• Maturity 93 → 93 (+0.0)
• Readiness 60 → 46 (-14.5)
• Security 59 → 67 (+8.8)
• Domain Modelling 92 → 93 (+0.8)
• Event Sourcing 100 → 100 (+0.0)
• Accessibility 52 → 52 (+0.0)
• Performance 94 (new)

• Dependency hygiene PARTLY measured — npm pinning read, dependency currency not (no pnpm-resolved versions to grade)
• Documentation: no installation or build instructions (examples/rvf/README.md)
• Documentation: no installation or build instructions (examples/scipix/README.md)
• Duplicated block (10 lines × 2) (crates/ruvector-mincut-node/src/lib.rs)
• Duplicated block (12 lines × 3) (crates/ruvllm/src/kernels/activations.rs)
• Duplicated block (15 lines × 2) (crates/ruvector-mincut/src/algorithm/mod.rs)
• Duplicated block (18 lines × 2) (crates/mcp-brain-server/src/gist.rs)
• Duplicated block (3–14 lines × 3) (crates/ruvector-mincut/src/fragment/mod.rs)
• Duplicated block (5 lines × 2) (crates/ruvix/crates/region/src/immutable.rs)
• Duplicated block (5 lines × 2) (crates/ruvllm-cli/src/commands/quantize.rs)
• Duplicated block (5 lines × 2) (crates/rvf/rvf-manifest/src/directory.rs)
• Duplicated block (6 lines × 2) (crates/ruvector-dag/src/dag/query_dag.rs)
• Duplicated block (6 lines × 2) (crates/ruvector-robotics/src/bridge/indexing.rs)
• Duplicated block (7 lines × 2) (crates/mcp-brain-server/src/routes.rs)
• Duplicated block (7 lines × 6) (crates/ruvector-mincut/src/algorithm/approximate.rs)
• Duplicated block (8 lines × 3) (crates/mcp-brain-server/src/gist.rs)
• Duplicated block (9 lines × 2) (crates/ruvector-mincut/src/algorithm/mod.rs)
• DynamicMinCut::apply_batch (cognitive 22) (crates/ruvector-mincut/src/canonical/dynamic/mod.rs)
• DynamicMinCut::compute_tree_edge_cut (cognitive 29) (crates/ruvector-mincut/src/algorithm/mod.rs)
• DynamicMinCut::find_replacement_edge (cognitive 25) (crates/ruvector-mincut/src/algorithm/mod.rs)
• …and 75 more

• ContinualUpdate::grow (cognitive 17) (crates/ruvector-kge/src/optimize/continual.rs)
• Documentation: no project overview (crates/agentic-robotics-embedded/README.md)
• Duplicate raw ingestion APIs at different levels: Both the module-level functions (cognitum_gate_kernel.ingest_delta) and the TileState struct methods (TileState.ingest_delta_raw) expose nearly identical signatures for raw byte ingestion. The module-level functions seem to operate on a global or default state, while the struct methods operate on an instance. This is acceptable if the intent is distinct (global vs instance), but the naming ingest_delta vs ingest_delta_raw is confusing because the struct method also takes raw bytes.
• Duplicate serialization interfaces: There are both free functions (e.g., serialize_json) and a generic Serializer struct with a serialize method. The free functions appear to be convenience wrappers or legacy APIs, while the Serializer struct is the modern, format-agnostic approach. This creates confusion on which API to use.
• Duplicated block (10 lines × 2) (crates/ruvector-kge-ffi/src/optimize.rs)
• Duplicated block (10 lines × 2) (crates/ruvector-typesafe-core/src/bank.rs)
• Duplicated block (10 lines × 2) (edge/gateway/src/durable.rs)
• Duplicated block (100 lines × 2) (crates/ruvector-kge-ffi/src/optimize.rs)
• Duplicated block (102 lines × 2) (crates/ruvector-kge-ffi/src/pipeline.rs)
• Duplicated block (10–12 lines × 2) (scripts/seed-brain-all.py)
• Duplicated block (10–12 lines × 4) (crates/ruvector-kge/src/train/loss.rs)
• Duplicated block (11 lines × 2) (crates/ruvector-edge-store/src/ops/vector.rs)
• Duplicated block (11 lines × 2) (crates/ruvector-kge-ffi/src/model.rs)
• Duplicated block (11 lines × 2) (crates/ruvector-kge-ffi/src/ops.rs)
• Duplicated block (11 lines × 2) (edge/auth-worker/src/platform.rs)
• Duplicated block (11 lines × 3) (crates/ruvector-kge-ffi/src/ops.rs)
• Duplicated block (12 lines × 2) (crates/ruvector-edge-store/src/ops/vector.rs)
• Duplicated block (12 lines × 2) (crates/ruvector-kge-ffi/src/model.rs)
• Duplicated block (12 lines × 2) (crates/ruvector-kge-ffi/src/model.rs)
• Duplicated block (12 lines × 2) (crates/ruvector-kge-ffi/src/model.rs)
• …and 517 more

• 115 commits — 93 feature/other, 22 fixes

• npm/core — 33 commits
• (repo) — 22 commits
• npm/packages — 22 commits
• crates/mcp-brain-server — 5 commits
• crates/ruvector-typesafe-core — 5 commits
• (root) — 4 commits
• .github/workflows — 4 commits
• crates/ruvector-kge — 3 commits
• crates/ruvector-mincut — 2 commits
• crates/rvAgent — 2 commits
• examples/esp32-decision — 2 commits
• crates/ruvector-agent-memory — 1 commit
• crates/ruvector-core — 1 commit
• crates/ruvector-embed-core — 1 commit
• crates/ruvector-kge-ffi — 1 commit
• crates/ruvector-typesafe-train — 1 commit
• crates/ruvector-wasm — 1 commit
• crates/ruvllm — 1 commit
• crates/ruvllm-cli — 1 commit
• crates/rvf — 1 commit

• fix: Fix WASM HNSW fallback with portable graph index and recall tests (#1035)
• fix: chore(deps): bump hono 4.13.1->4.13.7 and fast-uri 3.1.4->3.1.7 (CVE fixes) (#987)
• fix: chore(mincut): fix publish-blocking version pins and build npm wasm artifacts (#990)
• fix: ci(publish): longer npm propagation window; fix(filter): E0275 in Workspace CI (#1015)
• fix: ci: pin Tiny Dancer build toolchain to 1.97.0 to fix aarch64-musl zig link (#900) (#934)
• fix: fix(brain): build the knowledge graph off-lock — ends rebuild 504 storms (ADR-349 #6) (#1024)
• fix: fix(brain): make the ruvbrain-sse image build again (#1025)
• fix: fix(brain): pi.ruv.io 504 lock contention, UTF-8 crash, authenticated write paths (ADR-349) (#1023)
• fix: fix(brain): rebuildable image + no writes/training until Firestore hydration completes (#1022)
• fix: fix(embed-core): embed in bounded batches in the ORT backend
• fix: fix(hnsw): stop search() silently dropping stored points (#773) (#944)
• fix: fix(mincut): deterministic, non-degenerate RuVectorGraphAnalyzer::partition() (#979)
• fix: fix(router,ruvector): ship #430 + HNSW neighbour-selection heuristic; honour documented DbOptions; router 0.1.31, ruvector 0.3.2 (#1005)
• fix: fix(ruvector): rvf can never back VectorDb, and the stub must not eat writes (#992)
• fix: fix(ruvllm): say when generate()/query() text is not model output; opt-in strict
• fix: fix(ruvllm-cli): make serve's mock mode visible, and add --strict to fail instead
• fix: fix(ruvllm-wasm): fail closed instead of returning placeholder inference (#1061)
• fix: fix(rvf): bump @ruvector/rvf pin ^0.1.0 -> ^0.3.4 (string-id data loss) (#980)
• fix: fix(typesafe): train() can report the head decide will actually use
• fix: fix: #995 #984 #968 #988 + publish hardening; ruvector 0.3.3, graph-node 2.1.1 (#1014)
• …and 95 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

ruvnet/RuVector was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.