docs(research): rvagent Hermes-class harness architecture (metaharness + ruflo integration)

crates/ruvector-core/Cargo.toml

@@ -317,3 +317,7 @@ overly_complex_bool_expr = { level = "allow", priority = 1 }
 zombie_processes = { level = "allow", priority = 1 }
 repeat_vec_with_capacity = { level = "allow", priority = 1 }
 missing_transmute_annotations = { level = "allow", priority = 1 }
+
+[[bench]]
+name = "pdx_vs_rowmajor"
+harness = false

crates/ruvector-core/benches/pdx_vs_rowmajor.rs

@@ -0,0 +1,59 @@
+//! Row-major batch distance vs PDX vertical layout (ADR-279 §5.1).
+//!
+//! Both compute the same thing over the same data. The only difference is
+//! memory layout and whether a horizontal reduction happens per vector.
+
+use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+use ruvector_core::pdx::PdxIndex;
+use ruvector_core::simd_intrinsics::batch_euclidean;
+
+fn corpus(n: usize, dim: usize) -> Vec<Vec<f32>> {
+    (0..n)
+        .map(|i| {
+            (0..dim)
+                .map(|d| ((i * 31 + d * 17) % 101) as f32 / 101.0)
+                .collect()
+        })
+        .collect()
+}
+
+fn bench(c: &mut Criterion) {
+    // 1536 is the OpenAI embedding width; 768 covers most sentence encoders.
+    // (n, dim) pairs: the first three are cache-resident, the rest stream.
+    for (n, dim) in [
+        (256usize, 768usize),
+        (512, 768),
+        (1024, 768),
+        (4096, 768),
+        (4096, 1536),
+    ] {
+        let vecs = corpus(n, dim);
+        let refs: Vec<&[f32]> = vecs.iter().map(|v| v.as_slice()).collect();
+        let query: Vec<f32> = (0..dim).map(|d| (d % 7) as f32 / 7.0).collect();
+
+        let index = PdxIndex::from_rows(&refs);
+        let mut out = vec![0.0f32; n];
+
+        let mut group = c.benchmark_group(format!("batch_euclidean_{n}x{dim}"));
+        // Bytes of vector data scanned per query — makes the two comparable
+        // in bandwidth terms rather than just wall time.
+        group.throughput(Throughput::Bytes((n * dim * 4) as u64));
+
+        group.bench_function(BenchmarkId::new("row_major", dim), |b| {
+            b.iter(|| {
+                batch_euclidean(black_box(&query), black_box(&refs), black_box(&mut out));
+            })
+        });
+
+        group.bench_function(BenchmarkId::new("pdx_vertical", dim), |b| {
+            b.iter(|| {
+                index.euclidean_sq_into(black_box(&query), black_box(&mut out));
+            })
+        });
+
+        group.finish();
+    }
+}
+
+criterion_group!(benches, bench);
+criterion_main!(benches);

crates/ruvector-core/src/lib.rs

@@ -39,6 +39,7 @@ pub mod distance;
 pub mod embeddings;
 pub mod error;
 pub mod index;
+pub mod pdx;
 pub mod quantization;
 
 // Storage backends - conditional compilation based on features