Skip to content
CAI
Software that uses CAICheck a score

ruvnet/RuVector

53.5

Adequate · 14 November 2026

1346.3k

lines of production code

Rust

with TypeScript, JavaScript

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add CommonJS support for @ruvector/core

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

Add REFRAG pipeline example demonstrating tensor-based RAG optimization

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

Add RuVector ONNX embeddings example with GPU acceleration

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

Add V1 ABI stubs for min-cut WASM brain node

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

Add browser and Node.js-specific VectorDB entry points with IndexedDB and file persistence stubs

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

Add gene regulatory network consciousness explorer example

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

Add neural trading system example with Apify integration

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

Add robotics examples demonstrating perception, cognition, and swarm coordination

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

Add sevensense-analysis bioacoustic intelligence platform

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

Add sevensense-analysis bioacoustic intelligence platform

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. Also in this area: 1 commit (0 fixes) modifying (repo-wide).

examples/vibecast-7sense/crates/sevensense-embedding · low confidence · unverified

Added Google Cloud deployment automation and monitoring for the Brain server

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

Added benchmark examples for DiskANN delete recall, hot search, and mmap storage comparison

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

Added benchmark results and technical planning documentation

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

Added benchmarking utilities for Ruvector

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

Added experimental quantum-inspired cognition and time-crystal simulation research modules

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

Added performance profiling and benchmarking tooling

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

Added ruvector-core documentation and AVX-512 build configuration

The ruvector-core crate now includes a comprehensive README detailing its capabilities as an embeddable vector database engine, covering HNSW indexing, quantization, and SIMD acceleration. Additionally, a new build script has been introduced to conditionally enable the \ruvector\_core\_stable\_avx512\ configuration flag when compiling with Rust 1.89 or later, ensuring optimal hardware-accelerated performance while maintaining fallbacks for older compiler versions.

crates/ruvector-core · high confidence

Added usage examples for FlashAttention, Mamba, and Mincut-Gated Transformer

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

AgenticDB API and pluggable embedding providers

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. Also in this area: Rust 1.88 compatibility and improved build safety.

crates/ruvector-core/examples, crates/ruvector-core/src · high confidence

Browser-based optical simulation and receipt verification

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

CLI example adds automatic JS syntax repair for decompiled modules

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

Entropy-adaptive ANN search PoC added with benchmarking infrastructure

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

Initial AArch64 architecture support for the RuVix kernel

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

Initial Node.js bindings for Ruvector vector database

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 · high confidence

Initial release of Agentic Robotics framework crates

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

Initial release of RuVector Attention CLI and WebAssembly bindings

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 · high confidence

Initial release of WASM attention and training primitives

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

Initial release of the RVM kernel integration crate

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

Initial repository scaffolding and configuration

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

Introduce @ruvector/agentic-synth-examples package with CLI and tutorials

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

Introduce @ruvector/core with multi-platform native bindings and TypeScript tooling

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

Introduce @ruvector/ospipe SDK for semantic AI memory and add RVF MCP server

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

Introduce @ruvector/postgres-cli for one-command PostgreSQL and RuVector setup

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

Introduce @ruvector/ruvllm-wasm and @ruvector/ruvllm-cli packages with fail-closed inference

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

Introduce @ruvector/rvf-solver npm package with WASM-backed self-learning solver

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

Introduce @ruvector/typesafe benchmark harness and dataset loaders

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

Introduce AgentDB adapter for vector storage and HNSW indexing

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. Also in this area: 5 commits (2 fixes) modifying crates/rvf; 1 commit (0 fixes) modifying crates/rvf, npm/packages/rvf-node; 5 commits (1 fix) modifying crates/rvf; Verified streaming ingest with strict security and format changes; rvf-runtime 0.4.0 introduces wire dialect, progressive streaming, and signed store support; and 3 more.

crates/rvf · medium confidence · unverified

Introduce Claude Code hooks integration and self-learning intelligence system

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

Introduce Cypher query language parser for RuVector graph database

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

Introduce DiskANN index with mmap-backed vector storage and drift-adaptive reuse

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

Introduce FPGA Transformer backend with deterministic inference and WebAssembly support

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

Introduce GNN-based candidate reranking to recover ANN recall

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

Introduce MCP Gate server with adaptive monitoring and schema caching

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

Introduce MaxSim late-interaction search with multiple index variants

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

Introduce Neural Trader coherence gating and replay memory infrastructure

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

Introduce Node.js bindings for Ruvector GNN layer and tensor compression

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

Introduce Node.js bindings for Tiny Dancer neural routing

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

Introduce Node.js bindings for dynamic minimum cut and routing

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

Introduce Node.js bindings for the vector router via NAPI-RS

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

Introduce PowerInfer-style sparse inference engine with SIMD optimizations

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

Introduce RVM Coherence engine for adaptive partition split/merge decisions

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

Introduce RVM core type definitions for the microhypervisor

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

Introduce RaBitQ rotation-based 1-bit quantization for approximate nearest-neighbor search

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

Introduce Router Core vector database with HNSW indexing and neural routing

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

Introduce RuVector CLI with local intelligence and PostgreSQL-backed hooks storage

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

Introduce RuVector GNN WebAssembly bindings for browser and Node.js

This change adds the \ruvector-gnn-wasm\ crate, providing WebAssembly bindings that expose Graph Neural Network operations to JavaScript environments. Users can now instantiate \JsRuvectorLayer\ for GNN forward passes (including multi-head attention and GRU updates), use \JsTensorCompress\ for adaptive tensor compression based on access frequency, and perform differentiable similarity search via \differentiableSearch\. The bindings are built with \wasm-pack\ and support Node.js, browser, and bundler targets, with constructors returning \Result\ types to handle errors gracefully instead of panicking.

crates/ruvector-gnn-wasm · high confidence

Introduce RuVector Graph Transformer with proof-gated mutation and specialized modules

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

Introduce RuVector Server REST API crate

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

Introduce RuVector Sparsifier for dynamic spectral graph compression

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

Introduce RuVix Cognition Kernel with proof-gated syscalls and AArch64 boot infrastructure

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

Introduce RuvLLM CLI for local LLM inference on Apple Silicon

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

Introduce Ruvector CLI and WebAssembly bindings for vector database operations

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-wasm · high confidence

Introduce RvLite, a WASM-based vector database with SQL, SPARQL, and Cypher support

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

Introduce Scipix API server with OCR, PDF, and authentication features

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

Introduce SkyGraph Appliance core pipeline for synthetic ADS-B monitoring

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

Introduce TileZero arbiter for the Anytime-Valid Coherence Gate

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

Introduce TurboVec multi-bit ANN index with 3-bit quantization and external ID management

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

Introduce WebAssembly bindings for PowerInfer-style sparse inference

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

Introduce WebAssembly bindings for dynamic minimum cut and routing

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

Introduce WebAssembly bindings for the RuVector Graph Transformer

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

Introduce bounded RAG retrieval research crate

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

Introduce capability-based access control and optional WebAssembly guest runtime

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

Introduce capability-gated ANN search with per-vector access control

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

Introduce classical compute backend with SIMD, thermodynamic tracking, and cross-domain transfer

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

Introduce coherence measurement and spectral health monitoring for attention mechanisms

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

Introduce coherence-aware scheduler with degraded mode and epoch-based witnessing

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

Introduce core delta and graph delta libraries for vector and graph change tracking

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 · high confidence

Introduce core market event types and graph schema for Neural Trader

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

Introduce delta-aware HNSW index with incremental updates and quality monitoring

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

Introduce delta-behavior example with WASM bindings and SIMD optimizations

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

Introduce deterministic 7-phase boot sequence with measured attestation and AArch64 HAL

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

Introduce distributed clustering and Raft consensus crates

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

Introduce distributed graph query execution and federation infrastructure

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

Introduce emergent-time crate with physics-based and agentic time primitives

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

Introduce exo-core cognitive substrate with IIT, thermodynamics, and pluggable backends

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

Introduce exo-federation crate for distributed cognitive mesh

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

Introduce exo-manifold crate for learned manifold storage and retrieval

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

Introduce exo-temporal crate for causal temporal memory and anticipation

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

Introduce experimental vector search and namespace routing crates

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.

crates/ruvector-cluster-rag, crates/ruvector-namespace-merge, crates/ruvector-query-cache · high confidence

Introduce federated knowledge brain server with cognitive and security primitives

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

Introduce formal verification layer for vector operations

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

Introduce hyperbolic (Poincaré ball) HNSW vector search with WebAssembly bindings

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 · high confidence

Introduce mcp-brain client-side MCP server for shared learning

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

Introduce min-cut gated attention operator

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

Introduce mincut-gated transformer with coherence-driven early exit and energy-based gating

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

Introduce minimal WASM DAG library for browser and embedded environments

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

Introduce neural-trader-strategies crate with risk-gated trading strategies

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

Introduce neural-trader-wasm crate with WASM bindings for market data and coherence gates

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

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

Introduce ruLake cache layer with witness-addressed sharing, federated search, and bundle persistence

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

Introduce ruos-thermal CLI and deploy scripts for Pi 5 thermal monitoring

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

Introduce ruvector-crv crate for CRV protocol integration

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

Introduce ruvector-dither for deterministic low-bit quantization

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

Introduce ruvector-filter for advanced metadata filtering

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

Introduce ruvector-filter for advanced metadata filtering

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. Also in this area: Fixes metrics gathering test to assert specific metric name.

crates/ruvector-metrics · high confidence

Introduce ruvector-gnn crate with GNN layers, compression, and continual learning support

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

Introduce ruvector-lsm-ann: write-optimized streaming vector index

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

Introduce ruvector-math crate with advanced vector search algorithms

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

Introduce ruvector-replication crate for multi-master vector replication

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

Introduce ruvector-robotics crate with perception, cognitive, and MCP modules

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

Introduce ruvector-timesfm for TimesFM-based forecasting and anomaly detection

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

Introduce rvForge authoring core for building and signing RVF containers

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

Introduce rvm-partition for partition lifecycle, isolation, and IPC

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

Introduce scope-sharded vector index with strict physical isolation and security hardening

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

Introduce self-learning hooks for Claude Code with MCP tool-access policy

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

Introduce tamper-evident model envelopes with opt-in HMAC signing

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

Introduce tamper-evident vector write gates with cryptographic receipts

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

Introduce temporal coherence decay for agent memory retrieval

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

Introduce temporal tensor compression with tiered quantization

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

Introduce the Anytime-Valid Coherence Gate kernel for real-time autonomous agent safety

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

Introduce thermorust crate for thermodynamic neural-motif simulations

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

Introduce training-free retrieval and diffusion pipelines for small-vocab domains

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

Introduce verifiable WASM cognitive container with epoch-based orchestration

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

Introduces Cortex-A76 build optimizations and hardware deployment assets for Pi 5 clusters

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

Introduces HNSW deletion repair strategies with configurable recall-latency tradeoffs

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

Introduces MetaHarness integration for autonomous RuVector optimization

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

Introduces Node.js and WebAssembly bindings for the RuVector sparse solver

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

Introduces RVF boot loading infrastructure with cryptographic verification and capability management

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

Introduces RuVector Graph database with schema, indexing, and codegen

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

Introduces RuVix CLI and BCM2711/BCM2712 hardware drivers for Raspberry Pi 4/5

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

Introduces RuVix Hardware Abstraction Layer and AArch64 device drivers

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

Introduces Turbo4 4-bit vector quantization with 1-bit candidate generation

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

Introduces WASM bindings for the ruvector typesafe decision engine

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

Introduces coherence-gated HNSW search variants

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

Introduces experimental speculative ANN search crate

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

Introduces high-performance query execution engine with caching and parallel processing

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

Introduces hybrid vector-graph query capabilities with semantic search and GNN inference

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

Introduces lock-free queue IPC and capability-protected memory regions

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 · high confidence

Introduces research crate for threshold-driven approximate nearest-neighbour search

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

Introduces witness-chained provenance receipts for ANN retrieval results

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

Introducing @ruvector/rudag: WASM-accelerated DAG library with self-learning optimization

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

Introducing DrAgnes: a browser-based dermatology intelligence example

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

Introduction of HolE knowledge-graph embeddings with ANN retrieval and security hardening

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

Micro HNSW WASM v2.3 adds neuromorphic SNN features and performance optimizations

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

Native Node.js bindings for knowledge-graph embeddings

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

Native Rust port of TimesFM 1.0 200M inference via Candle

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

New 'Exotic' examples demonstrating coherence-based system behaviors

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

New @ruvector/attention-unified-wasm npm package with 18+ attention mechanisms

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

New AI and security simulation capabilities in edge-net

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

New CMB Consciousness Explorer example

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

New Cloud Run deployment infrastructure and intelligent load balancing

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

New Decompiler Dashboard example application

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

New Docker build infrastructure and deployment tooling for mcp-brain-server

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

New ESP32 LLM inference crate with micro-optimized attention and distributed federation

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

New GNN training and index-drift validation examples

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

New GPU job runner and training configuration for the OpenJev pipeline

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

New Google Cloud Run GPU benchmark suite with self-learning models

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

New HNSW Rust library with C/Julia bindings and memory-mapped persistence

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

New Hailo-8 NPU embedding backend with CPU fallback for Raspberry Pi 5

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

New Kalshi integration crate with live trading, paper trading, and signing benchmarks

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. Also in this area: 1 commit (0 fixes) modifying (repo-wide).

crates/ruvector-kalshi/src · low confidence · unverified

New Node.js bindings for the RuVector Graph Transformer

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

New OSpipe example: RuVector-enhanced personal AI memory for Screenpipe

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. Also in this area: 1 commit (0 fixes) modifying examples/data/framework.

examples, examples/data/framework · low confidence

New PhotonLayer benchmarking suite with optical compression and privacy analysis

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.

crates/photonlayer-cli, crates/photonlayer-core · high confidence

New Python convenience APIs for RuVector Rust backends

This release introduces a suite of new Python packages that provide validated, high-level APIs backed by native RuVector Rust code. Users can now access \ruvector\_core\ for vector storage and search (supporting cosine, euclidean, dot, and manhattan metrics), \ruvector\_attention\ for scaled dot-product attention, \ruvector\_gnn\ for graph neural network inference, \ruvector\_router\ for embedding-based semantic routing, \ruvector\_ruvllm\ for bounded token caches, \ruvector\_sona\ for LoRA transforms, and \ruvector\_rvf\ (including a WebAssembly variant) for local vector storage. All modules include strict input validation, type hints, and safety checks to ensure stable interaction with the underlying Rust runtime.

(repo-wide) · high confidence

New Python packages for embedding clustering, graph traversal, and reranking

Users can now install and use three new Python packages—ruvector-cluster, ruvector-graph, and ruvector-rerank—that expose native Rust-backed capabilities for clustering embeddings, traversing property graphs, and reranking candidates via attention weights. The clustering package provides a cluster function that groups vectors using Lloyd's algorithm with configurable iterations and returns labels, centroids, cohesion, and sizes. The graph package exposes a reachable function for breadth-first traversal with configurable depth and node limits, raising errors on budget overflows. The reranking package offers a rank function that scores candidates using scaled dot-product attention, returning ranked candidates with weights that sum to one, supporting optional top-k truncation.

(repo-wide) · high confidence

New RuVector Decompiler with JS and LLM weight analysis

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

New RuVector Edge Swarm example with P2P, intelligence sync, and compression

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

New WASM module for browser-side SkyGraph projection and anomaly scoring

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

New WASM modules for HNSW routing, MicroLoRA adaptation, and Pi-quantization

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

New WASM-compatible ONNX embedding example

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

New WebAssembly bindings and verified application examples

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

New WebAssembly bindings for advanced mathematical operations

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

New WebAssembly bindings for the mincut-gated transformer

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

New acoustic digital human workbench for ultrasound CT simulation and visualization

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

New advanced vector search capabilities in ruvector-core

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

New advanced vector search capabilities: hypergraphs, learned indexes, neural hashing, and TDA

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

New agent templates and configuration scaffolding

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

New attention mechanism implementations and benchmarks

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

New automation scripts and documentation for build, deployment, and analysis workflows

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

New benchmark binaries for performance profiling and system comparison

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

New benchmark harness for IVF pruning and PQ/IVFADC performance sweeps

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

New benchmark harnesses for AGI contract compliance and intelligence assessment

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

New benchmarking scripts and Node.js usage examples

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 · high confidence

New benchmarking suite and algorithmic examples for min-cut and routing

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

New boundary-discovery examples across 11 scientific domains

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

New collection management and primality utility crates

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

New consciousness analysis examples for climate, ecosystem, and quantum systems

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

New consciousness computation crate with WASM bindings and IIT algorithms

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

New discovery ETL pipeline with sublinear cross-domain correlation

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

New distributed agent coordination and secure command execution

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

New domain expansion engine with cross-domain transfer learning and meta-learning capabilities

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

New edge analytics service for min-cut graph queries

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

New example data integrations for climate and financial datasets

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

New examples and benchmarks for the Neural Self-Learning DAG system

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

New examples for dynamic minimum cut and vector-graph fusion

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 · high confidence

New exo-exotic crate for speculative cognitive experiments

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

New graph database benchmark suite with Neo4j comparison

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

New graph-aware attention mechanisms for DAG query optimization

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

New hailort-sys FFI bindings and ruvector-mmwave radar parser

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

New hybrid search crate with BM25, ANN, and fusion strategies

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

New memory management capabilities: CAMA arbitration, D²ACCI diagnostics, and Mincut-gated forgetting

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

New neural competition and dendritic integration components

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 · high confidence

New research examples for neuromorphic spiking and conscious language interface

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

New ruvector-nervous-system-wasm package for browser-based bio-inspired AI

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

New ruvector-profiler crate for benchmark observability

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

New rvm-checkpoint crate for C2SP transparency log integration

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

New standalone binaries for embedding, local brain, SSE proxy, and batch worker

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

New streaming memory admission crate with global-min-cut policies

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

New timesfm-harness scaffolding for TimesFM inference development

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

New training corpus added to data directory

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

New unified WebAssembly attention library with 18+ mechanisms

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

New vector index implementations: Flat, HNSW, and Turbo4

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

Node.js bindings for attention mechanisms, training, and graph operations

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: AI Safety Coherence Engine

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

RuvBot package introduction with CLI, GCP deployment, and multi-tenant architecture

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

RuvLLM example adds graph attention engine and multiple demonstration binaries

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

SONA crate introduced with WASM, Node.js, and Rust support

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

StagedWorkspace introduces content-hash state binding with fail-closed staleness checks

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

Structure-preserving graph condensation with differentiable min-cut

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-wasm, crates/ruvector-perception · high confidence

Tiny Dancer core adds benchmarks, admin API, observability, and training pipeline

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

WASM bindings for cross-domain transfer learning engine

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

WASM bindings for the Louvain decompiler pipeline

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

WASM vector search now includes a corrected adapter and portable HNSW fallback

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

pi.ruv.io landing page and static assets added

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

rvAgent introduces a structured agent configuration system with specialized roles and security controls

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

Behavioural changes

1 commit (0 fixes) modifying (repo-wide)

A change to existing behaviour in (repo-wide) — 1 commit, 5 files: “security: RUSTSEC sweep 2026-11-10 (29 advisories -\> 4 gated) (\#1482)” (refs \#1482). Also in this area: Introduces RuVix CLI and BCM2711/BCM2712 hardware drivers for Raspberry Pi 4/5.

crates/ruvector-e-means, npm/packages/e-means, crates/ruvix/crates/cli · low confidence · unverified

1 commit (0 fixes) modifying crates/ruvector-diskann/benches

A change to existing behaviour in crates/ruvector-diskann/benches — 1 commit, 1 file: “bench(diskann): add a Criterion harness for the distance kernels (\#783)” (refs \#783).

crates/ruvector-diskann/benches · medium confidence · unverified

10 commits (0 fixes) modifying crates/ruvector-attention-wasm/pkg

A change to existing behaviour in crates/ruvector-attention-wasm/pkg — 10 commits, 6 files: “chore: Update attention NAPI-RS binaries for all platforms”.

crates/ruvector-attention-wasm/pkg · medium confidence · unverified

10 commits (0 fixes) modifying crates/ruvector-graph-transformer-node/npm

A change to existing behaviour in crates/ruvector-graph-transformer-node/npm — 10 commits, 14 files: “chore: Update graph transformer NAPI-RS binaries for all platforms”.

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

11 commits (3 fixes) modifying npm/packages/ruvector-extensions

A change to existing behaviour in npm/packages/ruvector-extensions — 11 commits (3 fixs), 85 files: “docs(npm): animated SVG headers for user-facing package READMEs (\#1350)”; “fix(ts): align burst-scaling and ruvector-extensions with VectorDB API (\#493)”; “fix(embeddings): reconcile bge-small convention between Lattice providers (\#663)”; and 7 more (refs \#1350, \#493, \#663, \#123, \#651, …).

npm/packages/ruvector-extensions · medium confidence · unverified

14 commits (5 fixes) modifying npm/packages/rvf-wasm

A change to existing behaviour in npm/packages/rvf-wasm — 14 commits (5 fixs), 5 files: “rvf family SEO metadata (ADR-356): rvf 0.4.9, rvf-node 0.4.4, rvf-wasm 0.1.13, rvf-solver 0.1.11”; “fix(rvf-wasm): fix Node.js CJS/ESM glue and add rvf-node CI”; “perf(rvf,rvm): HNSW query path, RaBitQ, contiguous slab, witness v2, mincut wiring + security hardening (\#555)”; and 8 more (refs \#555, \#1323, \#1350, \#1377, \#166, …).

npm/packages/rvf-wasm · medium confidence · unverified

15 commits (4 fixes) modifying crates/ruvector-weaver

A change to existing behaviour in crates/ruvector-weaver — 15 commits (4 fixs), 60 files: “weaver seo propose: label optional/peer edges in Works with / Used by; apply --in-place to regenerate blocks on an existing PR branch”; “weaver seo: portfolio SEO / distribution layer + ADR-356”; “fix(weaver): gate false positives — leak allowlist/new-only leaks, published-graph cycle check (\#1392)”; and 12 more (refs \#1392, \#1369, \#1388, \#1380, \#1378, …).

crates/ruvector-weaver · medium confidence · unverified

16 commits (5 fixes) modifying npm/packages/agentic-synth

A change to existing behaviour in npm/packages/agentic-synth — 16 commits (5 fixs), 438 files: “fix(agentic-synth): pin open 0.x ranges, drop unresolvable peers; examples packs against 0.1.11 (\#1486)”; “docs(npm): animated SVG headers for user-facing package READMEs (\#1350)”; “README: label optional/peer edges in Works with / Used by (agentic-flow uses @ruvector/rudag optionally)”; and 12 more (refs \#1486, \#1350, \#1495, \#1345, \#739, …).

npm/packages/agentic-synth · medium confidence · unverified

17 commits (0 fixes) modifying crates/ruvector-attention-node/npm

A change to existing behaviour in crates/ruvector-attention-node/npm — 17 commits, 5 files: “chore: Update attention NAPI-RS binaries for all platforms”.

crates/ruvector-attention-node/npm · medium confidence · unverified

18 commits (0 fixes) modifying crates/ruvector-gnn-node/npm

A change to existing behaviour in crates/ruvector-gnn-node/npm — 18 commits, 18 files: “chore: Update GNN NAPI-RS binaries for all platforms”.

crates/ruvector-gnn-node/npm · medium confidence · unverified

18 commits (7 fixes) modifying npm/packages/core

A change to existing behaviour in npm/packages/core — 18 commits (7 fixs), 17 files: “fix(core,node): keep VectorDB::new adopting; check metric only when passed (\#1063)”; “feat: comprehensive ruvector updates - analysis, workers, dashboard enhancements”; “SEO metadata: homepage https://ruv.io, keywords, cross-links (6 packages, ADR-356)”; and 14 more (refs \#1063, \#1350, \#1382, \#1391, \#1346, …).

npm/packages/core · medium confidence · unverified

2 commits (0 fixes) modifying crates/ruvector-core, crates/ruvector-pq-search, crates/ruvector-rairs

A change to existing behaviour in crates/ruvector-core, crates/ruvector-pq-search, crates/ruvector-rairs — 2 commits, 12 files: “docs(crates): ADR-356 metadata for ruvector-core, ruvector-pq-search, ruvector-rairs (\#1492)”; “feat: add shared e-means clustering and ecosystem integrations (\#1489)” (refs \#1492, \#1489). Also in this area: Introduce RAIRS IVF index family with three search variants.

crates/ruvector-rairs · medium confidence · unverified

2 commits (0 fixes) modifying crates/ruvector-core, crates/ruvector-pq-search, crates/ruvector-rairs

A change to existing behaviour in crates/ruvector-core, crates/ruvector-pq-search, crates/ruvector-rairs — 2 commits, 12 files: “docs(crates): ADR-356 metadata for ruvector-core, ruvector-pq-search, ruvector-rairs (\#1492)”; “feat: add shared e-means clustering and ecosystem integrations (\#1489)” (refs \#1492, \#1489). Also in this area: Rust 1.88 compatibility and safer remainder checks; Introduce ruvector-pq-search crate with Product Quantization (PQ-ADC) vector search.

crates/ruvector-pq-search · medium confidence · unverified

2 commits (0 fixes) modifying crates/ruvector-edge-registry

A change to existing behaviour in crates/ruvector-edge-registry — 2 commits, 39 files: “edge-registry: accept the rvf lineage segment (0x24) as opaque”; “feat(edge): multi-tenant ruvector services on Cloudflare with cognitum-one OAuth (ADR-351, M0–M5) (\#1098)” (refs \#1098).

crates/ruvector-edge-registry · medium confidence · unverified

2 commits (0 fixes) modifying crates/ruvector-spann

A change to existing behaviour in crates/ruvector-spann — 2 commits, 6 files: “bench(spann): add distance benchmarks (\#782)”; “research(nightly): spann-partition-spill — boundary-safe ANN in Rust (\#602)” (refs \#782, \#602).

crates/ruvector-spann · medium confidence · unverified

2 commits (1 fix) modifying crates/emergent-time-wasm

A change to existing behaviour in crates/emergent-time-wasm — 2 commits (1 fix), 4 files: “fix(emergent-time): 0.1.1 — window shrink, bounded detector history, NaN/std guards (\#1326)”; “feat(emergent-time): @ruvector/emergent-time WASM package for Agentic Time (\#566)” (refs \#1326, \#566).

crates/emergent-time-wasm · medium confidence · unverified

2 commits (1 fix) modifying edge/auth-worker

A change to existing behaviour in edge/auth-worker — 2 commits (1 fix), 27 files: “fix(edge): one p256 for the edge workspace (0.14), so gateway/auth-worker tests compile”; “feat(edge): multi-tenant ruvector services on Cloudflare with cognitum-one OAuth (ADR-351, M0–M5) (\#1098)” (refs \#1098).

edge/auth-worker · medium confidence · unverified

25 commits (12 fixes) modifying npm/packages/rvlite

A change to existing behaviour in npm/packages/rvlite — 25 commits (12 fixs), 19 files: “feat: comprehensive ruvector updates - analysis, workers, dashboard enhancements”; “fix(rvlite): reserve explicit batch IDs during automatic allocation”; “feat(rvf): RVF WASM integration, witness auto-append, real verification, prebuilt fallbacks, README examples”; and 17 more (refs \#1350, \#1329, \#123, \#1346, \#69, …).

npm/packages/rvlite · medium confidence · unverified

3 commits (1 fix) modifying crates/ruvector-cnn-wasm

A change to existing behaviour in crates/ruvector-cnn-wasm — 3 commits (1 fix), 2 files: “fix(cnn): @ruvector/cnn 0.1.2 — working embedder, boundary validation, InfoNCE pairing (\#1336)”; “style: apply cargo fmt formatting”; “feat(ruvector-cnn): CNN contrastive learning + SIMD optimization fixes (\#252)” (refs \#1336, \#252).

crates/ruvector-cnn-wasm · medium confidence · unverified

37 commits (13 fixes) modifying npm/packages/rvf

A change to existing behaviour in npm/packages/rvf — 37 commits (13 fixs), 68 files: “fix(rvf): add string ID ↔ numeric label mapping to NodeBackend”; “fix(rvf): honor the store metric, reject bad batches, and keep quarantined maps refused”; “feat(rvf): expose AGI components via npm packages”; and 26 more (refs \#657, \#658, \#696, \#1367, \#1350, …).

npm/packages/rvf · medium confidence · unverified

4 commits (0 fixes) modifying crates/ruvector-gnn-node

A change to existing behaviour in crates/ruvector-gnn-node — 4 commits, 6 files: “feat: Add ruvector-gnn crate with GNN, compression, WASM and Node.js bindings”; “gnn: add files allowlist to npm package (\#1374)”; “SEO metadata: homepage https://ruv.io, keywords, cross-links (19 packages, ADR-356)”; and 1 more (refs \#1374).

crates/ruvector-gnn-node · medium confidence · unverified

4 commits (0 fixes) modifying crates/ruvector-learning-wasm/src

A change to existing behaviour in crates/ruvector-learning-wasm/src — 4 commits, 4 files: “style: apply rustfmt across entire codebase”; “feat(wasm): add 5 exotic AI WASM packages with npm publishing”.

crates/ruvector-learning-wasm/src · medium confidence · unverified

4 commits (1 fix) modifying crates/ruvector-attention-node

A change to existing behaviour in crates/ruvector-attention-node — 4 commits (1 fix), 6 files: “SEO metadata: homepage https://ruv.io, keywords, cross-links (19 packages, ADR-356)”; “perf(attention): native faster than a JS loop (2.0-5.5x), computeFlat, full typings; @ruvector/attention 2.3.0 (\#1390)”; “feat: Export all 39 attention mechanisms and utilities”; and 1 more (refs \#1390).

crates/ruvector-attention-node · medium confidence · unverified

5 commits (0 fixes) modifying npm/packages/all

A change to existing behaviour in npm/packages/all — 5 commits, 14 files: “feat(npm): opt-in @ruvector/all umbrella package (unpublished) (\#1344)”; “docs(npm): animated SVG headers for user-facing package READMEs (\#1350)”; “release: ruvector 0.3.25, @ruvector/core 0.1.39, @ruvector/all 0.1.3; ruvector-core 2.5.2, ruvector-pq-search 2.3.1, ruvector-rairs 0.1.1 (\#1491)”; and 2 more (refs \#1344, \#1350, \#1491, \#1489).

npm/packages/all · medium confidence · unverified

5 commits (1 fix) modifying crates/ruvector-exotic-wasm/src

A change to existing behaviour in crates/ruvector-exotic-wasm/src — 5 commits (1 fix), 4 files: “style: apply rustfmt across entire codebase”; “ci: fix the two slow test shards (mincut LocalKCut loop, morphogenetic doctests) and bound them”; “feat(wasm): add 5 exotic AI WASM packages with npm publishing”.

crates/ruvector-exotic-wasm/src · medium confidence · unverified

5 commits (1 fix) modifying npm/packages/emergent-time

A change to existing behaviour in npm/packages/emergent-time — 5 commits (1 fix), 6 files: “docs(npm): animated SVG headers for user-facing package READMEs (\#1350)”; “fix(emergent-time): 0.1.1 — window shrink, bounded detector history, NaN/std guards (\#1326)”; “SEO metadata: homepage https://ruv.io, keywords, cross-links (28 packages, ADR-356)”; and 2 more (refs \#1350, \#1326, \#566, \#1346).

npm/packages/emergent-time · medium confidence · unverified

5 commits (1 fix) modifying npm/packages/mincut-wasm

A change to existing behaviour in npm/packages/mincut-wasm — 5 commits (1 fix), 19 files: “chore(mincut): fix publish-blocking version pins and build npm wasm artifacts (\#990)”; “docs(npm): tested quickstarts, correct package names and animated banners for six SEO-wave packages (ADR-356)”; “Optimize exact mincut, routing and RuField spatial awareness across Rust, Node and WASM (\#986)”; and 2 more (refs \#990, \#986).

npm/packages/mincut-wasm · medium confidence · unverified

5 commits (1 fix) modifying npm/packages/ruvector-cnn

A change to existing behaviour in npm/packages/ruvector-cnn — 5 commits (1 fix), 8 files: “docs(npm): animated SVG headers for user-facing package READMEs (\#1350)”; “fix(cnn): @ruvector/cnn 0.1.2 — working embedder, boundary validation, InfoNCE pairing (\#1336)”; “SEO metadata: homepage https://ruv.io, keywords, cross-links (28 packages, ADR-356)”; and 2 more (refs \#1350, \#1336, \#1346, \#252).

npm/packages/ruvector-cnn · medium confidence · unverified

5 commits (2 fixes) modifying crates/ruvector-tiny-dancer-wasm

A change to existing behaviour in crates/ruvector-tiny-dancer-wasm — 5 commits (2 fixs), 2 files: “feat(tiny-dancer): Pandora-pattern value-of-information routing — closed-form Gaussian VoI estimator purchasing (PIR WP28, ADR-331)”; “fix: Fix case sensitivity bug preventing native module from loading”; “SEO metadata: homepage https://ruv.io, keywords, cross-links (19 packages, ADR-356)”; and 2 more.

crates/ruvector-tiny-dancer-wasm · medium confidence · unverified

5 commits (2 fixes) modifying npm/packages/burst-scaling

A change to existing behaviour in npm/packages/burst-scaling — 5 commits (2 fixs), 12 files: “fix(npm): burst-scaling shell injection + rudag unloadable build (low-traffic review e2) (\#1348)”; “docs(npm): animated SVG headers for user-facing package READMEs (\#1350)”; “fix(ts): align burst-scaling and ruvector-extensions with VectorDB API (\#493)”; and 2 more (refs \#1348, \#1350, \#493).

npm/packages/burst-scaling · medium confidence · unverified

6 commits (0 fixes) modifying crates/ruvector-exotic-wasm/pkg, crates/ruvector-learning-wasm/pkg

A change to existing behaviour in crates/ruvector-exotic-wasm/pkg, crates/ruvector-learning-wasm/pkg — 6 commits, 10 files: “docs(npm): tested quickstarts, correct package names and animated banners for six SEO-wave packages (ADR-356)”; “docs(wasm): add comprehensive SEO-optimized README files for npm packages”; “SEO metadata: homepage https://ruv.io, keywords, cross-links (19 packages, ADR-356)”; and 1 more.

crates/ruvector-exotic-wasm/pkg, crates/ruvector-learning-wasm/pkg · medium confidence · unverified

6 commits (1 fix) modifying config

A change to existing behaviour in config — 6 commits (1 fix), 4 files: “weaver seo: portfolio SEO / distribution layer + ADR-356”; “fix(weaver): gate false positives — leak allowlist/new-only leaks, published-graph cycle check (\#1392)”; “weaver seo baseline: platform class from the platform-suffixed name; os/cpu alone is noted, not reclassified”; and 3 more (refs \#1392, \#1369, \#1378).

config · medium confidence · unverified

6 commits (1 fix) modifying crates/ruvector-kalshi/examples

A change to existing behaviour in crates/ruvector-kalshi/examples — 6 commits (1 fix), 6 files: “feat(kalshi): three live example runners + brain wired into paper\_trade”; “feat(kalshi): wire neural-trader-coherence + neural-trader-replay”; “perf(kalshi): Arc-share signer internals; cache REST sig path”; and 3 more.

crates/ruvector-kalshi/examples · medium confidence · unverified

6 commits (1 fix) modifying npm/packages/graph-wasm

A change to existing behaviour in npm/packages/graph-wasm — 6 commits (1 fix), 6 files: “docs(npm): tested quickstarts, correct package names and animated banners for six SEO-wave packages (ADR-356)”; “docs(npm): animated SVG headers for user-facing package READMEs (\#1350)”; “SEO metadata: homepage https://ruv.io, keywords, cross-links (28 packages, ADR-356)”; and 3 more (refs \#1350, \#1331, \#1346).

npm/packages/graph-wasm · medium confidence · unverified

6 commits (1 fix) modifying npm/packages/raft

A change to existing behaviour in npm/packages/raft — 6 commits (1 fix), 57 files: “feat(npm): add @ruvector/raft, @ruvector/replication, @ruvector/scipix packages (\#129)”; “docs(npm): animated SVG headers for user-facing package READMEs (\#1350)”; “SEO metadata: homepage https://ruv.io, keywords, cross-links (28 packages, ADR-356)”; and 2 more (refs \#129, \#1350, \#1349).

npm/packages/raft · medium confidence · unverified

6 commits (2 fixes) modifying crates/ruvector-cnn/src

A change to existing behaviour in crates/ruvector-cnn/src — 6 commits (2 fixs), 47 files: “chore(workspace): fix pre-existing test flakes + add CI -D warnings enforcement”; “fix(cnn): @ruvector/cnn 0.1.2 — working embedder, boundary validation, InfoNCE pairing (\#1336)”; “feat(ruvector-cnn): implement ADR-091 INT8 CNN quantization”; and 3 more (refs \#1336, \#252).

crates/ruvector-cnn/src · medium confidence · unverified

6 commits (2 fixes) modifying npm/packages/ruvector-wasm-unified

A change to existing behaviour in npm/packages/ruvector-wasm-unified — 6 commits (2 fixs), 12 files: “fix(ts): resolve TypeScript errors across 5 npm packages (\#499)”; “fix(wasm-unified): suppress TS2532 in poincareToLorentz loop”; “chore: move packages to npm/packages directory (\#130)”; and 2 more (refs \#499, \#130).

npm/packages/ruvector-wasm-unified · medium confidence · unverified

66 commits (2 fixes) modifying npm/packages/rvf-node

A change to existing behaviour in npm/packages/rvf-node — 66 commits (2 fixs), 8 files: “chore: Update RVF NAPI-RS binaries for all platforms”; “rvf family SEO metadata (ADR-356): rvf 0.4.9, rvf-node 0.4.4, rvf-wasm 0.1.13, rvf-solver 0.1.11”; “chore(rvf-node): add darwin and linux-arm64 platform binaries”; and 12 more (refs \#1350, \#704, \#1400, \#1382, \#1391, …).

npm/packages/rvf-node · medium confidence · unverified

7 commits (2 fixes) modifying npm/packages/graph-data-generator

A change to existing behaviour in npm/packages/graph-data-generator — 7 commits (2 fixs), 27 files: “docs(npm): animated SVG headers for user-facing package READMEs (\#1350)”; “fix: Update doc links and move packages to npm/packages”; “fix(graph-data-generator): 0.1.2 — drop stale compiled JS from src/ that broke 0.1.1 (\#1351)”; and 3 more (refs \#1350, \#1351, \#123).

npm/packages/graph-data-generator · medium confidence · unverified

7 commits (3 fixes) modifying npm/packages/rvforge

A change to existing behaviour in npm/packages/rvforge — 7 commits (3 fixs), 53 files: “fix(rvforge): verify registry object content addresses”; “docs(rvforge): host the illustrated walkthrough on GitHub Pages (\#799)”; “fix(rvforge): preserve unreadable registry history errors”; and 4 more (refs \#799, \#800, \#790).

npm/packages/rvforge · medium confidence · unverified

7 commits (3 fixes) modifying npm/packages/spiking-neural

A change to existing behaviour in npm/packages/spiking-neural — 7 commits (3 fixs), 10 files: “docs(npm): tested quickstarts, correct package names and animated banners for six SEO-wave packages (ADR-356)”; “docs(npm): animated SVG headers for user-facing package READMEs (\#1350)”; “fix: Update doc links and move packages to npm/packages”; and 4 more (refs \#1350, \#1347, \#739).

npm/packages/spiking-neural · medium confidence · unverified

8 commits (1 fix) modifying npm/packages/cognitum-gate-wasm

A change to existing behaviour in npm/packages/cognitum-gate-wasm — 8 commits (1 fix), 20 files: “fix(ts): resolve TypeScript errors across 5 npm packages (\#499)”; “README: label optional/peer edges in Works with / Used by (agentic-flow uses @ruvector/rudag optionally)”; “fix(lint): resolve ESLint errors in cognitum-gate-wasm package”; and 4 more (refs \#499, \#130).

npm/packages/cognitum-gate-wasm · medium confidence · unverified

8 commits (1 fix) modifying npm/packages/diskann

A change to existing behaviour in npm/packages/diskann — 8 commits (1 fix), 5 files: “fix(diskann): reject corrupt index files instead of aborting Node; fix publish path (\#1327)”; “docs(npm): animated SVG headers for user-facing package READMEs (\#1350)”; “README: label optional/peer edges in Works with / Used by (agentic-flow uses @ruvector/rudag optionally)”; and 5 more (refs \#1327, \#1350, \#334, \#1346).

npm/packages/diskann · medium confidence · unverified

8 commits (1 fix) modifying npm/packages/rvf-mcp-server

A change to existing behaviour in npm/packages/rvf-mcp-server — 8 commits (1 fix), 11 files: “fix(rvf-mcp-server): SSE crash/hijack, broken prompts, input bounds (0.1.5) (\#1342)”; “perf(rvf-npm): append-only ID-map journal + RVF-backed rvf-mcp-server (\#1367)”; “docs(npm): animated SVG headers for user-facing package READMEs (\#1350)”; and 4 more (refs \#1342, \#1367, \#1350, \#166, \#1389).

npm/packages/rvf-mcp-server · medium confidence · unverified

9 commits (1 fix) modifying npm/packages/tiny-dancer

A change to existing behaviour in npm/packages/tiny-dancer — 9 commits (1 fix), 4 files: “SEO metadata: homepage https://ruv.io, keywords, cross-links (6 packages, ADR-356)”; “feat(tiny-dancer): full platform matrix — add musl (Alpine) + Windows ARM64”; “feat(tiny-dancer): add score() raw-forward inference + 0.1.22”; and 6 more (refs \#1350, \#1346, \#1321).

npm/packages/tiny-dancer · medium confidence · unverified

9 commits (2 fixes) modifying npm/packages/graph-node

A change to existing behaviour in npm/packages/graph-node — 9 commits (2 fixs), 7 files: “SEO metadata: homepage https://ruv.io, keywords, cross-links (6 packages, ADR-356)”; “fix: \#995 \#984 \#968 \#988 + publish hardening; ruvector 0.3.3, graph-node 2.1.1 (\#1014)”; “chore(npm): set homepage https://ruv.io at the source templates of 13 generated packages (\#1455)”; and 6 more (refs \#995, \#984, \#968, \#988, \#1014, …).

npm/packages/graph-node · medium confidence · unverified

9 commits (2 fixes) modifying npm/packages/router

A change to existing behaviour in npm/packages/router — 9 commits (2 fixs), 5 files: “SEO metadata: homepage https://ruv.io, keywords, cross-links (6 packages, ADR-356)”; “docs(npm): animated SVG headers for user-facing package READMEs (\#1350)”; “fix(router): make maxElements honest (\#1099) (\#1101)”; and 5 more (refs \#1350, \#1099, \#1101, \#123, \#1346, …).

npm/packages/router · medium confidence · unverified

9 commits (3 fixes) modifying npm/packages/node

A change to existing behaviour in npm/packages/node — 9 commits (3 fixs), 12 files: “fix(ts): resolve 7 TypeScript build errors across node, postgres-cli, ruvbot”; “fix(node,gnn): ESM import of @ruvector/node resolves; TensorCompress input no longer aborts Node (@ruvector/node 0.1.25) (\#1335)”; “fix(node): remove non-existent @ruvector/core re-exports”; and 5 more (refs \#1335, \#1350, \#123, \#1346).

npm/packages/node · medium confidence · unverified

9 commits (3 fixes) modifying npm/packages/pi-brain

A change to existing behaviour in npm/packages/pi-brain — 9 commits (3 fixs), 9 files: “fix: ruvector-postgres v0.3.1 — audit bug fixes, 46 SQL functions, Docker publish (\#227)”; “fix(pi-brain): 204 delete, path-segment encoding, https-only token, timeouts, MCP notifications (0.1.3) (\#1334)”; “feat(consciousness): SOTA IIT Φ, causal emergence, quantum collapse crate (ADR-131)”; and 6 more (refs \#227, \#1334, \#1350, \#466, \#1346).

npm/packages/pi-brain · medium confidence · unverified

9 commits (3 fixes) modifying npm/packages/sona

A change to existing behaviour in npm/packages/sona — 9 commits (3 fixs), 11 files: “SEO metadata: homepage https://ruv.io, keywords, cross-links (6 packages, ADR-356)”; “sona: validate NAPI inputs, catch panics at the boundary, bound in-flight trajectories (\#1373)”; “docs(npm): animated SVG headers for user-facing package READMEs (\#1350)”; and 6 more (refs \#1373, \#1350, \#1322, \#516, \#1346, …).

npm/packages/sona · medium confidence · unverified

Added patched hnsw\_rs crate for WASM compatibility

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

Automated package-lock.json synchronization via pre-commit hook

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

Chat UI restructured as a standalone SvelteKit application with OpenAI-compatible API support

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

Extracted ruqu and rvdna into standalone git submodules

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

Graph rebuild concurrency control and test determinism

The graph rebuild logic in \crates/mcp-brain-server\ has been refactored to explicitly separate the build phase from the lock acquisition, allowing the system to verify that read requests remain responsive while a rebuild is in progress. This change introduces a \rebuild\_with\_builder\ function that exposes the build boundary, enabling precise control over when the graph write lock is held versus when the expensive batch build occurs. Concurrently, the associated concurrency tests have been updated to use smaller synthetic datasets and explicit synchronization channels to deterministically verify that reads can proceed during the build phase and that mutations are correctly replayed, replacing the previous probabilistic timing-based assertions. Also in this area: Graph rebuilds no longer block search and status requests.

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

Introduce benchmarking, testing, and ESM build fixes for @ruvector/ruvllm

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

Introduces opt-in calibration and decision-head improvements

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

Introduction of v2 witness logging with keyed-BLAKE3 chain MACs and Merkle sealing

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

Python portfolio release repair and security hardening

The python/portfolio area introduces a release-repair workflow to safely resume missing immutable 0.2.0 artifacts (ruvector-attention, ruvector-cluster, ruvector-core, ruvector-gnn, ruvector-graph, ruvector-rerank, ruvector-router, ruvector-ruvllm, ruvector-rvf, ruvector-rvf-wasm, ruvector-sona) by verifying them against a frozen inventory and PyPI state, alongside a release supervisor that gates companion merges on successful native wheel publication and audit. Security posture is strengthened by replacing serde\_yaml with pinned serde-saphyr 1.3.0 to address unmaintained unsafe-libyaml, upgrading Quinn to 0.11.18 to clear five RustSec advisories, and adding strict input validation (nonfinite vector rejection, shape checks, graph traversal limits, WASM fuel/memory caps) and supply-chain gates (pinned actions, read-only build permissions, exact native runtime dependency, cargo-audit with --deny unsound). The portfolio also adds a benchmark for quantization methods (TurboQuant vs baselines) and updates the native runtime pin to 0.1.4 in the manifest while preserving immutable 0.2.0 artifacts at 0.1.3.

python · high confidence

RVM bare-metal AArch64 build infrastructure and proof-engine security hardening

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

Ruvocal UI migrated to SvelteKit with new API client and interaction components

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

Fixes

2 commits (2 fixes) fixing crates/ruvector-gnn/src/layer

A fix in crates/ruvector-gnn/src/layer — 2 commits (2 fixs), 1 file: “fix(python): validate GNN checkpoint layout without replacing learned weights”; “fix(gnn): use is\_multiple\_of in checkpoint validation”.

crates/ruvector-gnn/src/layer · medium confidence · unverified

2 commits (2 fixes) fixing crates/ruvector-streaming-qng

A fix in crates/ruvector-streaming-qng — 2 commits (2 fixs), 9 files: “fix: integrate latest PRs and issue regressions”; “fix(streaming-qng): make non-finite search inputs safe”.

crates/ruvector-streaming-qng · medium confidence · unverified

32 commits (24 fixes) fixing crates/ruvector-py

A fix in crates/ruvector-py — 32 commits (24 fixs), 59 files: “fix(python): enforce collection capacity on Agentforce writes”; “fix(python): preserve unknown Cypher predicates through negation”; “fix(python): discover persisted collections using sidecars”; and 29 more (refs \#1187, \#1117, \#1135, \#1186, \#1139, …).

crates/ruvector-py · medium confidence · unverified

5 commits (3 fixes) fixing crates/ruvector-graph-wasm

A fix in crates/ruvector-graph-wasm — 5 commits (3 fixs), 10 files: “fix: Resolve CI build failures”; “fix(graph-wasm): harden Cypher input, deletes, export; rebuild wasm (2.0.4) (\#1331)”; “docs(npm): improve discoverability and accuracy of @ruvector package docs (\#1346)”; and 2 more (refs \#1331, \#1346, \#1256).

crates/ruvector-graph-wasm · medium confidence · unverified

5 commits (4 fixes) fixing crates/ruvector-embed-core

A fix in crates/ruvector-embed-core — 5 commits (4 fixs), 11 files: “fix: stabilize decision reloads, server readiness and CI gates”; “fix(typesafe): distinguish singleton embedding policy in model identity”; “fix(embed-core): embed in bounded batches in the ORT backend”; and 2 more (refs \#1010, \#1036, \#1055).

crates/ruvector-embed-core · medium confidence · unverified

5 commits (4 fixes) fixing ruvector

A fix in ruvector — 5 commits (4 fixs), 1 file: “feat(ruvector-py): Python SDK, CLI and MCP server (ADR-352) (\#1117)”; “fix(python): validate and normalize bulk collection IDs”; “fix(python): preserve RaBitQ identities across collection lifecycle”; and 2 more (refs \#1117).

ruvector · medium confidence · unverified

8 commits (5 fixes) fixing crates/ruvector-core/src/advanced\_features

A fix in crates/ruvector-core/src/advanced\_features — 8 commits (5 fixs), 12 files. Also in this area: 5 commits (5 fixes) fixing crates/ruvector-postgres; Introduce ruvector-postgres Docker image and build tooling.

crates/ruvector-postgres · medium confidence · unverified

Backport candle-core 0.8.4 with ZIP 9 support and Rust 1.88 minimum

The vendored candle-core library has been updated to version 0.8.4 to support ZIP 9.0.5 manifest dependencies and repair legacy CP437 path compatibility in metadata. This change also raises the minimum supported Rust compiler version to 1.88 and introduces a build-time check that enables stable AVX-512 optimizations when compiling with Rust 1.89 or later, ensuring correct Unicode path decoding and improved performance on supported hardware.

patches/candle-core-0.8.4, patches/candle-core-0.9.2 · high confidence

Cypher MATCH execution and deferred hydration in the Node.js graph bindings

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

Rust 1.88 compatibility and safer remainder checks

The codebase has been updated to compile and run correctly on Rust 1.88. This involves replacing deprecated iterator methods like \chunks\_exact\ with the new \as\_chunks\ API, swapping \repeat(...).take(...)\ for \repeat\_n\, and using \is\_multiple\_of\ instead of the modulo operator for divisibility checks. Additionally, numerous remainder operations (\%\) have been replaced with \checked\_rem\ to prevent panics on zero divisors, and \Option::map\_or(true, ...)\ patterns have been simplified to \is\_none\_or\. A new build script for \ruvllm\ also detects Rust 1.89+ to enable stable AVX-512 features. Also in this area: Introduce RVForge registry crate with content-addressed object model and transparency log.

(repo-wide) · high confidence

Update p256 curve point handling in JWKS verification

The JWKS module in the edge authentication crate now uses the p256 library's \Sec1Point\ API instead of the deprecated \EncodedPoint\ API for handling elliptic curve coordinates. This change updates the internal logic for converting affine coordinates to SEC1 format and verifying keys, ensuring compatibility with the current p256 crate version and addressing associated security advisories. Also in this area: Rust 1.88 compatibility and safer remainder checks; New edge analytics service for min-cut graph queries.

crates/ruvector-edge-auth · high confidence

Test coverage

1 commit adding/updating tests in crates/ruvector-kalshi/tests; 1 commit adding/updating tests in crates/ruvector-weaver/tests/fixtures/consumer-a/packages/inner; 2 commits adding/updating tests in crates/ruvector-attention-node/test; 5 commits adding/updating tests in crates/ruvector-gnn-node/test; 6 commits adding/updating tests in crates/ruvector-cnn/tests; 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 benchmarks for the mincut-gated transformer; Added comprehensive performance benchmarks for ruvector-core; Added comprehensive test suite for the mincut-gated transformer; 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.

Dependencies

Introduce agentic-robotics framework and HailoRT FFI bindings

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

Housekeeping

Documentation for Node.js bindings added

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 cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 50 → 54 (+3.7)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 56 → 56 (-0.1)
  • Architecture 66 → 66 (+0.0)
  • Maturity 80 → 84 (+4.2)
  • Readiness 40 → 47 (+7.5)
  • Security 64 → 66 (+1.6)
  • Domain Modelling 93 → 93 (+0.0)
  • Event Sourcing 100 → 100 (+0.0)
  • Accessibility 52 → 52 (+0.3)
  • Performance 94 → 94 (+0.0)

Resolved (1420)

  • ADR links a record that does not exist (docs/adr/ADR-029-rvf-canonical-format.md)
  • ADR superseded but its status says otherwise (docs/adr/ADR-001-ruvector-core-architecture.md)
  • ApproxMinCut::compute_partition (cognitive 23) (crates/ruvector-mincut/src/algorithm/approximate.rs)
  • ApproxMinCut::stoer_wagner (cognitive 43) (crates/ruvector-mincut/src/algorithm/approximate.rs)
  • ApproxMinCut::stoer_wagner (cyclomatic 21) (crates/ruvector-mincut/src/algorithm/approximate.rs)
  • Classify ADR enforcement: 06 — Decision Record (one-page summary) (docs/sdk/06-decision-record.md)
  • Classify ADR enforcement: ADR 0001: Subquadratic Sparse Attention for ruvllm (crates/ruvllm_sparse_attention/docs/adr/ADR_0001_subquadratic_sparse_attention.md)
  • Classify ADR enforcement: ADR 007: Measured sensor decisions on ESP32 (npm/packages/typesafe/docs/adr/ADR-007-esp32-measured-sensor-decisions.md)
  • Classify ADR enforcement: ADR 151: Transition from searchreplace to Stateful PTY Agent Loop (docs/decisions/ADR-151-stateful-pty-agent.md)
  • Classify ADR enforcement: ADR-0001: Simulation-First Architecture (docs/sonic-ct/adr/ADR-0001-simulation-first.md)
  • Classify ADR enforcement: ADR-0002: Hardware Acquisition Behind a Backend Trait (docs/sonic-ct/adr/ADR-0002-hardware-backend-trait.md)
  • Classify ADR enforcement: ADR-0003: Preserve Raw RF Before Any AI Processing (docs/sonic-ct/adr/ADR-0003-preserve-raw-rf-before-ai.md)
  • Classify ADR enforcement: ADR-0004: Delay-and-Backprojection as the Reconstruction Baseline (docs/sonic-ct/adr/ADR-0004-delay-backprojection-baseline.md)
  • Classify ADR enforcement: ADR-0005: Research/Simulation Only — No Diagnostic Claims (docs/sonic-ct/adr/ADR-0005-medical-claims-boundary.md)
  • Classify ADR enforcement: ADR-0006: DICOMweb / FHIR as Planned External Adapters (docs/sonic-ct/adr/ADR-0006-dicomweb-fhir-adapters.md)
  • Classify ADR enforcement: ADR-0007: Uncertainty-First, Auditable Segmentation (docs/sonic-ct/adr/ADR-0007-uncertainty-first-ai.md)
  • Classify ADR enforcement: ADR-0008: CPU/WASM Now, GPU Later (docs/sonic-ct/adr/ADR-0008-gpu-later.md)
  • Classify ADR enforcement: ADR-0009: Five Acoustic Classes as the Canonical Reconstruction Output (docs/sonic-ct/adr/ADR-0009-five-acoustic-classes-canonical.md)
  • Classify ADR enforcement: ADR-000: Δ-Behavior Definition and Formal Framework (examples/delta-behavior/adr/ADR-000-DELTA-BEHAVIOR-DEFINITION.md)
  • Classify ADR enforcement: ADR-0010: Organ Identity Inferred from Anatomical Priors, Not Speed (docs/sonic-ct/adr/ADR-0010-organ-identity-from-priors.md)
  • …and 1400 more

New (2715)

  • ADR declares no status (docs/adr/ADR-python-cli-empty-batch.md)
  • ADR declares no status (docs/adr/ADR-python-langchain-batch-ids.md)
  • ADR declares no status (docs/adr/ADR-python-llamaindex-constrained-topk.md)
  • ADR declares no status (docs/adr/ADR-python-persistence-pair-integrity.md)
  • ADR declares no status (docs/adr/ADR-python-rabitq-external-id-boundaries.md)
  • ADR declares no status (docs/adr/ADR-python-rabitq-unknown-delete.md)
  • ADR declares no status (docs/adr/ADR-python-rabitq-vacuum-identities.md)
  • ADR declares no status (docs/adr/python-agentforce-collection-capacity.md)
  • ADR declares no status (docs/adr/python-mcp-existing-index-preservation.md)
  • ADR declares no status (docs/adr/python-mcp-sidecar-discovery.md)
  • ADR declares no status (docs/adr/python-salesforce-pagination-completeness.md)
  • ADR declares no status (docs/adr/rvlite-browser-writer-lease-transactions.md)
  • ADR still proposed, but the code already adopted it (docs/adr/ADR-150-pi-brain-ruvltra-tailscale.md)
  • ADR still proposed, but the code already adopted it (docs/adr/ADR-156-rulake-as-memory-substrate.md)
  • ADR still proposed, but the code already adopted it (docs/adr/ADR-264-matryoshka-coarse-fine-search.md)
  • ADR still proposed, but the code already adopted it (docs/adr/ADR-264-pq-adc-search.md)
  • ADR still proposed, but the code already adopted it (docs/adr/ADR-272-speculative-ann-search.md)
  • ADR still proposed, but the code already adopted it (docs/adr/ADR-330-cama-pattern-correlation-aware-memory-arbitration.md)
  • ADR still proposed, but the code already adopted it (docs/adr/ADR-331-pandora-pattern-voi-cost-aware-routing.md)
  • ADR still proposed, but the code already adopted it (docs/adr/ADR-334-scope-sharded-context-index.md)
  • …and 2695 more

Changes since last survey

  • 300 commits — 204 feature/other, 96 fixes

By area

  • (repo) — 84 commits
  • npm/core — 79 commits
  • npm/packages — 38 commits
  • crates/ruvector-py — 21 commits
  • .github/workflows — 16 commits
  • crates/rvf — 14 commits
  • (root) — 7 commits
  • crates/ruvector-attention-node — 4 commits
  • crates/ruvector-core — 4 commits
  • crates/ruvector-postgres — 4 commits
  • assets/ruvector — 3 commits
  • crates/ruvector-graph — 3 commits
  • crates/ruvector-mincut — 3 commits
  • crates/ruvector-gnn — 2 commits
  • crates/ruvllm — 2 commits
  • crates/sona — 2 commits
  • crates/ruvector-edge-auth — 1 commit
  • crates/ruvector-edge-registry — 1 commit
  • crates/ruvector-graph-transformer-node — 1 commit
  • crates/ruvector-graph-transformer-wasm — 1 commit

Notable commits

  • fix: Fix CI for PR #1278: rustfmt the rvf-runtime changes and update root Cargo.lock for sha2-asm (aarch64)
  • fix: Merge main into fix/1063 (resolve test-module, docs and typings conflicts)
  • fix: Merge origin/main into fix/ruvector-0.3.20-hooks-attention
  • fix: Merge origin/main into fix/ruvector-status-20261011
  • fix: Merge pull request #1115 from ruvnet/fix/postgres-docker-publish
  • fix: Merge pull request #1180 from ruvnet/fix/ruvector-status-20261011
  • fix: Merge pull request #1253 from ruvnet/fix/security-nested-consumers-20261023
  • fix: Merge pull request #1433 from ruvnet/fix/rvforge-consolidated
  • fix: Merge pull request #1435 from rudycelekli/fix/core-graph-consolidated
  • fix: Merge pull request #1437 from rudycelekli/fix/python-sdk-consolidated
  • fix: Merge pull request #1439 from ruvnet/fix/rvf-store-metric-batch-quarantine
  • fix: Merge pull request #1443 from ruvnet/fix/retrieval-correctness-nostd
  • fix: Merge pull request #1444 from ruvnet/fix/rvf-derivation-lineage-1289-1290
  • fix: Merge pull request #1445 from ruvnet/fix/ruvector-0.3.20-hooks-attention
  • fix: Merge pull request #1447 from ruvnet/fix/ruvllm-reasoning-bank-test-lock
  • fix: Merge pull request #1449 from ruvnet/fix/edge-registry-accept-lineage-seg
  • fix: Merge pull request #1451 from ruvnet/fix/edge-p256-014
  • fix: Merge pull request #1457 from ruvnet/sail/weaver-fix-reachable
  • fix: Merge pull request #1468 from ruvnet/sail/add-extras-test-fix
  • fix: Merge pull request #1479 from ruvnet/fix/onnx-embeddings-wasm-esm-cjs
  • …and 280 more

Architecture

  • Unchanged — 0 containers · 7 contexts · 0 edges

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

Survey your own repository

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.

About this page

  • The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 979c31acc57b970c1a7e0771ed527c1703c137e8 — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-3c33c1882dc1.