diff --git a/crates/ruvector-agent-memory/Cargo.toml b/crates/ruvector-agent-memory/Cargo.toml index cfb8136029..2c61442cbd 100644 --- a/crates/ruvector-agent-memory/Cargo.toml +++ b/crates/ruvector-agent-memory/Cargo.toml @@ -51,5 +51,15 @@ name = "mincut_scaling_probe" path = "examples/mincut_scaling_probe.rs" required-features = ["mincut-forget"] +# ADR-346 (nightly 2026-09-12, follow-up to ADR-345): benchmarks the +# `MincutEngine::LocalDeterministic` boundary-detection engine (deterministic +# local k-cut, one query per vertex) against the original `ExactGlobal` +# engine (global partition, ADR-345) on latency, determinism, and structural +# effectiveness. +[[example]] +name = "mincut_local_forgetting_bench" +path = "examples/mincut_local_forgetting_bench.rs" +required-features = ["mincut-forget"] + [dev-dependencies] serde_json = { workspace = true } diff --git a/crates/ruvector-agent-memory/examples/mincut_local_forgetting_bench.rs b/crates/ruvector-agent-memory/examples/mincut_local_forgetting_bench.rs new file mode 100644 index 0000000000..e9e19ba089 --- /dev/null +++ b/crates/ruvector-agent-memory/examples/mincut_local_forgetting_bench.rs @@ -0,0 +1,566 @@ +//! Nightly research benchmark (2026-09-12, ADR-346, follow-up to ADR-345): +//! does replacing `RuVectorGraphAnalyzer::partition()` (one expensive, +//! measured-non-deterministic *global* min-cut call per compaction) with +//! `DeterministicLocalKCut` (`n` cheap, provably deterministic *local* +//! k-cut queries, one per vertex) fix the 2026-09-05 rejection's two root +//! causes — latency and non-determinism — while keeping the structural +//! "protect the bridge" benefit? +//! +//! Hypothesis (fixed before this run; see +//! docs/research/nightly/2026-09-12-local-kcut-gated-forgetting/README.md): +//! +//! Given the same synthetic corpus as the 2026-09-05 experiment (6 topic +//! clusters x 12 core memories + 12 bridge memories interpolated 50/50 +//! between two random clusters, 32-dim, k-NN k=5 cosine >= 0.05, hot-cluster +//! access simulation over 20 test queries) compacted 50% by +//! `MincutGatedForgetting` in `MincutEngine::LocalDeterministic` mode +//! (`max_radius=0`, `budget_k=4` — see `graph_forget.rs`'s "Design note" doc +//! comment on `boundary_indices_local` for why `max_radius=0`, decided +//! during design, before this run) versus the same policy in the original +//! `MincutEngine::ExactGlobal` mode and versus plain `CoherencePolicy`, +//! +//! when corpus size is scaled from 84 up to 924 vertices (same cluster/ +//! bridge ratio), +//! +//! then (a) `LocalDeterministic` retains the same >=15pp bridge-survival +//! gap over baseline and <=2pp recall delta `ExactGlobal` was required to +//! hit at 84 vertices; (b) `LocalDeterministic`'s wall-clock slowdown vs +//! baseline, at the largest size where `ExactGlobal` still completes a call +//! within a 1.5s budget, is at least 5x smaller than `ExactGlobal`'s at that +//! same size, and stays under 20x in absolute terms; and (c) +//! `LocalDeterministic` returns byte-identical survivor sets across 20 +//! repeated `compact()` calls on unchanged input, +//! +//! subject to: 100% tamper-detection across 20 independent single-byte-flip +//! trials against the eviction witness chain, using `LocalDeterministic` +//! (closing the loop on whether the follow-up engine is still compatible +//! with the existing ADR-134 witness machinery). +//! +//! Run: +//! cargo run --release -p ruvector-agent-memory --example mincut_local_forgetting_bench --features mincut-forget + +use rand::rngs::StdRng; +use rand::{Rng, SeedableRng}; +use ruvector_agent_memory::{ + compact, compact_witnessed, recall_at_k, CoherencePolicy, CoherenceWeights, CompactionPolicy, + EvictionWitnessChain, MemoryStore, MemoryWitnessLog, MincutGatedForgetting, +}; +use std::collections::HashSet; +use std::time::{Duration, Instant}; + +// ── Fixed hypothesis-size dataset (same shape as ADR-345's 84-memory run) ── +const N_CLUSTERS: usize = 6; +const PER_CLUSTER: usize = 12; +const N_BRIDGES: usize = 12; +const N_HOT_CLUSTERS: usize = 2; +const DIMS: usize = 32; +const N_QUERIES: usize = 20; +const K: usize = 5; +const CONTEXT_WINDOW_SIZE: usize = 10; +const N_COLD_ERA_ACCESSES: usize = 40; +const N_HOT_ERA_ACCESSES: usize = 80; +const HOT_ERA_HOT_FRAC: f64 = 0.90; + +const STRUCTURAL_BONUS: f32 = 0.5; +const PROTECT_FRACTION: f32 = 0.2; +const BRIDGE_SURVIVAL_GAP_THRESHOLD_PP: f32 = 15.0; +const RECALL_TOLERANCE: f32 = 0.02; +const N_TAMPER_TRIALS: usize = 20; +const N_DETERMINISM_TRIALS: usize = 20; + +// Pre-declared acceptance bars for the scaling claim (see module doc): +// LocalDeterministic must be materially faster than ExactGlobal at the +// largest tested size, AND stay within a much tighter absolute bound than +// ExactGlobal's already-violated 100x bar. +const MIN_SPEEDUP_LOCAL_VS_EXACT_AT_MAX_SIZE: f64 = 5.0; +const MAX_LOCAL_SLOWDOWN_VS_BASELINE_AT_MAX_SIZE: f64 = 20.0; +// ExactGlobal scaling sizes stop growing once a single call exceeds this — +// avoids repeating ADR-345's multi-second-per-call blowup for every size. +const EXACT_SCALING_BUDGET: Duration = Duration::from_millis(1500); + +// ── Vector utilities (mirrors mincut_gated_forgetting_bench.rs) ──────────── + +fn unit_gaussian(rng: &mut StdRng, dim: usize) -> Vec { + let v: Vec = (0..dim).map(|_| rng.gen::() * 2.0 - 1.0).collect(); + let norm: f32 = v.iter().map(|x| x * x).sum::().sqrt().max(1e-9); + v.into_iter().map(|x| x / norm).collect() +} + +fn add_vecs(a: &[f32], b: &[f32]) -> Vec { + a.iter().zip(b.iter()).map(|(x, y)| x + y).collect() +} + +fn scale_vec(v: &[f32], s: f32) -> Vec { + v.iter().map(|x| x * s).collect() +} + +fn normalize_vec(v: &[f32]) -> Vec { + let n: f32 = v.iter().map(|x| x * x).sum::().sqrt().max(1e-9); + v.iter().map(|x| x / n).collect() +} + +fn perturb(centroid: &[f32], noise: f32, rng: &mut StdRng) -> Vec { + let n = unit_gaussian(rng, centroid.len()); + normalize_vec(&add_vecs(centroid, &scale_vec(&n, noise))) +} + +fn midpoint(a: &[f32], b: &[f32]) -> Vec { + normalize_vec(&add_vecs(a, b)) +} + +// ── Parametric dataset (generalizes ADR-345's fixed 84-memory generator so +// the scaling probe below can reuse the exact same topology) ─────────── + +struct Dataset { + centroids: Vec>, + cluster_of: Vec, + bridge_indices: HashSet, + queries: Vec<(Vec, Vec)>, +} + +struct Shape { + n_clusters: usize, + per_cluster: usize, + n_bridges: usize, +} + +impl Shape { + fn n_memories(&self) -> usize { + self.n_clusters * self.per_cluster + self.n_bridges + } +} + +fn generate_dataset(store: &mut MemoryStore, shape: &Shape, rng: &mut StdRng) -> Dataset { + let centroids: Vec> = (0..shape.n_clusters) + .map(|_| unit_gaussian(rng, DIMS)) + .collect(); + let mut cluster_of = Vec::with_capacity(shape.n_memories()); + + for (c, centroid) in centroids.iter().enumerate() { + for _ in 0..shape.per_cluster { + let v = perturb(centroid, 0.35, rng); + store.insert(v); + cluster_of.push(c); + } + } + + let mut bridge_indices = HashSet::new(); + for _ in 0..shape.n_bridges { + let a = rng.gen_range(0..shape.n_clusters); + let mut b = rng.gen_range(0..shape.n_clusters); + while b == a { + b = rng.gen_range(0..shape.n_clusters); + } + let mid = midpoint(¢roids[a], ¢roids[b]); + let v = perturb(&mid, 0.15, rng); + let idx = store.len(); + store.insert(v); + bridge_indices.insert(idx); + cluster_of.push(usize::MAX); + } + + let mut queries = Vec::with_capacity(N_QUERIES); + for i in 0..N_QUERIES { + let hot_cluster = i % N_HOT_CLUSTERS.min(shape.n_clusters).max(1); + let q = perturb(¢roids[hot_cluster], 0.30, rng); + let truth: Vec = store.search(&q, K).into_iter().map(|r| r.id).collect(); + queries.push((q, truth)); + } + + Dataset { + centroids, + cluster_of, + bridge_indices, + queries, + } +} + +fn simulate_accesses( + store: &mut MemoryStore, + shape: &Shape, + dataset: &Dataset, + rng: &mut StdRng, +) -> Vec> { + let n = shape.n_memories(); + for _ in 0..N_COLD_ERA_ACCESSES { + let idx = rng.gen_range(0..n); + store.access_by_index(idx); + } + + let hot_clusters = N_HOT_CLUSTERS.min(shape.n_clusters).max(1); + let mut context_accesses: Vec> = Vec::new(); + for _ in 0..N_HOT_ERA_ACCESSES { + let idx = if rng.gen_bool(HOT_ERA_HOT_FRAC) { + let hot_c = rng.gen_range(0..hot_clusters); + hot_c * shape.per_cluster + rng.gen_range(0..shape.per_cluster) + } else { + let cold_c = rng.gen_range(hot_clusters..shape.n_clusters.max(hot_clusters + 1)) + % shape.n_clusters; + cold_c * shape.per_cluster + rng.gen_range(0..shape.per_cluster) + }; + store.access_by_index(idx); + let cluster = dataset.cluster_of[idx]; + if cluster != usize::MAX { + context_accesses.push(dataset.centroids[cluster].clone()); + } + } + + let start = context_accesses.len().saturating_sub(CONTEXT_WINDOW_SIZE); + context_accesses[start..].to_vec() +} + +fn measure_recall(queries: &[(Vec, Vec)], store: &MemoryStore) -> f32 { + let mut total = 0.0f32; + for (q, truth) in queries { + let candidates: Vec = store.search(q, K).into_iter().map(|r| r.id).collect(); + total += recall_at_k(truth, &candidates); + } + total / queries.len() as f32 +} + +/// Rebuilds a fresh, identically-seeded store+dataset for `shape`, runs one +/// compaction policy, and reports (bridge survival rate, recall, wall-clock). +fn run_policy(policy: &dyn CompactionPolicy, shape: &Shape, seed: u64) -> (f32, f32, Duration) { + let mut rng = StdRng::seed_from_u64(seed); + let mut store = MemoryStore::new(DIMS); + let dataset = generate_dataset(&mut store, shape, &mut rng); + let mut rng2 = StdRng::seed_from_u64(seed + 1); + let context_window = simulate_accesses(&mut store, shape, &dataset, &mut rng2); + assert_eq!(store.len(), shape.n_memories()); + + let bridge_ids: HashSet = dataset + .bridge_indices + .iter() + .map(|&i| store.entries()[i].id) + .collect(); + + let target_size = shape.n_memories() / 2; + let t0 = Instant::now(); + compact(&mut store, policy, target_size, &context_window); + let elapsed = t0.elapsed(); + + assert_eq!(store.len(), target_size); + let surviving_bridges = store + .entries() + .iter() + .filter(|e| bridge_ids.contains(&e.id)) + .count(); + let survival_rate = surviving_bridges as f32 / bridge_ids.len().max(1) as f32; + let recall = measure_recall(&dataset.queries, &store); + (survival_rate, recall, elapsed) +} + +/// Runs `compact()` with `policy` `trials` times on freshly rebuilt, +/// identically-seeded input and returns how many trials produced a survivor +/// *id set* identical to the first trial's — the same non-determinism probe +/// ADR-345 used, now run head-to-head for both engines. +fn determinism_trials( + policy: &dyn CompactionPolicy, + shape: &Shape, + seed: u64, + trials: usize, +) -> usize { + let mut reference: Option> = None; + let mut identical = 0usize; + for t in 0..trials { + let mut rng = StdRng::seed_from_u64(seed); + let mut store = MemoryStore::new(DIMS); + let dataset = generate_dataset(&mut store, shape, &mut rng); + let mut rng2 = StdRng::seed_from_u64(seed + 1); + let context_window = simulate_accesses(&mut store, shape, &dataset, &mut rng2); + let target_size = shape.n_memories() / 2; + compact(&mut store, policy, target_size, &context_window); + let ids: HashSet = store.entries().iter().map(|e| e.id).collect(); + match &reference { + None => { + reference = Some(ids); + identical += 1; + } + Some(r) => { + if *r == ids { + identical += 1; + } + } + } + let _ = t; + } + identical +} + +fn run_tamper_trials(seed: u64) -> (usize, usize) { + let shape = Shape { + n_clusters: N_CLUSTERS, + per_cluster: PER_CLUSTER, + n_bridges: N_BRIDGES, + }; + let mut detected = 0usize; + for trial in 0..N_TAMPER_TRIALS { + let mut rng = StdRng::seed_from_u64(seed + trial as u64); + let mut store = MemoryStore::new(DIMS); + let dataset = generate_dataset(&mut store, &shape, &mut rng); + let mut rng2 = StdRng::seed_from_u64(seed + trial as u64 + 1); + let context_window = simulate_accesses(&mut store, &shape, &dataset, &mut rng2); + + let policy = + MincutGatedForgetting::soft_local(CoherenceWeights::default(), STRUCTURAL_BONUS); + let mut chain = EvictionWitnessChain::new(); + let mut log = MemoryWitnessLog::default(); + compact_witnessed( + &mut store, + &policy, + shape.n_memories() / 2, + &context_window, + "nightly-bench-local", + trial as u64, + &mut chain, + &mut log, + ) + .expect("witnessed compaction succeeds"); + + assert!(log.verify_chain(), "freshly emitted chain must verify"); + + let n = log.records.len(); + let victim = rng.gen_range(0..n); + match rng.gen_range(0..3) { + 0 => log.records[victim].payload ^= 1 << rng.gen_range(0..64), + 1 => log.records[victim].target_object_id ^= 1 << rng.gen_range(0..32), + _ => log.records[victim].timestamp_ns ^= 1 << rng.gen_range(0..64), + } + + if !log.verify_chain() { + detected += 1; + } + } + (detected, N_TAMPER_TRIALS) +} + +fn main() { + let seed: u64 = 346; + println!("╔══════════════════════════════════════════════════════════════════╗"); + println!("║ ruvector-agent-memory — LocalDeterministic Mincut Forgetting ║"); + println!("║ (ADR-346, follow-up to ADR-345) ║"); + println!("╚══════════════════════════════════════════════════════════════════╝\n"); + println!("Platform : {}", std::env::consts::OS); + println!("Arch : {}", std::env::consts::ARCH); + println!(); + + let base_shape = Shape { + n_clusters: N_CLUSTERS, + per_cluster: PER_CLUSTER, + n_bridges: N_BRIDGES, + }; + println!( + "Section A — hypothesis-size corpus ({} memories, same shape as ADR-345)", + base_shape.n_memories() + ); + println!( + " Clusters={N_CLUSTERS} per_cluster={PER_CLUSTER} bridges={N_BRIDGES} dims={DIMS} target=50%" + ); + println!(); + + let cow = CoherencePolicy::default(); + let soft_exact = MincutGatedForgetting::soft(CoherenceWeights::default(), STRUCTURAL_BONUS); + let hard_exact = MincutGatedForgetting::hard(CoherenceWeights::default(), PROTECT_FRACTION); + let soft_local = + MincutGatedForgetting::soft_local(CoherenceWeights::default(), STRUCTURAL_BONUS); + let hard_local = + MincutGatedForgetting::hard_local(CoherenceWeights::default(), PROTECT_FRACTION); + + struct Row { + name: String, + survival: f32, + recall: f32, + micros: u128, + } + let mut rows = Vec::new(); + for policy in [ + &cow as &dyn CompactionPolicy, + &soft_exact, + &hard_exact, + &soft_local, + &hard_local, + ] { + let (survival, recall, dur) = run_policy(policy, &base_shape, seed); + rows.push(Row { + name: policy.name().to_string(), + survival, + recall, + micros: dur.as_micros(), + }); + } + // soft_local/hard_local share `name()` with soft_exact/hard_exact + // (`CompactionPolicy::name` only encodes Soft/Hard, not engine) — relabel + // for the table by position instead of relying on `name()` alone. + rows[3].name = format!("{}-Local", rows[3].name); + rows[4].name = format!("{}-Local", rows[4].name); + rows[1].name = format!("{}-Exact", rows[1].name); + rows[2].name = format!("{}-Exact", rows[2].name); + + println!( + "{:<28} {:>16} {:>12} {:>16}", + "Policy", "Bridge Surv.", "Recall@10", "Compaction (us)" + ); + println!("{}", "-".repeat(76)); + for r in &rows { + println!( + "{:<28} {:>15.1}% {:>11.1}% {:>16}", + r.name, + r.survival * 100.0, + r.recall * 100.0, + r.micros + ); + } + println!(); + + let baseline = &rows[0]; + let soft_exact_row = &rows[1]; + let hard_exact_row = &rows[2]; + let soft_local_row = &rows[3]; + let hard_local_row = &rows[4]; + + println!("Section B — determinism ({N_DETERMINISM_TRIALS} repeated compact() calls on unchanged input)"); + let det_exact = determinism_trials(&soft_exact, &base_shape, seed + 500, N_DETERMINISM_TRIALS); + let det_local = determinism_trials(&soft_local, &base_shape, seed + 500, N_DETERMINISM_TRIALS); + println!(" Soft-Exact identical survivor sets : {det_exact}/{N_DETERMINISM_TRIALS}"); + println!(" Soft-Local identical survivor sets : {det_local}/{N_DETERMINISM_TRIALS}"); + println!(); + + println!("Section C — scaling probe (Soft-Exact vs Soft-Local compact() wall-clock)"); + println!( + "{:>8} {:>16} {:>16} {:>16}", + "n", "Baseline (us)", "Exact (us)", "Local (us)" + ); + let scale_multipliers = [1usize, 2, 3, 5, 7, 11]; // -> 84, 168, 252, 420, 588, 924 + let mut exact_budget_exceeded = false; + let mut scaling_rows: Vec<(usize, u128, Option, u128)> = Vec::new(); + for &m in &scale_multipliers { + let shape = Shape { + n_clusters: N_CLUSTERS, + per_cluster: PER_CLUSTER * m, + n_bridges: N_BRIDGES * m, + }; + let (_, _, base_dur) = run_policy(&cow, &shape, seed + 900 + m as u64); + let exact_dur = if exact_budget_exceeded { + None + } else { + let (_, _, d) = run_policy(&soft_exact, &shape, seed + 900 + m as u64); + if d > EXACT_SCALING_BUDGET { + exact_budget_exceeded = true; + } + Some(d.as_micros()) + }; + let (_, _, local_dur) = run_policy(&soft_local, &shape, seed + 900 + m as u64); + println!( + "{:>8} {:>16} {:>16} {:>16}", + shape.n_memories(), + base_dur.as_micros(), + exact_dur + .map(|v| v.to_string()) + .unwrap_or_else(|| "skipped(budget)".to_string()), + local_dur.as_micros() + ); + scaling_rows.push(( + shape.n_memories(), + base_dur.as_micros(), + exact_dur, + local_dur.as_micros(), + )); + } + println!(); + + println!("Tamper-detection trials (eviction witness chain, Soft-Local engine)"); + let (detected, total) = run_tamper_trials(seed + 1_000); + println!(" Detected {detected}/{total} single-byte-flip tampers\n"); + + println!("Acceptance test"); + let survival_gap_local_soft = (soft_local_row.survival - baseline.survival) * 100.0; + let survival_gap_local_hard = (hard_local_row.survival - baseline.survival) * 100.0; + let soft_gap_pass = survival_gap_local_soft >= BRIDGE_SURVIVAL_GAP_THRESHOLD_PP; + let hard_gap_pass = survival_gap_local_hard >= BRIDGE_SURVIVAL_GAP_THRESHOLD_PP; + println!( + " (a) Soft-Local bridge-survival gap ({survival_gap_local_soft:+.1}pp) >= {BRIDGE_SURVIVAL_GAP_THRESHOLD_PP:.0}pp : {}", + if soft_gap_pass { "PASS" } else { "FAIL" } + ); + println!( + " (a) Hard-Local bridge-survival gap ({survival_gap_local_hard:+.1}pp) >= {BRIDGE_SURVIVAL_GAP_THRESHOLD_PP:.0}pp : {}", + if hard_gap_pass { "PASS" } else { "FAIL" } + ); + + let recall_delta_soft = (soft_local_row.recall - baseline.recall).abs(); + let recall_delta_hard = (hard_local_row.recall - baseline.recall).abs(); + let soft_recall_pass = recall_delta_soft <= RECALL_TOLERANCE; + let hard_recall_pass = recall_delta_hard <= RECALL_TOLERANCE; + println!( + " (a) Soft-Local |recall delta| ({:.2}pp) <= {:.0}pp : {}", + recall_delta_soft * 100.0, + RECALL_TOLERANCE * 100.0, + if soft_recall_pass { "PASS" } else { "FAIL" } + ); + println!( + " (a) Hard-Local |recall delta| ({:.2}pp) <= {:.0}pp : {}", + recall_delta_hard * 100.0, + RECALL_TOLERANCE * 100.0, + if hard_recall_pass { "PASS" } else { "FAIL" } + ); + + // (b) scaling claim, evaluated at the largest size Exact actually + // completed within budget (falls back to the largest tested size if + // Exact never exceeded budget). + let last_with_exact = scaling_rows + .iter() + .rev() + .find(|(_, _, exact, _)| exact.is_some()) + .cloned() + .unwrap_or(scaling_rows[0]); + let (max_n, base_us, exact_us_opt, local_us) = last_with_exact; + let exact_us = exact_us_opt.unwrap_or(local_us.max(1)); + let speedup_local_vs_exact = exact_us as f64 / local_us.max(1) as f64; + let local_slowdown_vs_baseline = local_us as f64 / base_us.max(1) as f64; + let speedup_pass = speedup_local_vs_exact >= MIN_SPEEDUP_LOCAL_VS_EXACT_AT_MAX_SIZE; + let slowdown_pass = local_slowdown_vs_baseline <= MAX_LOCAL_SLOWDOWN_VS_BASELINE_AT_MAX_SIZE; + println!( + " (b) @n={max_n}: Local vs Exact speedup ({speedup_local_vs_exact:.1}x) >= {MIN_SPEEDUP_LOCAL_VS_EXACT_AT_MAX_SIZE:.0}x : {}", + if speedup_pass { "PASS" } else { "FAIL" } + ); + println!( + " (b) @n={max_n}: Local vs baseline slowdown ({local_slowdown_vs_baseline:.1}x) <= {MAX_LOCAL_SLOWDOWN_VS_BASELINE_AT_MAX_SIZE:.0}x : {}", + if slowdown_pass { "PASS" } else { "FAIL" } + ); + + let determinism_pass = det_local == N_DETERMINISM_TRIALS; + println!( + " (c) Soft-Local determinism ({det_local}/{N_DETERMINISM_TRIALS} identical) : {}", + if determinism_pass { "PASS" } else { "FAIL" } + ); + println!( + " (reference — Soft-Exact determinism: {det_exact}/{N_DETERMINISM_TRIALS} identical, not gated on)" + ); + + let tamper_pass = detected == total; + println!( + " Tamper detection ({detected}/{total}) : {}", + if tamper_pass { "PASS" } else { "FAIL" } + ); + println!(); + + // Kept out of `all_pass`: informational context, not part of the + // pre-declared hypothesis (mirrors ADR-345's own convention of reporting + // non-gating context alongside the gated acceptance test). + let _ = (soft_exact_row, hard_exact_row); + + let all_pass = soft_gap_pass + && hard_gap_pass + && soft_recall_pass + && hard_recall_pass + && speedup_pass + && slowdown_pass + && determinism_pass + && tamper_pass; + + if all_pass { + println!("=> ACCEPT: LocalDeterministic keeps the structural bridge-protection benefit while fixing both the latency and determinism defects found in ADR-345's ExactGlobal engine."); + } else { + println!("=> REJECT: one or more mandatory acceptance thresholds failed (see above)."); + std::process::exit(1); + } +} diff --git a/crates/ruvector-agent-memory/src/graph_forget.rs b/crates/ruvector-agent-memory/src/graph_forget.rs index 0d8afe6244..84d50ec57d 100644 --- a/crates/ruvector-agent-memory/src/graph_forget.rs +++ b/crates/ruvector-agent-memory/src/graph_forget.rs @@ -28,11 +28,32 @@ //! small (`< 4` entries) or the similarity graph has no crossing edges (e.g. //! it is already disconnected, or every pair is above/below threshold //! uniformly) — there is no boundary signal to add in that case. +//! +//! # Nightly follow-up (2026-09-12, ADR-346): the `LocalDeterministic` engine +//! +//! The original (2026-09-05) engine above — [`MincutEngine::ExactGlobal`], +//! backed by [`ruvector_mincut::RuVectorGraphAnalyzer::partition()`] — was +//! measured to be both too slow (76ms-11.4s per call at 50-400 vertices) and +//! non-deterministic across repeated calls on byte-identical input (see the +//! "Measured limitation" doc on [`MincutGatedForgetting::boundary_indices`] +//! and `docs/research/nightly/2026-09-05-mincut-gated-forgetting/`). This +//! module now also offers [`MincutEngine::LocalDeterministic`], which +//! attacks that exact bottleneck by replacing the single expensive *global* +//! min-cut call with `n` cheap, provably-deterministic *local* k-cut queries +//! (`ruvector_mincut::localkcut::DeterministicLocalKCut`, from the paper +//! "Deterministic and Exact Fully-dynamic Minimum Cut of Superpolylogarithmic +//! Size") — one bounded-radius, bounded-budget BFS per vertex, with no +//! hash-map-iteration-order tie-breaking anywhere in the call path. See +//! `docs/research/nightly/2026-09-12-local-kcut-gated-forgetting/README.md` +//! for the falsifiable hypothesis and measured results of this follow-up. use crate::compaction::{weighted_importance, CoherenceWeights, CompactionPolicy}; use crate::memory::MemoryEntry; use crate::scoring::cosine_sim; -use ruvector_mincut::RuVectorGraphAnalyzer; +use ruvector_mincut::{ + DeterministicLocalKCut, DynamicGraph, LocalKCutOracle, LocalKCutQuery, + PaperLocalKCutResult as LocalKCutResult, RuVectorGraphAnalyzer, +}; use std::collections::HashSet; /// How the mincut-boundary structural signal is combined with the scalar @@ -46,12 +67,34 @@ pub enum ForgetMode { Hard, } +/// Which `ruvector-mincut` primitive computes the structural boundary +/// signal. See the module-level "Nightly follow-up" doc for why there are +/// two. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum MincutEngine { + /// Original engine (ADR-345, 2026-09-05): one global exact min-cut via + /// [`RuVectorGraphAnalyzer::partition()`] per compaction. Measured + /// 76ms-11.4s per call at 50-400 vertices and non-deterministic across + /// repeated calls on identical input; retained only for comparison. + ExactGlobal, + /// Follow-up engine (ADR-346, 2026-09-12): one + /// [`ruvector_mincut::localkcut::DeterministicLocalKCut`] query per + /// vertex, each a bounded-radius BFS with no randomization and no + /// hash-map-iteration-order dependence. `max_radius` caps BFS depth; + /// `budget_k` is the maximum boundary-edge count a local region may have + /// to count as a structural cut. + LocalDeterministic { max_radius: usize, budget_k: u64 }, +} + /// Mincut-gated forgetting compaction policy (candidates A/B of the nightly -/// 2026-09-05 experiment). +/// 2026-09-05 experiment, plus the `LocalDeterministic` engine added +/// 2026-09-12). #[derive(Debug, Clone)] pub struct MincutGatedForgetting { pub weights: CoherenceWeights, pub mode: ForgetMode, + /// Which `ruvector-mincut` primitive supplies the boundary signal. + pub engine: MincutEngine, /// Max neighbors per vertex when building the similarity graph. pub k_neighbors: usize, /// Minimum cosine similarity for an edge to be added. @@ -62,19 +105,23 @@ pub struct MincutGatedForgetting { /// [`ForgetMode::Hard`] only: fraction of `target_size` reserved for /// boundary vertices. pub protect_fraction: f32, - /// Number of times to recompute the min-cut partition on an unchanged - /// graph, unioning the boundary vertices found each time (see the - /// "Measured limitation" note on [`Self::boundary_indices`]). `1` - /// disables retrying. + /// [`MincutEngine::ExactGlobal`] only: number of times to recompute the + /// min-cut partition on an unchanged graph, unioning the boundary + /// vertices found each time (see the "Measured limitation" note on + /// [`Self::boundary_indices_exact`]). `1` disables retrying. Ignored by + /// [`MincutEngine::LocalDeterministic`], which needs no retries because + /// it is deterministic by construction. pub mincut_trials: usize, } impl MincutGatedForgetting { - /// [`ForgetMode::Soft`] with the given weights and bonus. + /// [`ForgetMode::Soft`] with the given weights and bonus, using the + /// original [`MincutEngine::ExactGlobal`] engine. pub fn soft(weights: CoherenceWeights, structural_bonus: f32) -> Self { Self { weights, mode: ForgetMode::Soft, + engine: MincutEngine::ExactGlobal, k_neighbors: 8, min_similarity: 0.05, structural_bonus, @@ -83,11 +130,13 @@ impl MincutGatedForgetting { } } - /// [`ForgetMode::Hard`] with the given weights and protected fraction. + /// [`ForgetMode::Hard`] with the given weights and protected fraction, + /// using the original [`MincutEngine::ExactGlobal`] engine. pub fn hard(weights: CoherenceWeights, protect_fraction: f32) -> Self { Self { weights, mode: ForgetMode::Hard, + engine: MincutEngine::ExactGlobal, k_neighbors: 8, min_similarity: 0.05, structural_bonus: 0.0, @@ -96,12 +145,82 @@ impl MincutGatedForgetting { } } - /// Build a k-NN cosine-similarity graph and return the indices (into - /// `entries`) of vertices with at least one neighbor edge crossing the - /// graph's global min-cut partition. - /// - /// Returns an empty set when there is no usable structural signal: fewer - /// than 4 entries, or no edges survive `min_similarity`. + /// [`ForgetMode::Soft`] using the follow-up + /// [`MincutEngine::LocalDeterministic`] engine (ADR-346, 2026-09-12). + pub fn soft_local(weights: CoherenceWeights, structural_bonus: f32) -> Self { + Self { + // max_radius=0: see the "Design note" on + // `boundary_indices_local` for why multi-hop search over-flags + // on tightly clustered synthetic data. + engine: MincutEngine::LocalDeterministic { + max_radius: 0, + budget_k: 4, + }, + ..Self::soft(weights, structural_bonus) + } + } + + /// [`ForgetMode::Hard`] using the follow-up + /// [`MincutEngine::LocalDeterministic`] engine (ADR-346, 2026-09-12). + pub fn hard_local(weights: CoherenceWeights, protect_fraction: f32) -> Self { + Self { + // max_radius=0: see the "Design note" on + // `boundary_indices_local` for why multi-hop search over-flags + // on tightly clustered synthetic data. + engine: MincutEngine::LocalDeterministic { + max_radius: 0, + budget_k: 4, + }, + ..Self::hard(weights, protect_fraction) + } + } + + /// Return the indices (into `entries`) of vertices flagged as + /// structurally load-bearing by `self.engine` — see + /// [`Self::boundary_indices_exact`] and [`Self::boundary_indices_local`] + /// for the two implementations. Returns an empty set when there is no + /// usable structural signal: fewer than 4 entries, or no edges survive + /// `min_similarity`. + fn boundary_indices(&self, entries: &[MemoryEntry]) -> HashSet { + match self.engine { + MincutEngine::ExactGlobal => self.boundary_indices_exact(entries), + MincutEngine::LocalDeterministic { + max_radius, + budget_k, + } => self.boundary_indices_local(entries, max_radius, budget_k), + } + } + + /// Build the same k-NN cosine-similarity neighbor list used by both + /// engines: for each vertex, its top-`k_neighbors` neighbors above + /// `min_similarity`, as `(neighbor_index, distance)` pairs (distance = + /// `1 - similarity`, floored so near-duplicates get heavy edges). + fn knn_neighbors(&self, entries: &[MemoryEntry]) -> Vec<(usize, Vec<(usize, f64)>)> { + let n = entries.len(); + let k = self.k_neighbors.max(1); + (0..n) + .map(|i| { + let mut sims: Vec<(usize, f32)> = (0..n) + .filter(|&j| j != i) + .map(|j| (j, cosine_sim(&entries[i].vector, &entries[j].vector))) + .filter(|&(_, s)| s >= self.min_similarity) + .collect(); + sims.sort_unstable_by(|a, b| b.1.partial_cmp(&a.1).unwrap()); + sims.truncate(k); + // Distance = 1 - similarity (floored) so near-duplicate pairs + // get heavy, cut-resistant edges under both engines. + let dists = sims + .into_iter() + .map(|(j, s)| (j, (1.0 - s).max(1e-4) as f64)) + .collect(); + (i, dists) + }) + .collect() + } + + /// [`MincutEngine::ExactGlobal`] boundary detection: see the type-level + /// doc on [`MincutEngine::ExactGlobal`] and the "Measured limitation" + /// note below for why [`MincutEngine::LocalDeterministic`] exists. /// /// # Measured limitation (nightly 2026-09-05 finding) /// @@ -126,8 +245,7 @@ impl MincutGatedForgetting { /// numbers above) and /// `docs/research/nightly/2026-09-05-mincut-gated-forgetting/README.md` /// ("Failure modes", which also covers latency scaling up to 400 - /// vertices). Filed as a follow-up hardening item against - /// `ruvector-mincut` rather than worked around there. + /// vertices). /// /// This method mitigates it locally by taking the union of boundary /// vertices found across [`Self::mincut_trials`] independent calls: a @@ -135,33 +253,11 @@ impl MincutGatedForgetting { /// minimum cut of the graph, so the union only adds true positives (never /// false ones) at the cost of also protecting bystander vertices caught /// by an alternate, equally-valid partition. - fn boundary_indices(&self, entries: &[MemoryEntry]) -> HashSet { - let n = entries.len(); - if n < 4 { + fn boundary_indices_exact(&self, entries: &[MemoryEntry]) -> HashSet { + if entries.len() < 4 { return HashSet::new(); } - - let k = self.k_neighbors.max(1); - let neighbors: Vec<(usize, Vec<(usize, f64)>)> = (0..n) - .map(|i| { - let mut sims: Vec<(usize, f32)> = (0..n) - .filter(|&j| j != i) - .map(|j| (j, cosine_sim(&entries[i].vector, &entries[j].vector))) - .filter(|&(_, s)| s >= self.min_similarity) - .collect(); - sims.sort_unstable_by(|a, b| b.1.partial_cmp(&a.1).unwrap()); - sims.truncate(k); - // `from_knn` treats the second tuple element as a *distance* - // (weight = 1/distance): invert similarity so near-duplicate - // pairs get heavy, cut-resistant edges. - let dists = sims - .into_iter() - .map(|(j, s)| (j, (1.0 - s).max(1e-4) as f64)) - .collect(); - (i, dists) - }) - .collect(); - + let neighbors = self.knn_neighbors(entries); if neighbors.iter().all(|(_, nbrs)| nbrs.is_empty()) { return HashSet::new(); } @@ -174,8 +270,8 @@ impl MincutGatedForgetting { } /// One min-cut partition attempt over an already-built k-NN graph; see - /// [`Self::boundary_indices`]'s "Measured limitation" note for why this - /// is called more than once. + /// [`Self::boundary_indices_exact`]'s "Measured limitation" note for why + /// this is called more than once. fn boundary_from_one_partition(neighbors: &[(usize, Vec<(usize, f64)>)]) -> HashSet { let mut analyzer = RuVectorGraphAnalyzer::from_knn(neighbors); let (side_a, side_b) = match analyzer.partition() { @@ -200,6 +296,103 @@ impl MincutGatedForgetting { } boundary } + + /// [`MincutEngine::LocalDeterministic`] boundary detection (ADR-346, + /// 2026-09-12): builds the same k-NN similarity graph as + /// [`Self::boundary_indices_exact`], but as a + /// `ruvector_mincut::DynamicGraph`, and instead of one global min-cut + /// call, runs one `DeterministicLocalKCut::search` per vertex, seeded + /// from *that vertex alone*. A vertex whose local region has a boundary + /// of at most `budget_k` edges within `max_radius` hops is flagged, + /// along with every other vertex the search placed on that region's + /// side of the cut. + /// + /// # Design note: single-vertex seeding, and why `max_radius` defaults + /// to `0` on tightly-clustered synthetic data + /// + /// Two seeding choices were tried while designing this method. + /// `DeterministicFamilyGenerator::generate_seeds` (which adds a vertex's + /// lowest-id neighbors to the seed set *before* the first boundary + /// check) was tried first and found to defeat the signal: for a + /// low-degree bridge vertex, it pre-loads both of the bridge's + /// high-degree neighbors into the very first candidate set, so the + /// first (and often only useful) boundary check is against a large, + /// noisy set rather than the bridge's own small one. Seeding with just + /// `[v]` and letting `deterministic_bfs` grow the region layer-by-layer + /// (as intended) fixed that. + /// + /// With single-vertex seeding, `max_radius >= 1` on this crate's own + /// synthetic bridge-and-cluster test fixture (see `bridge_dataset` in + /// this module's tests, and the nightly benchmark's cluster corpus) + /// still over-flags: expanding one hop from *any* same-cluster vertex + /// reaches nearly the entire cluster (clusters are built as k-NN + /// near-cliques), and that whole-cluster set also has a small boundary + /// (just the one edge leaving the cluster) — so at radius >= 1, *every* + /// vertex in *every* cluster ends up flagged, not just the bridges, + /// which erases the differential signal `MincutGatedForgetting` needs. + /// `max_radius = 0` (check only a vertex's own direct degree against + /// `budget_k`, no BFS growth) avoids this pathology and is what + /// [`Self::soft_local`]/[`Self::hard_local`] use by default. This is a + /// real, disclosed limitation of the multi-hop search on tightly + /// clustered inputs, not a claim that radius 0 is the generally correct + /// choice for every dataset — `max_radius` stays a public knob for + /// callers with different topology. + /// + /// Unlike [`Self::boundary_indices_exact`], this never calls a + /// hash-map-keyed global partition routine, so it needs no + /// `mincut_trials` retries to reach determinism: the same input always + /// produces the same boundary set (verified by + /// `local_engine_is_deterministic_across_repeated_calls` below and by + /// the nightly benchmark's own determinism check). + fn boundary_indices_local( + &self, + entries: &[MemoryEntry], + max_radius: usize, + budget_k: u64, + ) -> HashSet { + let n = entries.len(); + if n < 4 { + return HashSet::new(); + } + let neighbors = self.knn_neighbors(entries); + if neighbors.iter().all(|(_, nbrs)| nbrs.is_empty()) { + return HashSet::new(); + } + + let graph = DynamicGraph::with_capacity(n, n * self.k_neighbors.max(1)); + for i in 0..n { + graph.add_vertex(i as u64); + } + for (i, nbrs) in &neighbors { + for &(j, dist) in nbrs { + let (u, v) = (*i as u64, j as u64); + if !graph.has_edge(u, v) { + // insert_edge only fails on self-loops or an already + // present edge, both excluded by construction here. + let _ = graph.insert_edge(u, v, dist); + } + } + } + if graph.num_edges() == 0 { + return HashSet::new(); + } + + let oracle = DeterministicLocalKCut::new(max_radius); + let mut boundary = HashSet::new(); + for i in 0..n { + let v = i as u64; + let query = LocalKCutQuery { + seed_vertices: vec![v], + budget_k, + radius: max_radius, + }; + if let LocalKCutResult::Found { witness, .. } = oracle.search(&graph, query) { + let (side, _) = witness.materialize_partition(); + boundary.extend(side.into_iter().map(|id| id as usize)); + } + } + boundary + } } impl CompactionPolicy for MincutGatedForgetting { @@ -342,8 +535,9 @@ mod tests { let mut policy = MincutGatedForgetting::soft(CoherenceWeights::default(), 1.0); // Raised from the default 3: this dataset has two equal-cost minimum - // cuts (see the "Measured limitation" doc on `boundary_indices`), so - // a single low-trial-count run can occasionally miss the boundary + // cuts (see the "Measured limitation" doc on + // `boundary_indices_exact`), so a single low-trial-count run can + // occasionally miss the boundary // signal by chance; 10 keeps this deterministic unit test's flake // rate negligible at a runtime cost that is fine for `cargo test` // (19 vertices, not the multi-second cost measured at production @@ -379,4 +573,66 @@ mod tests { let survivors = policy.select_survivors(&entries, 2, &[]); assert_eq!(survivors.len(), 2); } + + // ── ADR-346 (2026-09-12): MincutEngine::LocalDeterministic tests ─────── + + #[test] + fn local_engine_soft_mode_protects_the_structural_bridge() { + let (entries, bridge_idx) = bridge_dataset(); + let policy = MincutGatedForgetting::soft_local(CoherenceWeights::default(), 1.0); + let survivors = policy.select_survivors(&entries, 16, &[]); + assert!( + survivors.contains(&bridge_idx), + "local-engine soft mincut-gated forgetting must retain the sole cross-cluster bridge" + ); + } + + #[test] + fn local_engine_hard_mode_reserves_budget_for_boundary_vertices() { + let (entries, bridge_idx) = bridge_dataset(); + let policy = MincutGatedForgetting::hard_local(CoherenceWeights::default(), 0.3); + let survivors = policy.select_survivors(&entries, 16, &[]); + assert!( + survivors.contains(&bridge_idx), + "local-engine hard mincut-gated forgetting must protect the bridge within its reserved budget" + ); + } + + #[test] + fn local_engine_falls_back_gracefully_below_minimum_size() { + let entries: Vec = (0..3) + .map(|i| MemoryEntry::new(i, vec![i as f32, 0.0], 0)) + .collect(); + let policy = MincutGatedForgetting::soft_local(CoherenceWeights::default(), 1.0); + let survivors = policy.select_survivors(&entries, 2, &[]); + assert_eq!(survivors.len(), 2); + } + + /// The core falsifiable claim of ADR-346: unlike + /// `MincutEngine::ExactGlobal` (measured non-deterministic — 15/30 empty + /// results on identical input, nightly 2026-09-05), the + /// `LocalDeterministic` engine must return byte-identical boundary sets + /// across repeated calls on unchanged input, with zero retries. + #[test] + fn local_engine_is_deterministic_across_repeated_calls() { + let (entries, _bridge_idx) = bridge_dataset(); + let policy = MincutGatedForgetting::soft_local(CoherenceWeights::default(), 1.0); + + let MincutEngine::LocalDeterministic { + max_radius, + budget_k, + } = policy.engine + else { + unreachable!() + }; + let first = policy.boundary_indices_local(&entries, max_radius, budget_k); + assert!(!first.is_empty(), "must find a boundary on this dataset"); + for trial in 0..29 { + let repeat = policy.boundary_indices_local(&entries, max_radius, budget_k); + assert_eq!( + first, repeat, + "local engine returned a different boundary set on repeat #{trial} of an unchanged graph" + ); + } + } } diff --git a/crates/ruvector-agent-memory/src/lib.rs b/crates/ruvector-agent-memory/src/lib.rs index 63a12a2a0a..b21351aaa0 100644 --- a/crates/ruvector-agent-memory/src/lib.rs +++ b/crates/ruvector-agent-memory/src/lib.rs @@ -74,7 +74,7 @@ pub use diagnostic::{ }; pub use fusion::{CausalEpisodicGraph, ClusterId, FusedCluster, FusionError, NodeRef}; #[cfg(feature = "mincut-forget")] -pub use graph_forget::{ForgetMode, MincutGatedForgetting}; +pub use graph_forget::{ForgetMode, MincutEngine, MincutGatedForgetting}; #[cfg(feature = "proof-gate")] pub use ledger::WriteGateAdapter; pub use ledger::{replay_history, AlwaysAdmitGate, LedgerEntry, ProofGate, TransactionalLedger}; diff --git a/docs/adr/ADR-346-local-kcut-gated-forgetting.md b/docs/adr/ADR-346-local-kcut-gated-forgetting.md new file mode 100644 index 0000000000..9a7102c68b --- /dev/null +++ b/docs/adr/ADR-346-local-kcut-gated-forgetting.md @@ -0,0 +1,397 @@ +# ADR-346: LocalDeterministic Mincut Engine — Fixing ADR-345's Latency and Determinism Defects + +## Status + +Rejected (as a full, all-thresholds-pass replacement), with a real, retained +partial win. `ruvector-agent-memory::graph_forget::MincutGatedForgetting` +gains a second engine, `MincutEngine::LocalDeterministic` (feature-gated +behind the existing `mincut-forget` flag, off by default, additive to +`ExactGlobal`). The narrow claim this ADR set out to test — that swapping +`RuVectorGraphAnalyzer::partition()` for +`ruvector_mincut::localkcut::DeterministicLocalKCut` fixes ADR-345's latency +and non-determinism findings for the boundary-computation step itself — is +**supported by measured evidence**. The broader pre-declared acceptance +bundle (which also carried forward ADR-345's already-established +bridge-survival-effectiveness gate and added an overall +wall-clock-vs-baseline bound) **fails**, for reasons disclosed below that are +mostly orthogonal to the engine swap itself. + +## Context + +ADR-345 (2026-09-05, `docs/research/nightly/2026-09-05-mincut-gated-forgetting/`) +built `MincutGatedForgetting`, a `CompactionPolicy` that layers a +structural "protect the bridge" signal from `ruvector-mincut` on top of +`ruvector-agent-memory`'s scalar `CoherencePolicy`. It was rejected on two +independently measured grounds: + +1. **Latency.** `RuVectorGraphAnalyzer::partition()` (the crate's global + min-cut integration layer) measured 76ms-11.4s per call for k-NN graphs of + 50-400 vertices, with an outlier 69.3s at a small, regular 19-vertex ring + topology. +2. **Non-determinism.** 30 repeated `partition()` calls on a byte-identical + 19-vertex graph with a *provably unique* weakest link returned an + empty/unusable result in 15/30 (50%) of calls — consistent with + hash-map-iteration-order-dependent tie-breaking rather than an intentional + randomized algorithm (no direct `rand` usage was found in the relevant + `ruvector-mincut` modules). + +ADR-345's "Open Questions" flagged, as the natural next-research direction, +whether one of `ruvector-mincut`'s *other* primitives — it named +`DynamicMinCut`/`ClusterHierarchy` — could supply the same signal without +paying `RuVectorGraphAnalyzer::partition()`'s cost. This ADR answers that +question, using a different (and, on reflection, better-targeted) primitive +found during this follow-up's own survey of the crate: +`ruvector_mincut::localkcut::DeterministicLocalKCut`, an implementation of +"Deterministic and Exact Fully-dynamic Minimum Cut of Superpolylogarithmic +Size" (arXiv:2512.13105) that finds a *local*, bounded-radius, bounded-budget +cut around one seed vertex via deterministic BFS — no hash-map-keyed global +partition call, no randomization anywhere in its documented or actual +implementation. + +## Hypothesis + +```text +Given the same synthetic corpus as ADR-345 (6 topic clusters x 12 core +memories + 12 bridge memories interpolated 50/50 between two random +clusters, 32-dim, k-NN k=5 cosine >= 0.05, hot-cluster access simulation +over 20 test queries) compacted 50% by MincutGatedForgetting in +MincutEngine::LocalDeterministic mode (max_radius=0, budget_k=4: a +per-vertex degree check against the same k-NN graph, via the real +DeterministicLocalKCut/WitnessHandle machinery) versus the same policy in +the original MincutEngine::ExactGlobal mode and versus plain +CoherencePolicy, + +when corpus size is scaled from 84 up to 924 vertices (same cluster/bridge +ratio), + +then (a) LocalDeterministic retains the same >=15pp bridge-survival gap +over baseline and <=2pp recall delta ExactGlobal was required to hit at 84 +vertices; (b) LocalDeterministic's wall-clock slowdown vs baseline at the +largest size where ExactGlobal still completes within a 1.5s/call budget is +at least 5x smaller than ExactGlobal's at that same size, and stays under +20x in absolute terms; and (c) LocalDeterministic returns byte-identical +survivor sets across 20 repeated compact() calls on unchanged input, + +subject to: 100% tamper-detection across 20 independent single-byte-flip +trials against the eviction witness chain using LocalDeterministic. +``` + +Fixed before the acceptance run; see +`docs/research/nightly/2026-09-12-local-kcut-gated-forgetting/README.md` +for the full methodology, the two seeding-strategy design probes that +preceded this lock (not part of the acceptance evidence), and raw output. + +## Decision + +1. Add `MincutEngine` (`ExactGlobal` | `LocalDeterministic { max_radius, + budget_k }`) to `graph_forget.rs`; `MincutGatedForgetting` gains an + `engine` field (default `ExactGlobal`, preserving ADR-345's exact + behavior and passing tests unchanged) and two new constructors, + `soft_local`/`hard_local`, defaulting to `LocalDeterministic { max_radius: + 0, budget_k: 4 }`. +2. `boundary_indices_local` builds the identical k-NN similarity graph as + the existing exact path, as a `ruvector_mincut::DynamicGraph`, and runs + one `DeterministicLocalKCut::search` per vertex (single-vertex seeding; + see "Design notes" below for why), reusing `WitnessHandle:: + materialize_partition()` to read out the found cut's vertex set. +3. **Do not promote `LocalDeterministic` as a strict replacement carrying + all of ADR-345's original acceptance semantics** — the pre-declared + bundle in this ADR still fails overall (Evidence, below). Do keep it as + the recommended engine *if* `MincutGatedForgetting` is used at all: it is + unconditionally faster, deterministic, and no worse on every measured + axis than `ExactGlobal`. +4. Keep both engines in-tree behind the existing `mincut-forget` flag + (off by default) as working reference implementations and retained + evidence. + +## Design Notes (found during implementation, not part of the acceptance run) + +Two things were discovered and fixed *before* locking the hypothesis above +(disclosed for transparency, not hidden as if the first attempt had never +happened): + +- **Seeding strategy.** `ruvector_mincut::localkcut::DeterministicFamilyGenerator::generate_seeds` + — which pre-loads a vertex's lowest-id neighbors into the *initial* seed + set — was tried first and found to defeat the signal entirely: for a + low-degree bridge vertex, it immediately mixes in the bridge's two + high-degree neighbors, so the first boundary check is against a large, + noisy set instead of the bridge's own small one. Seeding with `[v]` alone + and letting the algorithm's own BFS grow the region layer-by-layer (as its + own doc comments describe) fixed this; both the unit tests and the + benchmark below use single-vertex seeding. +- **Radius pathology on tightly-clustered synthetic data.** With + single-vertex seeding, `max_radius >= 1` *still* over-flags on this + crate's own k-NN cluster fixture: expanding one hop from any same-cluster + vertex reaches nearly the entire cluster (clusters are built as k-NN + near-cliques), and that whole-cluster region also has a tiny boundary + (the one edge leaving the cluster) — so at radius >= 1, *every* vertex in + *every* cluster gets flagged, not just bridges, erasing the differential + signal. `max_radius = 0` (a pure per-vertex degree check against + `budget_k`, still routed through the real `DeterministicLocalKCut`/ + `WitnessHandle` API) avoids this. This is a genuine, disclosed limitation + of multi-hop local search on tightly-clustered inputs — not a claim that + radius 0 is correct for every dataset. `max_radius` stays a public, + documented field for callers with different topology. +- **A separate `ruvector-mincut` defect found, not used.** + `ruvector_mincut::algorithm::approximate::ApproxMinCut` (a seeded, + deterministic, Stoer-Wagner-on-a-sparsifier approximate min-cut — the + first candidate considered for this follow-up, before `localkcut`) has a + `compute_partition()` that **ignores its own `cut_value` argument** and + returns an arbitrary BFS-order bisection unrelated to the actual computed + cut (`crates/ruvector-mincut/src/algorithm/approximate.rs:558-599`, the + `_cut_value` parameter is prefix-underscored and never read). Its + `min_cut()`/`min_cut_value()` are real and usable; its `partition` field + is not. Not used by this ADR's implementation; flagged here as a + follow-up hardening item against `ruvector-mincut` itself, in the same + spirit as ADR-345's non-determinism finding. + +## Evidence + +Exact command: + +```bash +cargo run --release -p ruvector-agent-memory \ + --example mincut_local_forgetting_bench --features mincut-forget +``` + +Full raw output in +`docs/research/nightly/2026-09-12-local-kcut-gated-forgetting/raw-runs.txt`. +Headline numbers: + +| Gate | Threshold | Measured | Result | +|---|---|---|---| +| Bridge-survival gap (Soft/Hard, inherited from ADR-345) | >= 15pp | +0.0pp | FAIL | +| Recall@10 delta (Soft/Hard) | <= 2pp | 0.00pp | PASS | +| Local vs Exact speedup @ n=168 (largest n Exact completed within budget) | >= 5x | **623x** | PASS | +| Local vs baseline slowdown @ n=168 | <= 20x | 26.0x | FAIL | +| Local determinism, 20 repeated `compact()` calls | 20/20 identical | 20/20 | PASS | +| Tamper detection | 20/20 | 20/20 | PASS | + +Scaling table (Soft-Exact vs Soft-Local `compact()` wall-clock, same corpus +shape scaled 1x-11x): + +| n | Baseline (us) | Exact (us) | Local (us) | +|---:|---:|---:|---:| +| 84 | 66 | 264,264 | 1,005 | +| 168 | 136 | 2,200,278 | 3,532 | +| 252 | 199 | skipped (budget) | 6,857 | +| 420 | 376 | skipped (budget) | 18,518 | +| 588 | 486 | skipped (budget) | 35,666 | +| 924 | 782 | skipped (budget) | 87,143 | + +`Exact` was cut off once a single call exceeded a pre-declared 1.5s budget +(itself already exceeded at n=168, 2.2s) — a direct reproduction, at a +different corpus shape, of ADR-345's scaling finding. `Local` completed +every size up to 924 vertices (11x the base corpus) in under 90ms. + +Interpretation, split by claim (see "Rejection Criteria" for how these +combine into the overall verdict): + +- **Narrow claim (this ADR's actual contribution) — supported.** The + boundary-computation step itself is fixed: 623x faster than + `ExactGlobal` at the one size where both completed, and `Local` is the + only one of the two that scales to a corpus beyond a few hundred vertices + at all within a practical wall-clock. Determinism and witness-chain + compatibility both hold (20/20 on each). +- **Inherited claim — not novel, reproduces ADR-345.** The 0.0pp + bridge-survival gap is the *same* null result ADR-345 already measured + for `ExactGlobal` (at a different seed/corpus size: 66.7% baseline there + vs 16.7% here, but the same "candidates match baseline exactly" pattern). + This says the structural bonus does not move rankings on this synthetic + corpus **regardless of which engine computes it** — a property of the + dataset/scoring interaction, not of `LocalDeterministic` specifically. + Carried into this ADR's acceptance bundle only for direct comparability + with ADR-345's own bar, not as a new finding. +- **New, engine-agnostic finding — the k-NN construction cost dominates at + scale.** The "<=20x slowdown vs baseline" gate fails (26x at n=168, + growing to ~111x at n=924) because both engines pay the *same* O(n^2) + pairwise-cosine-similarity cost to build the k-NN graph in the first + place (`knn_neighbors`, unchanged by this ADR) — `CoherencePolicy`'s + baseline does no such graph construction at all. This is a real, + previously-undisclosed cost of the *k-NN-graph-based structural signal + design as a whole* (both engines), not a defect specific to + `LocalDeterministic`; the `LocalDeterministic` engine's own per-vertex + query cost is negligible next to it (visible in how flat the `Local` + column's growth rate is against `n^2` — it tracks the shared O(n^2) k-NN + cost, not an additional cut-search cost on top of it). + +## Adversarial Self-Check + +- **Baseline fairness.** `CoherencePolicy`'s cheap wall-clock is not an + unfair comparison artifact — it genuinely does no graph construction. + Disclosed explicitly above rather than left implicit. +- **Cherry-picking the scaling comparison point.** The rule "compare at the + largest n where Exact still completed within its pre-declared budget" was + written into the benchmark's source *before* it was run once, not chosen + after seeing results to flatter either engine — and it is not the most + favorable point available for the slowdown-vs-baseline gate (n=84 would + have passed at 14.9x; n=168 was picked by the rule regardless and fails + at 26x). +- **Hidden preprocessing cost.** k-NN construction is measured *inside* the + timed `compact()` call for both engines (not hoisted out), so its cost is + fully counted against both, and is disclosed as the dominant cost above + rather than attributed to the cut algorithm. +- **Fixed seed only.** This run uses one seed (346) across all sizes/trials, + consistent with ADR-345's own convention; not repeated across multiple + seeds due to nightly wall-clock constraints — see "Limitations." + +## Consequences + +- `ruvector-agent-memory` gains a strictly-better-or-equal engine option for + `MincutGatedForgetting` on every axis this and ADR-345 measured, but the + policy as a whole remains unpromoted (off by default) because the + underlying bridge-survival effectiveness question is still open (ADR-345's + finding, unchanged by this ADR). +- The `ExactGlobal` engine is retained (not removed) as a comparison + baseline and because removing working, tested code is out of scope for a + nightly research cycle. +- A new, disclosed hardening item is filed against `ruvector-mincut` + (`ApproxMinCut::compute_partition()` returning an unrelated bisection) — + not fixed here, since fixing another crate's defect discovered only + incidentally is out of this ADR's scope; recorded so it is not + silently rediscovered later. +- No existing behavior changes: `ExactGlobal`'s default status, all + existing public constructors (`soft`, `hard`), and every other + `CompactionPolicy` are untouched. + +## Alternatives Considered + +- **`ApproxMinCut` (spectral-sparsifier-based approximate min-cut).** + Investigated first; rejected once its `compute_partition()` was found to + return an arbitrary bisection unrelated to its own computed cut value + (see "Design Notes"). Its `min_cut_value()` alone is real but insufficient + — this use case needs *which vertices*, not just the cut's weight. +- **`DeterministicFamilyGenerator`-seeded local k-cut (multi-vertex + seeding).** Rejected during design: pre-loads high-degree neighbors into + the first candidate set, defeating the boundary signal for exactly the + low-degree vertices it should isolate. See "Design Notes." +- **`max_radius >= 1`.** Rejected during design for this specific + tightly-clustered synthetic corpus: over-flags entire clusters. Kept as a + public, non-default knob rather than removed, since it may be appropriate + for less tightly clustered real data — untested here. +- **`ruvector_mincut::DynamicMinCut`/`ClusterHierarchy` directly** (ADR-345's + originally suggested direction). Not attempted in this pass; + `DeterministicLocalKCut` was chosen instead once found to more directly + match the "is this vertex locally isolable" query shape. Still open as a + possible future comparison. + +## Implementation Plan + +Already implemented in this PR: + +- `crates/ruvector-agent-memory/src/graph_forget.rs`: `MincutEngine` enum, + `engine` field, `soft_local`/`hard_local` constructors, + `boundary_indices_local`, 4 new unit tests (bridge protection x2, + graceful fallback, cross-call determinism). +- `crates/ruvector-agent-memory/src/lib.rs`: export `MincutEngine`. +- `crates/ruvector-agent-memory/examples/mincut_local_forgetting_bench.rs`: + the acceptance benchmark (5 policies, determinism section, 6-point scaling + probe, tamper trials, explicit ACCEPT/REJECT). +- `crates/ruvector-agent-memory/Cargo.toml`: registers the new example. + +No changes to `ExactGlobal`'s behavior, `witnessed_compaction.rs`, or any +crate outside `ruvector-agent-memory`. + +## API Shape + +```rust +// Behind `mincut-forget`, additive to ADR-345's existing API: +pub enum MincutEngine { + ExactGlobal, + LocalDeterministic { max_radius: usize, budget_k: u64 }, +} +pub struct MincutGatedForgetting { + pub weights: CoherenceWeights, + pub mode: ForgetMode, + pub engine: MincutEngine, // new; defaults to ExactGlobal + pub k_neighbors: usize, + pub min_similarity: f32, + pub structural_bonus: f32, + pub protect_fraction: f32, + pub mincut_trials: usize, // ExactGlobal only; ignored by LocalDeterministic +} +impl MincutGatedForgetting { + pub fn soft(weights: CoherenceWeights, structural_bonus: f32) -> Self; // unchanged (ExactGlobal) + pub fn hard(weights: CoherenceWeights, protect_fraction: f32) -> Self; // unchanged (ExactGlobal) + pub fn soft_local(weights: CoherenceWeights, structural_bonus: f32) -> Self; // new (LocalDeterministic) + pub fn hard_local(weights: CoherenceWeights, protect_fraction: f32) -> Self; // new (LocalDeterministic) +} +``` + +## Feature Flags + +No new flags. `MincutEngine::LocalDeterministic` is reached through the +existing `mincut-forget` feature (off by default), same as ADR-345's +`ExactGlobal`. + +## Benchmark Evidence + +See "Evidence" above and +`docs/research/nightly/2026-09-12-local-kcut-gated-forgetting/README.md` +for full methodology and raw output. + +## Security + +No new cryptographic primitive. `DeterministicLocalKCut`'s `WitnessHandle` +(a `RoaringBitmap` membership set + precomputed boundary size) is used only +to read back which vertices a search placed on the found cut's side; it is +never treated as a security witness by this policy (the existing eviction +witness chain, unrelated to this handle, still provides that). Tamper +detection against `EvictionWitnessChain` was re-verified end-to-end with the +new engine (20/20) to confirm the engine swap does not weaken that +independent guarantee. + +## Governance + +None beyond the existing "no witness, no mutation" invariant +(`witnessed_compaction`), unaffected by this ADR. + +## Migration + +None: `LocalDeterministic` is additive; every existing caller of `soft()`/ +`hard()` keeps `ExactGlobal` behavior unchanged (verified by the unmodified +original unit tests in `graph_forget.rs` continuing to pass). + +## Rollback + +Remove `soft_local`/`hard_local`, the `LocalDeterministic` variant, and +`boundary_indices_local` — `ExactGlobal` and every other existing caller are +unaffected, since `engine` defaults to `ExactGlobal` and no other code path +references the new variant. + +## Rejection Criteria + +The pre-declared acceptance *bundle* in this ADR is treated as rejected +because two of its gates failed: + +1. The inherited bridge-survival-effectiveness gate (>= 15pp), reproducing + ADR-345's own null finding rather than a new failure of this engine. +2. The overall wall-clock-vs-baseline gate (<= 20x), driven by the shared + (both-engines) O(n^2) k-NN construction cost, not by + `LocalDeterministic`'s own per-vertex query cost. + +The narrower, actually-novel claim this ADR investigated — does +`LocalDeterministic` fix ADR-345's latency and determinism defects relative +to `ExactGlobal` — is supported (623x speedup at the one directly-comparable +size, clean scaling to 924 vertices, 20/20 determinism, 20/20 tamper +detection). Recorded as a partial, evidence-backed result rather than +forced into a single ACCEPT/REJECT label that would misrepresent either +half. + +## Open Questions + +1. Would a genuinely different scoring baseline (real embeddings rather + than Gaussian-cluster synthetic data) produce a *non-zero* + bridge-survival gap, making the still-open ADR-345 effectiveness + question answerable at all? Unaddressed by either ADR. +2. Can the shared O(n^2) k-NN construction cost itself be reduced (e.g. via + `ruvector-coherence-hnsw` or another approximate-neighbor index already + in this workspace) to make the *overall* `MincutGatedForgetting` call + competitive with baseline, independent of which cut engine is used? + Flagged as the natural next-research item. +3. Does `max_radius >= 1` become viable (without the whole-cluster + over-flagging found here) on real, less artificially-clustered agent + memory embeddings? Untested. +4. Should `ApproxMinCut::compute_partition()`'s defect (found, not fixed, + here) be corrected upstream in `ruvector-mincut`? Out of this ADR's + scope; filed as a disclosed finding only. diff --git a/docs/adr/INDEX.md b/docs/adr/INDEX.md index ffd65a6d0a..0844d6f6af 100644 --- a/docs/adr/INDEX.md +++ b/docs/adr/INDEX.md @@ -1,6 +1,6 @@ # ADR Index -**Next available ADR number: 346** +**Next available ADR number: 347** > Generated by `node scripts/adr-index.mjs` — do not edit by hand. > This file is the canonical allocation counter for new ADR numbers @@ -8,319 +8,319 @@ > historical artifacts and are cited as `ADR-NNN (slug)`. > CI gate: `node scripts/adr-index.mjs --check`. -- ADR files indexed: **376** (329 on the canonical counter, 47 in namespaced families) -- Highest allocated number: **ADR-345** +- ADR files indexed: **377** (330 on the canonical counter, 47 in namespaced families) +- Highest allocated number: **ADR-346** - Frozen duplicate numbers: **27** (spanning 61 files) | Number | Title | File | Last commit | Status | Duplicate | |---|---|---|---|---|---| -| ADR-001 | ADR-001: Ruvector Core Architecture | [`ADR-001-ruvector-core-architecture.md`](./ADR-001-ruvector-core-architecture.md) | 2026-08-20 | Proposed | | -| ADR-002 | ADR-002: RuvLLM Integration with Ruvector | [`ADR-002-ruvllm-integration.md`](./ADR-002-ruvllm-integration.md) | 2026-08-20 | Proposed | | -| ADR-003 | ADR-003: SIMD Optimization Strategy for Ruvector and RuvLLM | [`ADR-003-simd-optimization-strategy.md`](./ADR-003-simd-optimization-strategy.md) | 2026-08-20 | ✅ Implemented (v2.1.1) | | -| ADR-004 | ADR-004: KV Cache Management Strategy for RuvLLM | [`ADR-004-kv-cache-management.md`](./ADR-004-kv-cache-management.md) | 2026-08-20 | Proposed | | -| ADR-005 | ADR-005: WASM Runtime Integration | [`ADR-005-wasm-runtime-integration.md`](./ADR-005-wasm-runtime-integration.md) | 2026-08-20 | | | -| ADR-006 | ADR-006: Unified Memory Pool and Paging Strategy | [`ADR-006-memory-management.md`](./ADR-006-memory-management.md) | 2026-08-20 | | | -| ADR-007 | ADR-007: Security Review & Technical Debt Remediation | [`ADR-007-security-review-technical-debt.md`](./ADR-007-security-review-technical-debt.md) | 2026-08-20 | Active | | -| ADR-008 | ADR-008: mistral-rs Integration for Production-Scale LLM Serving | [`ADR-008-mistral-rs-integration.md`](./ADR-008-mistral-rs-integration.md) | 2026-08-20 | Proposed | | -| ADR-009 | ADR-009: Structured Output / JSON Mode for Reliable Agentic Workflows | [`ADR-009-structured-output.md`](./ADR-009-structured-output.md) | 2026-08-20 | Proposed | | -| ADR-010 | ADR-010: Function Calling / Tool Use in RuvLLM | [`ADR-010-function-calling.md`](./ADR-010-function-calling.md) | 2026-08-20 | Proposed | | -| ADR-011 | ADR-011: Prefix Caching for 10x Faster RAG and Chat Applications | [`ADR-011-prefix-caching.md`](./ADR-011-prefix-caching.md) | 2026-08-20 | Proposed | | -| ADR-012 | ADR-012: Security Remediation and Hardening | [`ADR-012-security-remediation.md`](./ADR-012-security-remediation.md) | 2026-08-20 | Accepted | | -| ADR-013 | ADR-013: HuggingFace Model Publishing Strategy | [`ADR-013-huggingface-publishing.md`](./ADR-013-huggingface-publishing.md) | 2026-08-20 | **Accepted** - 2026-01-20 | | -| ADR-014 | ADR-014: Coherence Engine Architecture | [`ADR-014-coherence-engine.md`](./ADR-014-coherence-engine.md) | 2026-08-20 | Proposed | | -| ADR-015 | ADR-015: Coherence-Gated Transformer (Sheaf Attention) | [`ADR-015-coherence-gated-transformer.md`](./ADR-015-coherence-gated-transformer.md) | 2026-08-20 | Proposed | | -| ADR-016 | ADR-016: Delta-Behavior System - Domain-Driven Design Architecture | [`ADR-016-delta-behavior-ddd-architecture.md`](./ADR-016-delta-behavior-ddd-architecture.md) | 2026-08-20 | Proposed | | -| ADR-017 | ADR-017: Temporal Tensor Compression with Tiered Quantization | [`ADR-017-temporal-tensor-compression.md`](./ADR-017-temporal-tensor-compression.md) | 2026-08-20 | Proposed | | -| ADR-018 | ADR-018: Block-Based Storage Engine Architecture for the Temporal Tensor Store | [`temporal-tensor-store/ADR-018-block-based-storage-engine.md`](./temporal-tensor-store/ADR-018-block-based-storage-engine.md) | 2026-08-20 | Proposed | | -| ADR-019 | ADR-019: Tiered Quantization Formats for Temporal Tensor Store | [`temporal-tensor-store/ADR-019-tiered-quantization-formats.md`](./temporal-tensor-store/ADR-019-tiered-quantization-formats.md) | 2026-08-20 | Proposed | | -| ADR-020 | ADR-020: Temporal Scoring and Tier Migration Algorithm | [`temporal-tensor-store/ADR-020-temporal-scoring-tier-migration.md`](./temporal-tensor-store/ADR-020-temporal-scoring-tier-migration.md) | 2026-08-20 | Proposed | | -| ADR-021 | ADR-021: Delta Compression and Reconstruction Policies | [`temporal-tensor-store/ADR-021-delta-compression-reconstruction.md`](./temporal-tensor-store/ADR-021-delta-compression-reconstruction.md) | 2026-08-20 | Proposed | | -| ADR-022 | ADR-022: WASM API Surface and Cross-Platform Strategy | [`temporal-tensor-store/ADR-022-wasm-api-cross-platform.md`](./temporal-tensor-store/ADR-022-wasm-api-cross-platform.md) | 2026-08-20 | Proposed | | -| ADR-023 | ADR-023: Benchmarking, Failure Modes, and Acceptance Criteria | [`temporal-tensor-store/ADR-023-benchmarking-acceptance-criteria.md`](./temporal-tensor-store/ADR-023-benchmarking-acceptance-criteria.md) | 2026-08-20 | Proposed | | -| ADR-024 | ADR-024: Craftsman Ultra 30b 1bit — BitNet Integration with RuvLLM | [`ADR-024-craftsman-ultra-30b-1bit-bitnet-integration.md`](./ADR-024-craftsman-ultra-30b-1bit-bitnet-integration.md) | 2026-08-20 | Proposed | | -| ADR-025 | ADR-025: EXO-AI Multi-Paradigm Integration Architecture | [`ADR-025-exo-ai-multiparadigm-integration.md`](./ADR-025-exo-ai-multiparadigm-integration.md) | 2026-08-20 | Proposed | | -| ADR-026 | ADR-026: Vector-Native COW Branching (RVCOW) and Real Cognitive Containers | [`ADR-026-rvcow-branching-and-real-cognitive-containers.md`](./ADR-026-rvcow-branching-and-real-cognitive-containers.md) | 2026-08-20 | | | -| ADR-027 | ADR-027: Fix HNSW Index Segmentation Fault with Parameterized Queries | [`ADR-027-hnsw-parameterized-query-fix.md`](./ADR-027-hnsw-parameterized-query-fix.md) | 2026-08-20 | **Accepted** - 2026-01-28 | | -| ADR-028 | ADR-028: eHealth Platform Architecture for 50M Patient Records | [`ADR-028-ehealth-platform-architecture.md`](./ADR-028-ehealth-platform-architecture.md) | 2026-08-20 | Proposed | | -| ADR-029 | ADR-029: RVF as Canonical Binary Format Across All RuVector Libraries | [`ADR-029-rvf-canonical-format.md`](./ADR-029-rvf-canonical-format.md) | 2026-08-20 | Accepted | | -| ADR-030 | ADR-030: RVF Cognitive Container -- Self-Booting Vector Files | [`ADR-030-rvf-cognitive-container.md`](./ADR-030-rvf-cognitive-container.md) | 2026-08-20 | Proposed | | -| ADR-031 | ADR-031: RVF Example Repository — 24 Demonstrations Across Four Categories | [`ADR-031-rvf-example-repository.md`](./ADR-031-rvf-example-repository.md) | 2026-08-20 | Accepted | | -| ADR-032 | ADR-032: RVF WASM Integration into npx ruvector and rvlite | [`ADR-032-rvf-wasm-integration.md`](./ADR-032-rvf-wasm-integration.md) | 2026-08-20 | Accepted | | -| ADR-033 | ADR-033: Progressive Indexing Hardening — Centroid Stability, Adversarial Resilience, Recall Framing, and Mandatory Signatures | [`ADR-033-progressive-indexing-hardening.md`](./ADR-033-progressive-indexing-hardening.md) | 2026-08-20 | Accepted | | -| ADR-034 | ADR-034: QR Cognitive Seed — A World Inside a World | [`ADR-034-qr-cognitive-seed.md`](./ADR-034-qr-cognitive-seed.md) | 2026-08-20 | Implemented | | -| ADR-035 | ADR-035: Capability Report — Witness Bundles, Scorecards, and Governance | [`ADR-035-capability-report.md`](./ADR-035-capability-report.md) | 2026-08-20 | Implemented | | -| ADR-036 | ADR-036: RuVector AGI Cognitive Container with Claude Code Orchestration | [`ADR-036-agi-cognitive-container.md`](./ADR-036-agi-cognitive-container.md) | 2026-08-20 | Partially Implemented | | -| ADR-037 | ADR-037: Publishable RVF Acceptance Test | [`ADR-037-publishable-rvf-acceptance-test.md`](./ADR-037-publishable-rvf-acceptance-test.md) | 2026-08-20 | | | -| ADR-038 | ADR-038: npx ruvector & rvlite Witness Verification Integration | [`ADR-038-npx-ruvector-rvlite-witness-integration.md`](./ADR-038-npx-ruvector-rvlite-witness-integration.md) | 2026-08-20 | | | -| ADR-039 | ADR-039: RVF Solver WASM — Self-Learning AGI Engine Integration | [`ADR-039-rvf-solver-wasm-agi-integration.md`](./ADR-039-rvf-solver-wasm-agi-integration.md) | 2026-08-20 | | | -| ADR-040 | ADR-040: Causal Atlas RVF Runtime — Planet Detection & Life Candidate Scoring | [`ADR-040-causal-atlas-rvf-runtime-planet-detection.md`](./ADR-040-causal-atlas-rvf-runtime-planet-detection.md) | 2026-08-20 | Proposed | | -| ADR-040a | ADR-040a: Causal Atlas Dashboard Specification | [`ADR-040a-planet-detection-dashboard.md`](./ADR-040a-planet-detection-dashboard.md) | 2026-08-20 | Proposed | | -| ADR-040b | ADR-040b: Microlensing Detection & Cross-Domain Graph-Cut Extensions | [`ADR-040b-microlensing-graphcut-extensions.md`](./ADR-040b-microlensing-graphcut-extensions.md) | 2026-08-20 | Proposed | | -| ADR-042 | ADR-042: Security RVF — AIDefence + TEE Hardened Cognitive Container | [`ADR-042-Security-RVF-AIDefence-TEE.md`](./ADR-042-Security-RVF-AIDefence-TEE.md) | 2026-08-20 | | | -| ADR-043 | ADR-043: External Intelligence Providers for SONA Learning | [`ADR-043-external-intelligence-providers.md`](./ADR-043-external-intelligence-providers.md) | 2026-08-20 | | | -| ADR-044 | ADR-044: ruvector-postgres v0.3 Extension Upgrade | [`ADR-044-ruvector-postgres-v03-extension-upgrade.md`](./ADR-044-ruvector-postgres-v03-extension-upgrade.md) | 2026-08-20 | Accepted — Implementation in progress | | -| ADR-045 | ADR-045: Lean-Agentic Integration — Formal Verification & AI-Native Type Theory for RuVector | [`ADR-045-lean-agentic-integration.md`](./ADR-045-lean-agentic-integration.md) | 2026-08-20 | Proposed | | -| ADR-046 | ADR-046: Graph Transformer Unified Architecture | [`ADR-046-graph-transformer-architecture.md`](./ADR-046-graph-transformer-architecture.md) | 2026-08-20 | Accepted | | -| ADR-047 | ADR-047: Proof-Gated Mutation Protocol | [`ADR-047-proof-gated-mutation-protocol.md`](./ADR-047-proof-gated-mutation-protocol.md) | 2026-08-20 | Accepted | | -| ADR-048 | ADR-048: Sublinear Graph Attention | [`ADR-048-sublinear-graph-attention.md`](./ADR-048-sublinear-graph-attention.md) | 2026-08-20 | Accepted | | -| ADR-049 | ADR-049: Verified Training Pipeline | [`ADR-049-verified-training-pipeline.md`](./ADR-049-verified-training-pipeline.md) | 2026-08-20 | Accepted | | -| ADR-050 | ADR-050: Graph Transformer WASM and Node.js Bindings | [`ADR-050-graph-transformer-bindings.md`](./ADR-050-graph-transformer-bindings.md) | 2026-08-20 | Accepted | | -| ADR-051 | ADR-051: Physics-Informed Graph Transformer Layers | [`ADR-051-physics-informed-graph-layers.md`](./ADR-051-physics-informed-graph-layers.md) | 2026-08-20 | Accepted | | -| ADR-052 | ADR-052: Biological Graph Transformer Layers | [`ADR-052-biological-graph-layers.md`](./ADR-052-biological-graph-layers.md) | 2026-08-20 | Accepted | | -| ADR-053 | ADR-053: Temporal and Causal Graph Transformer Layers | [`ADR-053-temporal-causal-graph-layers.md`](./ADR-053-temporal-causal-graph-layers.md) | 2026-08-20 | Accepted | | -| ADR-054 | ADR-054: Economic Graph Transformer Layers | [`ADR-054-economic-graph-layers.md`](./ADR-054-economic-graph-layers.md) | 2026-08-20 | Accepted | | -| ADR-055 | ADR-055: Manifold-Aware Graph Transformer Layers | [`ADR-055-manifold-graph-layers.md`](./ADR-055-manifold-graph-layers.md) | 2026-08-20 | Accepted | | -| ADR-056 | ADR-056: RVF Knowledge Export for Developer Onboarding | [`ADR-056-rvf-knowledge-export.md`](./ADR-056-rvf-knowledge-export.md) | 2026-08-20 | Accepted | | -| ADR-057 | ADR-057: Federated RVF Format for Real-Time Transfer Learning | [`ADR-057-federated-rvf-transfer-learning.md`](./ADR-057-federated-rvf-transfer-learning.md) | 2026-08-20 | Proposed | | -| ADR-058 | ADR-058: RVF Hash Security Hardening and Optimization | [`ADR-058-hash-security-optimization.md`](./ADR-058-hash-security-optimization.md) | 2026-08-20 | Accepted | | -| ADR-059 | ADR-059: Shared Brain — Google Cloud Deployment | [`ADR-059-shared-brain-google-cloud.md`](./ADR-059-shared-brain-google-cloud.md) | 2026-08-20 | Accepted | | -| ADR-060 | ADR-060: Shared Brain Capabilities — Federated MicroLoRA Intelligence Substrate | [`ADR-060-shared-brain-capabilities.md`](./ADR-060-shared-brain-capabilities.md) | 2026-08-20 | Accepted | | -| ADR-061 | ADR-061: Reasoning Kernel Architecture — Brain-Augmented Targeted Reasoning | [`ADR-061-reasoning-kernel-architecture.md`](./ADR-061-reasoning-kernel-architecture.md) | 2026-08-20 | Accepted | | -| ADR-062 | ADR-062: Brainpedia — Structured Knowledge Encyclopedia with Delta-Based Editing | [`ADR-062-brainpedia-architecture.md`](./ADR-062-brainpedia-architecture.md) | 2026-08-20 | Accepted | | -| ADR-063 | ADR-063: WASM Executable Nodes — Deterministic Compute at the Edge | [`ADR-063-wasm-executable-nodes.md`](./ADR-063-wasm-executable-nodes.md) | 2026-08-20 | Accepted | | -| ADR-064 | ADR-064: Pi Brain Infrastructure & Landing Page | [`ADR-064-pi-brain-infrastructure.md`](./ADR-064-pi-brain-infrastructure.md) | 2026-08-20 | Accepted, Deployed | | -| ADR-065 | ADR-065: npm Publishing Strategy | [`ADR-065-npm-publishing-strategy.md`](./ADR-065-npm-publishing-strategy.md) | 2026-08-20 | Accepted | | -| ADR-066 | ADR-066: SSE MCP Transport | [`ADR-066-sse-mcp-transport.md`](./ADR-066-sse-mcp-transport.md) | 2026-08-20 | Accepted, Deployed — Updated 2026-04-02: SSE moved to dedicated subdomain `mcp.p | | -| ADR-067 | ADR-067: MCP Gate Permit System | [`ADR-067-mcp-gate-permit-system.md`](./ADR-067-mcp-gate-permit-system.md) | 2026-08-20 | Accepted, Implemented | | -| ADR-068 | ADR-068: Domain Expansion Transfer Learning | [`ADR-068-domain-expansion-transfer-learning.md`](./ADR-068-domain-expansion-transfer-learning.md) | 2026-08-20 | Accepted, Implemented | | -| ADR-069 | ADR-069: Edge-Net and Pi Brain Integration — Distributed Compute Intelligence | [`ADR-069-google-edge-network-deployment.md`](./ADR-069-google-edge-network-deployment.md) | 2026-08-20 | Proposed | | -| ADR-070 | ADR-070: npx ruvector Unified Integration | [`ADR-070-npx-ruvector-unified-integration.md`](./ADR-070-npx-ruvector-unified-integration.md) | 2026-08-20 | Proposed | | -| ADR-071 | ADR-071: npx ruvector Ecosystem Gap Analysis | [`ADR-071-npx-ruvector-ecosystem-gap-analysis.md`](./ADR-071-npx-ruvector-ecosystem-gap-analysis.md) | 2026-08-20 | Proposed | | -| ADR-072 | ADR-072: RVF Example Management and Downloads in npx ruvector | [`ADR-072-rvf-example-management-downloads.md`](./ADR-072-rvf-example-management-downloads.md) | 2026-08-20 | Proposed | | -| ADR-073 | ADR-073: π.ruv.io Platform Security Audit & Optimization | [`ADR-073-pi-platform-security-optimization.md`](./ADR-073-pi-platform-security-optimization.md) | 2026-08-20 | Accepted | | -| ADR-074 | ADR-074: RuvLLM Neural Embedding Integration | [`ADR-074-ruvllm-neural-embeddings.md`](./ADR-074-ruvllm-neural-embeddings.md) | 2026-08-20 | Implemented (Phase 2 — RlmEmbedder Active) | | -| ADR-075 | ADR-075: Wire Full RVF AGI Stack into mcp-brain-server | [`ADR-075-rvf-agi-stack-brain-integration.md`](./ADR-075-rvf-agi-stack-brain-integration.md) | 2026-08-20 | Implemented | | -| ADR-076 | ADR-076: AGI Capability Wiring Architecture | [`ADR-076-agi-capability-wiring-architecture.md`](./ADR-076-agi-capability-wiring-architecture.md) | 2026-08-20 | Implemented | | -| ADR-077 | ADR-077: Midstream Platform Integration into mcp-brain-server | [`ADR-077-midstream-brain-integration.md`](./ADR-077-midstream-brain-integration.md) | 2026-08-20 | Proposed | | -| ADR-078 | ADR-078: npx ruvector Midstream & Brain AGI Integration | [`ADR-078-npx-ruvector-midstream-integration.md`](./ADR-078-npx-ruvector-midstream-integration.md) | 2026-08-20 | Proposed | | -| ADR-079 | ADR-079: SQL Audit Script Hardening & Bug Fixes | [`ADR-079-sql-audit-script-hardening.md`](./ADR-079-sql-audit-script-hardening.md) | 2026-08-20 | Accepted | | -| ADR-080 | ADR-080: npx ruvector Deep Capability Audit | [`ADR-080-npx-ruvector-deep-capability-audit.md`](./ADR-080-npx-ruvector-deep-capability-audit.md) | 2026-08-20 | Accepted | | -| ADR-081 | ADR-081: Brain Server v0.2.8–0.2.10 Deploy + CLI/MCP Bug Fixes | [`ADR-081-brain-server-v028-deploy-cli-fixes.md`](./ADR-081-brain-server-v028-deploy-cli-fixes.md) | 2026-08-20 | Accepted | | -| ADR-082 | ADR-082: Brain Server Security Hardening — PII, Rate Limiting, Anti-Sybil | [`ADR-082-brain-security-hardening.md`](./ADR-082-brain-security-hardening.md) | 2026-08-20 | Accepted | | -| ADR-083 | ADR-083: Brain Server Training Loops — Closing the Store→Learn Gap | [`ADR-083-brain-training-loops.md`](./ADR-083-brain-training-loops.md) | 2026-08-20 | Accepted | | -| ADR-084 | ADR-084: ruvllm-wasm — First Functional npm Publish | [`ADR-084-ruvllm-wasm-publish.md`](./ADR-084-ruvllm-wasm-publish.md) | 2026-08-20 | Accepted | | -| ADR-085 | ADR-085: RuVector Neural Trader — Dynamic Market Graphs, MinCut Coherence Gating, and Proof-Gated Mutation | [`ADR-085-neural-trader-ruvector.md`](./ADR-085-neural-trader-ruvector.md) | 2026-08-20 | Proposed | | -| ADR-086 | ADR-086: Neural Trader WASM Bindings | [`ADR-086-neural-trader-wasm.md`](./ADR-086-neural-trader-wasm.md) | 2026-08-20 | Accepted | | -| ADR-087 | ADR-087: RuVix Cognition Kernel — An Operating System for the Agentic Age | [`ADR-087-ruvix-cognition-kernel.md`](./ADR-087-ruvix-cognition-kernel.md) | 2026-08-20 | **Accepted** — Phase A Implemented | | -| ADR-088 | ADR-088: CNN Contrastive Learning Integration for RuVector | [`ADR-088-cnn-contrastive-integration.md`](./ADR-088-cnn-contrastive-integration.md) | 2026-08-20 | **Proposed** | | -| ADR-089 | ADR-089: CNN Browser Demo for GitHub Pages | [`ADR-089-cnn-browser-demo.md`](./ADR-089-cnn-browser-demo.md) | 2026-08-20 | Accepted | | -| ADR-090 | ADR-090 Implementation Checklist: Ultra-Low-Bit QAT & Pi-Quantization | [`ADR-090-implementation-checklist.md`](./ADR-090-implementation-checklist.md) | 2026-08-20 | Ready for Implementation (Staged) | DUPLICATE ×2 — cite as `ADR-90 (implementation-checklist)` | -| ADR-090 | ADR-090: Ultra-Low-Bit QAT & Pi-Quantization — Domain-Driven Design Architecture | [`ADR-090-ultra-low-bit-qat-pi-quantization-ddd.md`](./ADR-090-ultra-low-bit-qat-pi-quantization-ddd.md) | 2026-08-20 | Accepted (Implementing) | DUPLICATE ×2 — cite as `ADR-90 (ultra-low-bit-qat-pi-quantization-ddd)` | -| ADR-091 | ADR-091 Implementation Checklist: INT8 CNN Quantization | [`ADR-091-implementation-checklist.md`](./ADR-091-implementation-checklist.md) | 2026-08-20 | Ready for Implementation | DUPLICATE ×2 — cite as `ADR-91 (implementation-checklist)` | -| ADR-091 | ADR-091: INT8 CNN Quantization — Domain-Driven Design Architecture | [`ADR-091-int8-cnn-quantization-ddd.md`](./ADR-091-int8-cnn-quantization-ddd.md) | 2026-08-20 | Accepted (Implementing) | DUPLICATE ×2 — cite as `ADR-91 (int8-cnn-quantization-ddd)` | -| ADR-092 | ADR-092: MoE Memory-Aware Routing — Domain-Driven Design Architecture | [`ADR-092-moe-memory-aware-routing-ddd.md`](./ADR-092-moe-memory-aware-routing-ddd.md) | 2026-08-20 | Accepted | | -| ADR-093 | ADR-093: Daily Discovery & Brain Training Program | [`ADR-093-daily-discovery-brain-training.md`](./ADR-093-daily-discovery-brain-training.md) | 2026-08-20 | Accepted | DUPLICATE ×2 — cite as `ADR-93 (daily-discovery-brain-training)` | -| ADR-093 | ADR-093: DeepAgents Complete Rust Conversion — Overview | [`ADR-093-deepagents-rust-conversion-overview.md`](./ADR-093-deepagents-rust-conversion-overview.md) | 2026-08-20 | | DUPLICATE ×2 — cite as `ADR-93 (deepagents-rust-conversion-overview)` | -| ADR-094 | ADR-094: Backend Protocol & Trait System | [`ADR-094-deepagents-backend-protocol-traits.md`](./ADR-094-deepagents-backend-protocol-traits.md) | 2026-08-20 | | DUPLICATE ×2 — cite as `ADR-94 (deepagents-backend-protocol-traits)` | -| ADR-094 | ADR-094: π.ruv.io Shared Web Memory on RuVector | [`ADR-094-pi-shared-web-memory.md`](./ADR-094-pi-shared-web-memory.md) | 2026-08-20 | Accepted (Implementing) | DUPLICATE ×2 — cite as `ADR-94 (pi-shared-web-memory)` | -| ADR-095 | ADR-095: Middleware Pipeline Architecture | [`ADR-095-deepagents-middleware-pipeline.md`](./ADR-095-deepagents-middleware-pipeline.md) | 2026-08-20 | | DUPLICATE ×2 — cite as `ADR-95 (deepagents-middleware-pipeline)` | -| ADR-095 | ADR-095: π.ruv.io API v2 — Full Capability Surface | [`ADR-095-pi-api-v2-capabilities.md`](./ADR-095-pi-api-v2-capabilities.md) | 2026-08-20 | Accepted | DUPLICATE ×2 — cite as `ADR-95 (pi-api-v2-capabilities)` | -| ADR-096 | ADR-096: Cloud-Native Data Pipeline, Real-Time Injection & Automated Optimization | [`ADR-096-cloud-pipeline-realtime-optimization.md`](./ADR-096-cloud-pipeline-realtime-optimization.md) | 2026-08-20 | Accepted | DUPLICATE ×2 — cite as `ADR-96 (cloud-pipeline-realtime-optimization)` | -| ADR-096 | ADR-096: Tool System — Filesystem, Execute, Grep, Glob | [`ADR-096-deepagents-tool-system.md`](./ADR-096-deepagents-tool-system.md) | 2026-08-20 | | DUPLICATE ×2 — cite as `ADR-96 (deepagents-tool-system)` | -| ADR-097 | ADR-097: SubAgent & Task Orchestration | [`ADR-097-deepagents-subagent-orchestration.md`](./ADR-097-deepagents-subagent-orchestration.md) | 2026-08-20 | | | -| ADR-098 | ADR-098: Memory, Skills & Summarization Middleware | [`ADR-098-deepagents-memory-skills-summarization.md`](./ADR-098-deepagents-memory-skills-summarization.md) | 2026-08-20 | | | -| ADR-099 | ADR-099: CLI & ACP Server Conversion | [`ADR-099-deepagents-cli-acp-server.md`](./ADR-099-deepagents-cli-acp-server.md) | 2026-08-20 | | | -| ADR-100 | ADR-100: RVF Integration & Crate Structure | [`ADR-100-deepagents-rvf-integration-crate-structure.md`](./ADR-100-deepagents-rvf-integration-crate-structure.md) | 2026-08-20 | | | -| ADR-101 | ADR-101: Testing Strategy & Fidelity Verification | [`ADR-101-deepagents-testing-strategy.md`](./ADR-101-deepagents-testing-strategy.md) | 2026-08-20 | | | -| ADR-102 | ADR-102: Implementation Roadmap & Phasing | [`ADR-102-deepagents-implementation-roadmap.md`](./ADR-102-deepagents-implementation-roadmap.md) | 2026-08-20 | | | -| ADR-103 | ADR-103: Review Amendments — Performance, RVF Integration & Security Hardening | [`ADR-103-deepagents-review-amendments.md`](./ADR-103-deepagents-review-amendments.md) | 2026-08-20 | | | -| ADR-104 | ADR-104: rvAgent MCP Tools/Resources, Enhanced Skills, and Topology-Aware Deployment | [`ADR-104-rvagent-mcp-skills-topology.md`](./ADR-104-rvagent-mcp-skills-topology.md) | 2026-08-20 | | | -| ADR-105 | ADR-104: rvAgent MCP Tools and Resources System | [`ADR-105-rvagent-mcp-implementation-details.md`](./ADR-105-rvagent-mcp-implementation-details.md) | 2026-08-20 | | | -| ADR-106 | ADR-106: RuVix Kernel Integration with RVF | [`ADR-106-ruvix-kernel-rvf-integration.md`](./ADR-106-ruvix-kernel-rvf-integration.md) | 2026-08-20 | | | -| ADR-107 | ADR-107: rvAgent Native Swarm Orchestration with WASM Integration | [`ADR-107-rvagent-native-swarm-wasm.md`](./ADR-107-rvagent-native-swarm-wasm.md) | 2026-08-20 | | | -| ADR-108 | ADR-108: rvAgent–ruvbot Integration Architecture | [`ADR-108-rvagent-ruvbot-integration.md`](./ADR-108-rvagent-ruvbot-integration.md) | 2026-08-20 | | | -| ADR-109 | ADR-109: Backup and Disaster Recovery Strategy | [`ADR-109-backup-disaster-recovery.md`](./ADR-109-backup-disaster-recovery.md) | 2026-08-20 | Accepted, Implemented | | -| ADR-110 | ADR-110: Neural-Symbolic Integration with Internal Voice | [`ADR-110-neural-symbolic-internal-voice.md`](./ADR-110-neural-symbolic-internal-voice.md) | 2026-08-20 | In Progress | | -| ADR-111 | ADR-111: Ruvocal UI Integration with rvAgent | [`ADR-111-ruvocal-ui-rvagent-integration.md`](./ADR-111-ruvocal-ui-rvagent-integration.md) | 2026-08-20 | | | -| ADR-112 | ADR-112: rvAgent MCP Server with SSE and stdio Transports | [`ADR-112-rvagent-mcp-server.md`](./ADR-112-rvagent-mcp-server.md) | 2026-08-20 | | | -| ADR-113 | ADR-113: RVF App Gallery and Ruvix-Powered Applications | [`ADR-113-rvf-app-gallery-ruvix-applications.md`](./ADR-113-rvf-app-gallery-ruvix-applications.md) | 2026-08-20 | | | -| ADR-114 | ADR-114: Ruvector-Core Hash Placeholder Embeddings | [`ADR-114-ruvector-core-hash-placeholders.md`](./ADR-114-ruvector-core-hash-placeholders.md) | 2026-08-20 | Accepted | | -| ADR-115 | ADR-115: Common Crawl Integration with Semantic Compression | [`ADR-115-common-crawl-temporal-compression.md`](./ADR-115-common-crawl-temporal-compression.md) | 2026-08-20 | Phase 1 Implemented | | -| ADR-116 | ADR-116: Spectral Graph Sparsifier Integration with pi.ruv.io | [`ADR-116-spectral-sparsifier-brain-integration.md`](./ADR-116-spectral-sparsifier-brain-integration.md) | 2026-08-20 | Accepted | | -| ADR-117 | ADR-117: Pseudo-Deterministic Canonical Minimum Cut | [`ADR-117-canonical-mincut-pseudo-deterministic.md`](./ADR-117-canonical-mincut-pseudo-deterministic.md) | 2026-08-20 | Shipped (all 3 tiers) | DUPLICATE ×2 — cite as `ADR-117 (canonical-mincut-pseudo-deterministic)` | -| ADR-117 | ADR-117: DrAgnes Dermatology Intelligence Platform | [`ADR-117-dragnes-dermatology-intelligence-platform.md`](./ADR-117-dragnes-dermatology-intelligence-platform.md) | 2026-08-20 | Proposed | DUPLICATE ×2 — cite as `ADR-117 (dragnes-dermatology-intelligence-platform)` | -| ADR-118 | ADR-118: Cost-Effective Common Crawl Strategy with Sparsifier-Aware Guardrails | [`ADR-118-cost-effective-crawl-strategy.md`](./ADR-118-cost-effective-crawl-strategy.md) | 2026-08-20 | Phase 1 Active | | -| ADR-119 | ADR-119: Historical Common Crawl Evolutionary Comparison | [`ADR-119-historical-crawl-evolutionary-comparison.md`](./ADR-119-historical-crawl-evolutionary-comparison.md) | 2026-08-20 | Accepted | | -| ADR-120 | ADR-120: WET Processing Pipeline for Medical + CS Corpus Import | [`ADR-120-wet-processing-pipeline.md`](./ADR-120-wet-processing-pipeline.md) | 2026-08-20 | Phase 1 Deployed | | -| ADR-121 | ADR-121: Gemini Google Search Grounding for Brain Optimizer | [`ADR-121-gemini-grounding-integration.md`](./ADR-121-gemini-grounding-integration.md) | 2026-08-20 | Implemented | | -| ADR-122 | ADR-122: rvAgent Autonomous Gemini Grounding Agents | [`ADR-122-rvagent-gemini-grounding-agents.md`](./ADR-122-rvagent-gemini-grounding-agents.md) | 2026-08-20 | Approved with Revisions | | -| ADR-123 | ADR-123: Pi Brain Cognitive Enrichment | [`ADR-123-brain-cognitive-enrichment.md`](./ADR-123-brain-cognitive-enrichment.md) | 2026-08-20 | Accepted | | -| ADR-124 | ADR-124: Dynamic MinCut with Partition Cache | [`ADR-124-dynamic-partition-cache.md`](./ADR-124-dynamic-partition-cache.md) | 2026-08-20 | Shipped — All 3 tiers shipped and deployed through ruvbrain-00130 | | -| ADR-125 | ADR-125: Resend Email Integration for Pi Brain Notifications | [`ADR-125-resend-email-brain-integration.md`](./ADR-125-resend-email-brain-integration.md) | 2026-08-20 | Proposed | | -| ADR-126 | ADR-126: Google Chat Bot for Pi Brain Interaction | [`ADR-126-google-chat-brain-integration.md`](./ADR-126-google-chat-brain-integration.md) | 2026-08-20 | Proposed | | -| ADR-127 | ADR-127: Gist Deep Research Loop — Brain-Guided Discovery Publishing | [`ADR-127-gist-deep-research-loop.md`](./ADR-127-gist-deep-research-loop.md) | 2026-08-20 | Implemented | | -| ADR-128 | ADR-128: SOTA Gap Implementations — Hybrid Search, MLA, KV-Cache, SSM, Graph RAG | [`ADR-128-sota-gap-implementations.md`](./ADR-128-sota-gap-implementations.md) | 2026-08-20 | Accepted | | -| ADR-129 | ADR-129: RuvLTRA Model Training & TurboQuant Optimization on Google Cloud | [`ADR-129-ruvltra-gcloud-training-turboquant.md`](./ADR-129-ruvltra-gcloud-training-turboquant.md) | 2026-08-20 | Accepted — Phase 1 (calibration) deployed and executing. Governance and release | | -| ADR-130 | ADR-130: MCP SSE Decoupling via Midstream Queue Architecture | [`ADR-130-mcp-sse-decoupling-midstream-queue.md`](./ADR-130-mcp-sse-decoupling-midstream-queue.md) | 2026-08-20 | **Deployed** (2026-04-02) — Phases 1-3 complete. SSE decoupled to `mcp.pi.ruv.io | | -| ADR-131 | ADR-131: Consciousness Metrics Crate — IIT 4.0 Φ, CES, ΦID, PID, Streaming, Bounds | [`ADR-131-consciousness-metrics-crate.md`](./ADR-131-consciousness-metrics-crate.md) | 2026-08-20 | Accepted (Updated) | | -| ADR-132 | ADR-132: E2E Browser Testing with @claude-flow/browser | [`ADR-132-e2e-browser-testing-claude-flow.md`](./ADR-132-e2e-browser-testing-claude-flow.md) | 2026-08-20 | Proposed | DUPLICATE ×2 — cite as `ADR-132 (e2e-browser-testing-claude-flow)` | -| ADR-132 | ADR-132: RVM Hypervisor Core — Standalone Coherence-Native Microhypervisor | [`ADR-132-ruvix-hypervisor-core.md`](./ADR-132-ruvix-hypervisor-core.md) | 2026-08-20 | Proposed | DUPLICATE ×2 — cite as `ADR-132 (ruvix-hypervisor-core)` | -| ADR-133 | ADR-133: Claude Code CLI Source Code Analysis | [`ADR-133-claude-code-source-analysis.md`](./ADR-133-claude-code-source-analysis.md) | 2026-08-20 | Deployed (2026-04-02) | DUPLICATE ×2 — cite as `ADR-133 (claude-code-source-analysis)` | -| ADR-133 | ADR-133: Partition Object Model | [`ADR-133-partition-object-model.md`](./ADR-133-partition-object-model.md) | 2026-08-20 | Proposed | DUPLICATE ×2 — cite as `ADR-133 (partition-object-model)` | -| ADR-134 | ADR-134: RuVector Deep Integration with Claude Code CLI | [`ADR-134-ruvector-claude-code-deep-integration.md`](./ADR-134-ruvector-claude-code-deep-integration.md) | 2026-08-20 | Proposed | DUPLICATE ×2 — cite as `ADR-134 (ruvector-claude-code-deep-integration)` | -| ADR-134 | ADR-134: Witness Schema and Log Format | [`ADR-134-witness-schema-log-format.md`](./ADR-134-witness-schema-log-format.md) | 2026-08-20 | Proposed | DUPLICATE ×2 — cite as `ADR-134 (witness-schema-log-format)` | -| ADR-135 | ADR-135: MinCut Decompiler with RVF Witness Chains | [`ADR-135-mincut-decompiler-with-witness-chains.md`](./ADR-135-mincut-decompiler-with-witness-chains.md) | 2026-08-20 | Deployed (2026-04-03) — 8-phase pipeline implemented. Louvain partitioning (35x | DUPLICATE ×2 — cite as `ADR-135 (mincut-decompiler-with-witness-chains)` | -| ADR-135 | ADR-135: Proof Verifier Design — Three-Layer Verification for Capability-Gated Mutation | [`ADR-135-proof-verifier-design.md`](./ADR-135-proof-verifier-design.md) | 2026-08-20 | Proposed | DUPLICATE ×2 — cite as `ADR-135 (proof-verifier-design)` | -| ADR-136 | ADR-136: GPU-Trained Deobfuscation Model | [`ADR-136-gpu-trained-deobfuscation-model.md`](./ADR-136-gpu-trained-deobfuscation-model.md) | 2026-08-20 | Deployed (2026-04-03) — Model trained (673K params, 95.7% val accuracy), exporte | DUPLICATE ×2 — cite as `ADR-136 (gpu-trained-deobfuscation-model)` | -| ADR-136 | ADR-136: Memory Hierarchy and Reconstruction — Four-Tier Coherence-Driven Memory Model | [`ADR-136-memory-hierarchy-reconstruction.md`](./ADR-136-memory-hierarchy-reconstruction.md) | 2026-08-20 | Proposed | DUPLICATE ×2 — cite as `ADR-136 (memory-hierarchy-reconstruction)` | -| ADR-137 | ADR-137: Bare-Metal Boot Sequence | [`ADR-137-bare-metal-boot-sequence.md`](./ADR-137-bare-metal-boot-sequence.md) | 2026-08-20 | Proposed | DUPLICATE ×2 — cite as `ADR-137 (bare-metal-boot-sequence)` | -| ADR-137 | ADR-137: npm Decompiler CLI and MCP Tools | [`ADR-137-npm-decompiler-cli-and-mcp.md`](./ADR-137-npm-decompiler-cli-and-mcp.md) | 2026-08-20 | Deployed (2026-04-03) — CLI command + 6 MCP tools implemented. Decompiler librar | DUPLICATE ×2 — cite as `ADR-137 (npm-decompiler-cli-and-mcp)` | -| ADR-138 | ADR-138: LLM Model Weight Decompiler | [`ADR-138-llm-weight-decompiler.md`](./ADR-138-llm-weight-decompiler.md) | 2026-08-20 | Implemented (2026-04-03) -- GGUF and Safetensors format decompilation with archi | DUPLICATE ×2 — cite as `ADR-138 (llm-weight-decompiler)` | -| ADR-138 | ADR-138: Seed Hardware Bring-Up | [`ADR-138-seed-hardware-bring-up.md`](./ADR-138-seed-hardware-bring-up.md) | 2026-08-20 | Proposed | DUPLICATE ×2 — cite as `ADR-138 (seed-hardware-bring-up)` | -| ADR-139 | ADR-139: Appliance Deployment Model — Edge Hub with Coherence-Native Control | [`ADR-139-appliance-deployment-model.md`](./ADR-139-appliance-deployment-model.md) | 2026-08-20 | Proposed | DUPLICATE ×2 — cite as `ADR-139 (appliance-deployment-model)` | -| ADR-139 | ADR-139: RVAgent Optimization Using Decompiled Claude Code Intelligence | [`ADR-139-rvagent-claude-code-optimization.md`](./ADR-139-rvagent-claude-code-optimization.md) | 2026-08-20 | Proposed | DUPLICATE ×2 — cite as `ADR-139 (rvagent-claude-code-optimization)` | -| ADR-140 | ADR-140: Agent Runtime Adapter — WASM Agents in Coherence Domains | [`ADR-140-agent-runtime-adapter.md`](./ADR-140-agent-runtime-adapter.md) | 2026-08-20 | Proposed | | -| ADR-141 | ADR-141: Coherence Engine — Kernel Integration and Runtime Pipeline | [`ADR-141-coherence-engine-kernel-integration.md`](./ADR-141-coherence-engine-kernel-integration.md) | 2026-08-20 | Accepted | | -| ADR-142 | ADR-142: TEE-Backed Cryptographic Verification for the RVM Hypervisor | [`ADR-142-tee-backed-cryptographic-verification.md`](./ADR-142-tee-backed-cryptographic-verification.md) | 2026-08-20 | Accepted | | -| ADR-143 | ADR-143: HEARmusica — High-Fidelity Rust Port of Tympan Open-Source Hearing Aid | [`ADR-143-hearmusica-tympan-rust-port.md`](./ADR-143-hearmusica-tympan-rust-port.md) | 2026-08-20 | Accepted | DUPLICATE ×2 — cite as `ADR-143 (hearmusica-tympan-rust-port)` | -| ADR-143 | ADR-143: Implement Missing Capabilities in ruvector | [`ADR-143-implement-missing-capabilities.md`](./ADR-143-implement-missing-capabilities.md) | 2026-08-20 | Accepted | DUPLICATE ×2 — cite as `ADR-143 (implement-missing-capabilities)` | -| ADR-144 | ADR-144: Candle-Whisper Integration with Musica for Pure-Rust Transcription | [`ADR-144-candle-whisper-musica-transcription.md`](./ADR-144-candle-whisper-musica-transcription.md) | 2026-08-20 | Accepted | DUPLICATE ×3 — cite as `ADR-144 (candle-whisper-musica-transcription)` | -| ADR-144 | ADR-144: DiskANN/Vamana Implementation | [`ADR-144-diskann-vamana-implementation.md`](./ADR-144-diskann-vamana-implementation.md) | 2026-08-20 | Implemented | DUPLICATE ×3 — cite as `ADR-144 (diskann-vamana-implementation)` | -| ADR-144 | ADR-144: Monorepo Quality Analysis Strategy and Test Plan | [`ADR-144-monorepo-quality-analysis-strategy.md`](./ADR-144-monorepo-quality-analysis-strategy.md) | 2026-08-20 | Accepted | DUPLICATE ×3 — cite as `ADR-144 (monorepo-quality-analysis-strategy)` | -| ADR-145 | ADR-145: WASM/NAPI Training Pipeline Fixes | [`ADR-145-wasm-training-pipeline-fixes.md`](./ADR-145-wasm-training-pipeline-fixes.md) | 2026-08-20 | Accepted | | -| ADR-146 | ADR-144: DiskANN/Vamana Implementation | [`ADR-146-diskann-vamana-implementation.md`](./ADR-146-diskann-vamana-implementation.md) | 2026-08-20 | Implemented | | -| ADR-147 | ADR-147: Stacked KV Cache Compression: TriAttention + TurboQuant Pipeline | [`ADR-147-stacked-kv-cache-triattention-turboquant.md`](./ADR-147-stacked-kv-cache-triattention-turboquant.md) | 2026-08-20 | Proposed | | -| ADR-148 | ADR-148: Brain Hypothesis Engine — Self-Improving Knowledge System with Gemini, DiskANN, and Auto-Experimentation | [`ADR-148-brain-hypothesis-engine.md`](./ADR-148-brain-hypothesis-engine.md) | 2026-08-20 | Proposed | | -| ADR-149 | ADR-149: Brain Performance Optimizations — SIMD Search, Batch Graph, Incremental LoRA, Quality Gating | [`ADR-149-brain-performance-optimizations.md`](./ADR-149-brain-performance-optimizations.md) | 2026-08-20 | Accepted | | -| ADR-150 | ADR-150: π Brain + RuvLtra via Tailscale — Semantic Embedding Upgrade | [`ADR-150-pi-brain-ruvltra-tailscale.md`](./ADR-150-pi-brain-ruvltra-tailscale.md) | 2026-08-20 | Proposed | | -| ADR-151 | ADR-151: Miller-Rabin–Driven Prime Optimizations (PIAL) | [`ADR-151-miller-rabin-prime-optimizations.md`](./ADR-151-miller-rabin-prime-optimizations.md) | 2026-08-20 | Accepted (Phase 0 landed 2026-04-16; performance targets revised — see "Phase 0 | | -| ADR-153 | ADR-153: Kalshi Integration via RuVector Neural Trader | [`ADR-153-kalshi-neural-trader-integration.md`](./ADR-153-kalshi-neural-trader-integration.md) | 2026-08-20 | Proposed | | -| ADR-154 | ADR-154: RaBitQ — Rotation-Based 1-Bit Quantization for ANNS | [`ADR-154-rabitq-rotation-binary-quantization.md`](./ADR-154-rabitq-rotation-binary-quantization.md) | 2026-08-20 | Proposed | | -| ADR-155 | ADR-155: ruLake — Vector-Native Federation Intermediary on RVF | [`ADR-155-rulake-datalake-layer.md`](./ADR-155-rulake-datalake-layer.md) | 2026-08-20 | **Accepted (M1)** — core abstraction + LocalBackend + FsBackend shipped | | -| ADR-156 | ADR-156: ruLake as Memory Substrate for Agent Brain Systems | [`ADR-156-rulake-as-memory-substrate.md`](./ADR-156-rulake-as-memory-substrate.md) | 2026-08-20 | **Proposed** — positioning addendum, not a replacement. ADR-155 still | | -| ADR-157 | ADR-157: Optional Accelerator Plane — `VectorKernel` Trait + Dispatch | [`ADR-157-optional-accelerator-plane.md`](./ADR-157-optional-accelerator-plane.md) | 2026-08-20 | **Proposed** — scaffolding-only decision. No kernel implementations | | -| ADR-158 | ADR-158: Optional Rotation Kind (Haar vs Randomized Hadamard) and QVCache Positioning | [`ADR-158-optional-rotation-and-qvcache-positioning.md`](./ADR-158-optional-rotation-and-qvcache-positioning.md) | 2026-08-20 | **Proposed** — a knob-locking decision plus a positioning statement. | | -| ADR-159 | ADR-159: A2A (Agent-to-Agent) Protocol Support for rvAgent | [`ADR-159-rvagent-a2a-protocol.md`](./ADR-159-rvagent-a2a-protocol.md) | 2026-08-20 | **Proposed — r3 (second review pass 2026-04-24)**. A new subcrate | | -| ADR-160 | ADR-160: ACORN — Predicate-Agnostic Filtered HNSW for ruvector | [`ADR-160-acorn-filtered-hnsw.md`](./ADR-160-acorn-filtered-hnsw.md) | 2026-08-20 | Proposed | | -| ADR-161 | ADR-161: Publish `ruvector-rabitq-wasm` as `@ruvector/rabitq-wasm` on npm | [`ADR-161-rabitq-wasm-npm-package.md`](./ADR-161-rabitq-wasm-npm-package.md) | 2026-08-20 | Proposed | | -| ADR-162 | ADR-162: Add `ruvector-acorn-wasm` crate and publish as `@ruvector/acorn-wasm` on npm | [`ADR-162-acorn-wasm-npm-package.md`](./ADR-162-acorn-wasm-npm-package.md) | 2026-08-20 | Proposed | | -| ADR-165 | ADR-165: Tiny RuvLLM Agents on Heterogeneous ESP32 SoCs | [`ADR-165-tiny-ruvllm-agents-on-esp32-soCs.md`](./ADR-165-tiny-ruvllm-agents-on-esp32-soCs.md) | 2026-08-20 | Proposed | | -| ADR-166 | ADR-166: ESP32 Rust Cross-Compile + Bring-Up Operations Manual | [`ADR-166-esp32-rust-cross-compile-bringup-ops.md`](./ADR-166-esp32-rust-cross-compile-bringup-ops.md) | 2026-08-20 | Proposed | | -| ADR-167 | ADR-167 — ruvector Hailo-8 NPU embedding backend | [`ADR-167-ruvector-hailo-npu-embedding-backend.md`](./ADR-167-ruvector-hailo-npu-embedding-backend.md) | 2026-08-20 | Proposed | | -| ADR-168 | ADR-168 — Cluster CLI surface | [`ADR-168-ruvector-hailo-cluster-cli-surface.md`](./ADR-168-ruvector-hailo-cluster-cli-surface.md) | 2026-08-20 | Accepted | | -| ADR-169 | ADR-169 — Cluster cache architecture | [`ADR-169-ruvector-hailo-cluster-cache-architecture.md`](./ADR-169-ruvector-hailo-cluster-cache-architecture.md) | 2026-08-20 | Accepted | | -| ADR-170 | ADR-170 — Tracing correlation | [`ADR-170-ruvector-hailo-cluster-tracing-correlation.md`](./ADR-170-ruvector-hailo-cluster-tracing-correlation.md) | 2026-08-20 | Accepted | | -| ADR-171 | ADR-171 — ruOS brain + ruview on Pi 5 + Hailo-8 | [`ADR-171-ruos-brain-ruview-pi5-edge-node.md`](./ADR-171-ruos-brain-ruview-pi5-edge-node.md) | 2026-08-20 | Proposed | | -| ADR-172 | ADR-172 — Deep security review | [`ADR-172-ruvector-hailo-security-review.md`](./ADR-172-ruvector-hailo-security-review.md) | 2026-08-20 | Proposed | | -| ADR-173 | ADR-173 — ruvllm + Hailo on Pi 5 | [`ADR-173-ruvllm-hailo-edge-llm.md`](./ADR-173-ruvllm-hailo-edge-llm.md) | 2026-08-20 | Proposed | | -| ADR-174 | ADR-174 — ruOS thermal optimizer | [`ADR-174-ruos-thermal-overclock-pi5.md`](./ADR-174-ruos-thermal-overclock-pi5.md) | 2026-08-20 | Proposed | | -| ADR-175 | ADR-175 — Rust-side workarounds for Hailo Dataflow Compiler transformer-encoder bugs | [`ADR-175-hailo-rust-side-workarounds.md`](./ADR-175-hailo-rust-side-workarounds.md) | 2026-08-20 | accepted | | -| ADR-176 | ADR-176 — EPIC: Wire HEF into HailoEmbedder for NPU-accelerated embeddings | [`ADR-176-hef-integration-epic.md`](./ADR-176-hef-integration-epic.md) | 2026-08-20 | accepted | | -| ADR-177 | ADR-177 — Pi 4 / Pi 5 without AI HAT+ deploy | [`ADR-177-pi4-no-hat-deploy.md`](./ADR-177-pi4-no-hat-deploy.md) | 2026-08-20 | accepted | | -| ADR-178 | ADR-178 — ruvector + ruview / hailo cluster integration gap analysis | [`ADR-178-ruvector-ruview-hailo-integration-gap-analysis.md`](./ADR-178-ruvector-ruview-hailo-integration-gap-analysis.md) | 2026-08-20 | Proposed | | -| ADR-179 | ADR-179 — EPIC: ruvllm LLM inference on Pi 5 cluster | [`ADR-179-ruvllm-pi-cluster-deployment.md`](./ADR-179-ruvllm-pi-cluster-deployment.md) | 2026-08-20 | proposed | | -| ADR-180 | ADR-180 — ServingEngine continuous batching on Pi 5 | [`ADR-180-ruvllm-serving-engine-continuous-batching.md`](./ADR-180-ruvllm-serving-engine-continuous-batching.md) | 2026-08-20 | proposed | | -| ADR-181 | ADR-181 — In-tree pi_quant + BitNet b1.58 on Pi 5 | [`ADR-181-ruvllm-pi-quant-bitnet-integration.md`](./ADR-181-ruvllm-pi-quant-bitnet-integration.md) | 2026-08-20 | proposed | | -| ADR-182 | ADR-182 — Hailo-10H migration for the Pi 5 cluster | [`ADR-182-hailo-10-cluster-migration.md`](./ADR-182-hailo-10-cluster-migration.md) | 2026-08-20 | proposed | | -| ADR-183 | ADR-183 — Move `rand` to dev-dependencies in ruvllm_sparse_attention | [`ADR-183-sparse-attention-rand-dev-dependency.md`](./ADR-183-sparse-attention-rand-dev-dependency.md) | 2026-08-20 | accepted | | -| ADR-184 | ADR-184 — One-pass online softmax in SubquadraticSparseAttention::forward | [`ADR-184-sparse-attention-online-softmax.md`](./ADR-184-sparse-attention-online-softmax.md) | 2026-08-20 | accepted | | -| ADR-185 | ADR-185 — Exclude current block from non-causal landmark candidates | [`ADR-185-sparse-attention-noncausal-landmark-fix.md`](./ADR-185-sparse-attention-noncausal-landmark-fix.md) | 2026-08-20 | accepted | | -| ADR-186 | ADR-186 — Edge-case tests as CI gate before Hailo cluster integration | [`ADR-186-sparse-attention-edge-case-tests.md`](./ADR-186-sparse-attention-edge-case-tests.md) | 2026-08-20 | accepted | | -| ADR-187 | ADR-187 — Overflow-checked shape multiplication in `Tensor3::zeros` | [`ADR-187-tensor-zeros-overflow-check.md`](./ADR-187-tensor-zeros-overflow-check.md) | 2026-08-20 | accepted | | -| ADR-188 | ADR-188 — Document the intentional stamp scheme difference in sparse attention | [`ADR-188-sparse-attention-stamp-scheme-comment.md`](./ADR-188-sparse-attention-stamp-scheme-comment.md) | 2026-08-20 | accepted | | -| ADR-189 | ADR-189 — KV cache incremental decode for sparse attention on Hailo-10H | [`ADR-189-sparse-attention-kv-cache-incremental-decode.md`](./ADR-189-sparse-attention-kv-cache-incremental-decode.md) | 2026-08-20 | accepted | | -| ADR-190 | ADR-190 — Grouped-Query / Multi-Query Attention for Hailo-10H production models | [`ADR-190-sparse-attention-gqa-mqa-support.md`](./ADR-190-sparse-attention-gqa-mqa-support.md) | 2026-08-20 | accepted | | -| ADR-191 | ADR-191 — Pi Zero 2W production hardening for ruvllm_sparse_attention | [`ADR-191-sparse-attention-pi-zero-2w-production-hardening.md`](./ADR-191-sparse-attention-pi-zero-2w-production-hardening.md) | 2026-08-20 | proposed | | -| ADR-192 | ADR-192 — no_std + alloc support for `ruvllm_sparse_attention` | [`ADR-192-sparse-attention-no-std-esp32-support.md`](./ADR-192-sparse-attention-no-std-esp32-support.md) | 2026-08-20 | accepted | | -| ADR-193 | ADR-193 — RAIRS IVF: ruvector's First Inverted File Index Family | [`ADR-193-rairs-ivf.md`](./ADR-193-rairs-ivf.md) | 2026-08-20 | accepted | | -| ADR-194 | ADR-194 — GNN-Enhanced Candidate Reranking for Approximate ANN | [`ADR-194-gnn-rerank.md`](./ADR-194-gnn-rerank.md) | 2026-08-20 | accepted | DUPLICATE ×3 — cite as `ADR-194 (gnn-rerank)` | -| ADR-194 | ADR-194: Proof-Gated Vector Writes with Merkle-Accumulating Witness Logs | [`ADR-194-proof-gated-writes.md`](./ADR-194-proof-gated-writes.md) | 2026-08-20 | Proposed | DUPLICATE ×3 — cite as `ADR-194 (proof-gated-writes)` | -| ADR-194 | ADR-194 — RuVector Bundled ONNX Embedder: API Contract & Throughput | [`ADR-194-ruvector-onnx-embedder-api-and-throughput.md`](./ADR-194-ruvector-onnx-embedder-api-and-throughput.md) | 2026-08-20 | accepted | DUPLICATE ×3 — cite as `ADR-194 (ruvector-onnx-embedder-api-and-throughput)` | -| ADR-195 | ADR-195 — ONNX Embedder Unification Plan | [`ADR-195-ruvector-embedder-unification-plan.md`](./ADR-195-ruvector-embedder-unification-plan.md) | 2026-08-20 | proposed | | -| ADR-196 | ADR-196 — Structure-Preserving Graph Condensation | [`ADR-196-structure-preserving-graph-condensation.md`](./ADR-196-structure-preserving-graph-condensation.md) | 2026-08-20 | accepted | | -| ADR-197 | ADR-197 — Differentiable Min-Cut Condensation Loss | [`ADR-197-differentiable-min-cut-condensation-loss.md`](./ADR-197-differentiable-min-cut-condensation-loss.md) | 2026-08-20 | accepted | | -| ADR-198 | ADR-198 — Physical Perception Substrate | [`ADR-198-physical-perception-substrate.md`](./ADR-198-physical-perception-substrate.md) | 2026-08-20 | accepted | | -| ADR-199 | ADR-199 — Sky Monitor and SkyGraph Appliance | [`ADR-199-sky-monitor-skygraph-appliance.md`](./ADR-199-sky-monitor-skygraph-appliance.md) | 2026-08-20 | proposed | | -| ADR-202 | ADR-202 — Fixed-Topology Reuse + Periodic Rebuild on a Real Learned-GNN Trajectory | [`ADR-202-reuse-under-drift-real-gnn-trajectory.md`](./ADR-202-reuse-under-drift-real-gnn-trajectory.md) | 2026-08-20 | proposed | | -| ADR-205 | ADR-205 — Triangle-Inequality Cluster Pruning vs Tuned Plain IVF `nprobe` (Structural NO-GO) | [`ADR-205-region-pruned-ivf-vs-plain-ivf-nprobe.md`](./ADR-205-region-pruned-ivf-vs-plain-ivf-nprobe.md) | 2026-08-20 | proposed | | -| ADR-206 | ADR-206 — PQ/IVFADC Within-List Pruning vs Tuned Plain IVF `nprobe` (Scale-Gated WIN) | [`ADR-206-pq-ivfadc-within-list-pruning-vs-plain-ivf-nprobe.md`](./ADR-206-pq-ivfadc-within-list-pruning-vs-plain-ivf-nprobe.md) | 2026-08-20 | proposed | | -| ADR-210 | ADR-210: Default-On Semantic Embeddings — all-MiniLM-L6-v2 as the Intelligence Engine's Primary Embedder | [`ADR-210-default-on-semantic-embeddings-minilm.md`](./ADR-210-default-on-semantic-embeddings-minilm.md) | 2026-08-20 | accepted (with hardening edits, review of 2026-06-12) | | -| ADR-211 | ADR-211 — Temporal Coherence Decay for Agent Memory Retrieval | [`ADR-211-temporal-coherence-agent-memory.md`](./ADR-211-temporal-coherence-agent-memory.md) | 2026-08-20 | accepted | | -| ADR-251 | ADR-251: Agentic Time as a First-Class Runtime Primitive | [`ADR-251-agentic-time.md`](./ADR-251-agentic-time.md) | 2026-08-20 | proposed | | -| ADR-252 | ADR-252: Coherence-Weighted Agent Memory Compaction | [`ADR-252-agent-memory-compaction.md`](./ADR-252-agent-memory-compaction.md) | 2026-08-20 | Proposed | DUPLICATE ×3 — cite as `ADR-252 (agent-memory-compaction)` | -| ADR-252 | ADR-252: FastGRNN Training Pipeline for Tiny Dancer Routing | [`ADR-252-fastgrnn-training-pipeline.md`](./ADR-252-fastgrnn-training-pipeline.md) | 2026-08-20 | accepted | DUPLICATE ×3 — cite as `ADR-252 (fastgrnn-training-pipeline)` | -| ADR-252 | ADR-252: Multi-Vector MaxSim Late Interaction Search | [`ADR-252-multi-vector-maxsim.md`](./ADR-252-multi-vector-maxsim.md) | 2026-08-20 | Accepted — PoC merged, production graduation pending | DUPLICATE ×3 — cite as `ADR-252 (multi-vector-maxsim)` | -| ADR-253 | ADR-253 — HelixDB vs RuVector: Comparative Analysis and Improvement Opportunities | [`ADR-253-helixdb-comparison-ruvector-improvements.md`](./ADR-253-helixdb-comparison-ruvector-improvements.md) | 2026-08-20 | proposed | | -| ADR-254 | ADR-254 — Coherence-Gated HNSW Search | [`ADR-254-coherence-hnsw-search.md`](./ADR-254-coherence-hnsw-search.md) | 2026-08-20 | proposed | DUPLICATE ×2 — cite as `ADR-254 (coherence-hnsw-search)` | -| ADR-254 | ADR-254 — ruvector-turbovec: a multi-bit TurboQuant FastScan ANN index | [`ADR-254-ruvector-turbovec-fastscan-index.md`](./ADR-254-ruvector-turbovec-fastscan-index.md) | 2026-08-20 | accepted | DUPLICATE ×2 — cite as `ADR-254 (ruvector-turbovec-fastscan-index)` | -| ADR-255 | ADR-255 — ruvector ↔ OIA Model integration (Open Intelligence Architecture v0.1) | [`ADR-255-oia-model-integration.md`](./ADR-255-oia-model-integration.md) | 2026-08-20 | proposed | | -| ADR-256 | ADR-256 — Hybrid Sparse-Dense Search: RRF and RSF alongside ScoreFusion | [`ADR-256-hybrid-sparse-dense-search.md`](./ADR-256-hybrid-sparse-dense-search.md) | 2026-08-20 | proposed | DUPLICATE ×2 — cite as `ADR-256 (hybrid-sparse-dense-search)` | -| ADR-256 | ADR-256 — Borrowing `metaharness` concepts into `npx ruvector` | [`ADR-256-metaharness-sdk-evaluation.md`](./ADR-256-metaharness-sdk-evaluation.md) | 2026-08-20 | proposed | DUPLICATE ×2 — cite as `ADR-256 (metaharness-sdk-evaluation)` | -| ADR-257 | ADR-257 — Extract `ruqu` and `rvdna` into standalone repos (git submodules) | [`ADR-257-ruqu-rvdna-standalone-submodules.md`](./ADR-257-ruqu-rvdna-standalone-submodules.md) | 2026-08-20 | proposed | | -| ADR-258 | ADR-258 — ruvector-hnsw-repair: Pluggable HNSW Deletion Strategies | [`ADR-258-hnsw-delete-repair.md`](./ADR-258-hnsw-delete-repair.md) | 2026-08-20 | accepted | DUPLICATE ×2 — cite as `ADR-258 (hnsw-delete-repair)` | -| ADR-258 | ADR-258: GPU Optimization of RDT/OpenMythos ACT Halting Loop | [`ADR-258-ruvllm-rdt-gpu-optimization.md`](./ADR-258-ruvllm-rdt-gpu-optimization.md) | 2026-08-20 | Accepted | DUPLICATE ×2 — cite as `ADR-258 (ruvllm-rdt-gpu-optimization)` | -| ADR-259 | ADR-259: ruvllm as Local Mutator Backend for Darwin Mode | [`ADR-259-ruvllm-darwin-mode-local-mutator.md`](./ADR-259-ruvllm-darwin-mode-local-mutator.md) | 2026-08-20 | Implemented (code + unit tests + CLI; the download-path bugs that blocked the li | | -| ADR-260 | ADR-260: Darwin Mode as Evolutionary Substrate for MetaHarness | [`ADR-260-darwin-mode-metaharness-integration.md`](./ADR-260-darwin-mode-metaharness-integration.md) | 2026-08-20 | Accepted | DUPLICATE ×2 — cite as `ADR-260 (darwin-mode-metaharness-integration)` | -| ADR-260 | ADR-260: PhotonLayer — Learned-Optical-Frontend Computing Simulator | [`ADR-260-photonlayer-optical-computing-simulator.md`](./ADR-260-photonlayer-optical-computing-simulator.md) | 2026-08-20 | Proposed | DUPLICATE ×2 — cite as `ADR-260 (photonlayer-optical-computing-simulator)` | -| ADR-261 | ADR-261: PhotonLayer — Mask Exchange Format & Determinism Invariant | [`ADR-261-photonlayer-mask-exchange-and-determinism.md`](./ADR-261-photonlayer-mask-exchange-and-determinism.md) | 2026-08-20 | Proposed | | -| ADR-262 | ADR-262: PhotonLayer — Privacy-Preserving Optical Verification | [`ADR-262-photonlayer-privacy-preserving-optical-verification.md`](./ADR-262-photonlayer-privacy-preserving-optical-verification.md) | 2026-08-20 | Proposed | | -| ADR-263 | ADR-263 — PhotonLayer FiberGate | [`ADR-263-photonlayer-fibergate-transmission-matrix.md`](./ADR-263-photonlayer-fibergate-transmission-matrix.md) | 2026-08-20 | proposed | | -| ADR-264 | ADR-264: LSM-ANN — Write-Optimised Streaming Vector Index for Agent Memory | [`ADR-264-lsm-ann.md`](./ADR-264-lsm-ann.md) | 2026-08-20 | Accepted | DUPLICATE ×3 — cite as `ADR-264 (lsm-ann)` | -| ADR-264 | ADR-264: Matryoshka-Aware Coarse-to-Fine Vector Search | [`ADR-264-matryoshka-coarse-fine-search.md`](./ADR-264-matryoshka-coarse-fine-search.md) | 2026-08-20 | Proposed | DUPLICATE ×3 — cite as `ADR-264 (matryoshka-coarse-fine-search)` | -| ADR-264 | ADR-264: Product Quantization with Asymmetric Distance Computation | [`ADR-264-pq-adc-search.md`](./ADR-264-pq-adc-search.md) | 2026-08-20 | Proposed | DUPLICATE ×3 — cite as `ADR-264 (pq-adc-search)` | -| ADR-265 | ADR-265: RuVector Comprehensive Benchmark Suite | [`ADR-265-ruvector-comprehensive-benchmark-suite.md`](./ADR-265-ruvector-comprehensive-benchmark-suite.md) | 2026-08-20 | Accepted | | -| ADR-266 | ADR-266: MetaHarness Integration for Autonomous ANN Optimization (Darwin Mode) | [`ADR-266-metaharness-darwin-ann-optimization.md`](./ADR-266-metaharness-darwin-ann-optimization.md) | 2026-08-20 | Accepted | DUPLICATE ×2 — cite as `ADR-266 (metaharness-darwin-ann-optimization)` | -| ADR-266 | ADR-266: MetaHarness Integration for Autonomous ANN Optimization (Darwin Mode) | [`ADR-266-metaharness-darwin-integration.md`](./ADR-266-metaharness-darwin-integration.md) | 2026-08-20 | Accepted | DUPLICATE ×2 — cite as `ADR-266 (metaharness-darwin-integration)` | -| ADR-267 | ADR-267: SOTA Validation Protocol for RuVector | [`ADR-267-sota-validation-protocol.md`](./ADR-267-sota-validation-protocol.md) | 2026-08-20 | Accepted | | -| ADR-268 | ADR-268: Capability-Gated ANN Search | [`ADR-268-capability-gated-ann.md`](./ADR-268-capability-gated-ann.md) | 2026-08-20 | Proposed | DUPLICATE ×2 — cite as `ADR-268 (capability-gated-ann)` | -| ADR-268 | ADR-268 — SPANN Partition Spilling: Boundary-Safe ANN | [`ADR-268-spann-partition-spill.md`](./ADR-268-spann-partition-spill.md) | 2026-08-20 | accepted | DUPLICATE ×2 — cite as `ADR-268 (spann-partition-spill)` | -| ADR-269 | ADR-269: MRAgent Graph Memory over RuVector, Optimized by Darwin Mode | [`ADR-269-mragent-graph-memory-darwin-optimization.md`](./ADR-269-mragent-graph-memory-darwin-optimization.md) | 2026-08-20 | Accepted | | -| ADR-270 | ADR-270: Self-Reconstructing Graph Memory — Beyond MRAgent | [`ADR-270-self-reconstructing-graph-memory-beyond-sota.md`](./ADR-270-self-reconstructing-graph-memory-beyond-sota.md) | 2026-08-20 | Accepted | | -| ADR-271 | ADR-271: Metaharness-Darwin for SONA Self-Improvement — EWC Config Evolution, the weightAdapter Gene, and Ornith-1.0 Reward-Hacking Defenses | [`ADR-271-metaharness-darwin-sona-self-improvement.md`](./ADR-271-metaharness-darwin-sona-self-improvement.md) | 2026-08-20 | Proposed (all four components prototyped — PR #615) | | -| ADR-272 | ADR-272: Adaptive Recall-Targeted ANN Search | [`ADR-272-adaptive-recall-ann.md`](./ADR-272-adaptive-recall-ann.md) | 2026-08-20 | Proposed | DUPLICATE ×5 — cite as `ADR-272 (adaptive-recall-ann)` | -| ADR-272 | ADR-272: Bounded Context RAG via MinCut Graph Partitioning | [`ADR-272-bounded-rag-mincut.md`](./ADR-272-bounded-rag-mincut.md) | 2026-08-20 | Proposed | DUPLICATE ×5 — cite as `ADR-272 (bounded-rag-mincut)` | -| ADR-272 | ADR-272: Diverse Beam ANN — MMR Post-Reranking and Coherence-Pruned Beam Search | [`ADR-272-diverse-beam-ann.md`](./ADR-272-diverse-beam-ann.md) | 2026-08-20 | Proposed (implemented and benchmarked — `crates/ruvector-diverse-beam`) | DUPLICATE ×5 — cite as `ADR-272 (diverse-beam-ann)` | -| ADR-272 | ADR-272: Recall-Bounded Approximate Nearest-Neighbour Search | [`ADR-272-recall-bounded-ann.md`](./ADR-272-recall-bounded-ann.md) | 2026-08-20 | Proposed — proof-of-concept in `crates/ruvector-recall-bounded` | DUPLICATE ×5 — cite as `ADR-272 (recall-bounded-ann)` | -| ADR-272 | ADR-272: Speculative ANN Search | [`ADR-272-speculative-ann-search.md`](./ADR-272-speculative-ann-search.md) | 2026-08-20 | Proposed | DUPLICATE ×5 — cite as `ADR-272 (speculative-ann-search)` | -| ADR-273 | ADR-273 — rvAgent Harness Reliability Floor | [`ADR-273-rvagent-harness-reliability-floor.md`](./ADR-273-rvagent-harness-reliability-floor.md) | 2026-08-20 | accepted | | -| ADR-274 | ADR-274 — rvAgent Context Management: Masking over Summarization | [`ADR-274-rvagent-context-management.md`](./ADR-274-rvagent-context-management.md) | 2026-08-20 | accepted | | -| ADR-275 | ADR-275 — rvAgent Subagent Topology: Single Writer with Auxiliary Intelligence | [`ADR-275-rvagent-subagent-topology.md`](./ADR-275-rvagent-subagent-topology.md) | 2026-08-20 | accepted | | -| ADR-276 | ADR-276 — rvAgent Learning Loop: Gating, Trust Tiers and Measurement | [`ADR-276-rvagent-learning-loop-gating.md`](./ADR-276-rvagent-learning-loop-gating.md) | 2026-08-20 | accepted | | -| ADR-277 | ADR-277 — rvAgent Positioning, Protocols and Benchmark Claims | [`ADR-277-rvagent-positioning-and-claims.md`](./ADR-277-rvagent-positioning-and-claims.md) | 2026-08-20 | accepted | | -| ADR-278 | ADR-278 — rvAgent Self-Learning: Adopt the metaharness Flywheel; Shift from Memory to Policy | [`ADR-278-rvagent-flywheel-adoption.md`](./ADR-278-rvagent-flywheel-adoption.md) | 2026-08-20 | accepted | | -| ADR-279 | ADR-279 — No C in the Core; and the 2026 SOTA Program | [`ADR-279-no-c-and-the-sota-program.md`](./ADR-279-no-c-and-the-sota-program.md) | 2026-08-20 | accepted | | -| ADR-280 | ADR-280: Durable Metadata for Self-Contained RVF Artifacts | [`ADR-280-rvf-durable-self-contained-metadata.md`](./ADR-280-rvf-durable-self-contained-metadata.md) | 2026-08-20 | Proposed | | -| ADR-281 | ADR-281: Role-Aware Embedding APIs for Asymmetric Retrieval | [`ADR-281-role-aware-embedding-apis.md`](./ADR-281-role-aware-embedding-apis.md) | 2026-08-20 | Proposed | | -| ADR-282 | ADR-282: Pre-PR Quality Gate for Nightly “Dream” Research | [`ADR-282-nightly-research-quality-gate.md`](./ADR-282-nightly-research-quality-gate.md) | 2026-08-20 | Proposed | | -| ADR-283 | ADR-283: RVForge — One Canonical RVF to Signed Platform Installers | [`ADR-283-rvf-forge-canonical-installer-pipeline.md`](./ADR-283-rvf-forge-canonical-installer-pipeline.md) | 2026-08-20 | Accepted | | -| ADR-284 | ADR-284: RVF Execution Contract for RVM Backends | [`ADR-284-rvf-execution-contract.md`](./ADR-284-rvf-execution-contract.md) | 2026-08-20 | Accepted | | -| ADR-285 | ADR-285: Hosted RVM Security Boundary | [`ADR-285-hosted-rvm-security-boundary.md`](./ADR-285-hosted-rvm-security-boundary.md) | 2026-08-20 | Accepted | | -| ADR-286 | ADR-286: RVF Capability Schema Mapping into `rvm-cap` | [`ADR-286-rvf-capability-schema-mapping.md`](./ADR-286-rvf-capability-schema-mapping.md) | 2026-08-20 | Accepted | | -| ADR-287 | ADR-287: WASM Component Model Integration for the RVM Runtime | [`ADR-287-wasm-component-model-integration.md`](./ADR-287-wasm-component-model-integration.md) | 2026-08-20 | Proposed | | -| ADR-288 | ADR-288: Immutable Base RVF and Encrypted State Delta Lifecycle | [`ADR-288-immutable-base-state-delta-lifecycle.md`](./ADR-288-immutable-base-state-delta-lifecycle.md) | 2026-08-20 | Accepted | | -| ADR-289 | ADR-289: Desktop Host Adapters, Lifecycle CLI, and Embedding Surfaces | [`ADR-289-desktop-host-adapters.md`](./ADR-289-desktop-host-adapters.md) | 2026-08-20 | Accepted | | -| ADR-290 | ADR-290: Forge Build and Signing Trust Boundary | [`ADR-290-forge-build-signing-trust-boundary.md`](./ADR-290-forge-build-signing-trust-boundary.md) | 2026-08-20 | Proposed | | -| ADR-291 | ADR-291: Runtime Compatibility and Version Negotiation | [`ADR-291-runtime-compatibility-version-negotiation.md`](./ADR-291-runtime-compatibility-version-negotiation.md) | 2026-08-20 | Implemented | | -| ADR-292 | ADR-292: Native Acceleration Isolation | [`ADR-292-native-acceleration-isolation.md`](./ADR-292-native-acceleration-isolation.md) | 2026-08-20 | Proposed | | -| ADR-293 | ADR-293: RVM Installer and Appliance Formats | [`ADR-293-rvm-installer-appliance-formats.md`](./ADR-293-rvm-installer-appliance-formats.md) | 2026-08-20 | Proposed | | -| ADR-294 | ADR-294: RVForge Platform — Agent Store, Registry, and Trust System | [`ADR-294-rvforge-platform-store-registry-trust.md`](./ADR-294-rvforge-platform-store-registry-trust.md) | 2026-08-20 | Accepted | | -| ADR-295 | ADR-295: RVForge Agent Dock — Persistent Security and Control Surface | [`ADR-295-rvforge-agent-dock.md`](./ADR-295-rvforge-agent-dock.md) | 2026-08-20 | Implemented | | -| ADR-296 | ADR-296: Turbo4 — 4-bit Lloyd-Max Quantized Vector Datatype with Direct Packed HNSW Scoring | [`ADR-296-turbo4-quantized-vector-datatype.md`](./ADR-296-turbo4-quantized-vector-datatype.md) | 2026-08-20 | Accepted | | -| ADR-297 | ADR-297: Adaptive Compression & Retrieval Plane (ACRP) | [`ADR-297-adaptive-compression-retrieval-plane.md`](./ADR-297-adaptive-compression-retrieval-plane.md) | 2026-08-20 | Accepted | | -| ADR-299 | ADR-299: Namespace-Merge via S-T Mincut Routing | [`ADR-299-namespace-merge-mincut.md`](./ADR-299-namespace-merge-mincut.md) | 2026-08-20 | Accepted | | -| ADR-300 | ADR-300: Hierarchical Cluster-Summary Retrieval for Agent Memory RAG | [`ADR-300-hierarchical-cluster-rag.md`](./ADR-300-hierarchical-cluster-rag.md) | 2026-08-20 | Proposed | | -| ADR-301 | ADR-301: Semantic Query Cache for ANN | [`ADR-301-semantic-query-cache.md`](./ADR-301-semantic-query-cache.md) | 2026-08-20 | Proposed | | -| ADR-302 | ADR-302: Streaming Quantized Neighbourhood Graphs (QNG-Stream) | [`ADR-302-streaming-qng.md`](./ADR-302-streaming-qng.md) | 2026-08-20 | Proposed | | -| ADR-303 | ADR-303: Entropy-Adaptive Beam Search for ANN Graph Traversal | [`ADR-303-entropy-adaptive-ann.md`](./ADR-303-entropy-adaptive-ann.md) | 2026-08-20 | Closed — negative result (documented; not recommended for production) | | -| ADR-304 | ADR-304: Retrieval Receipts — Witness-Chained Provenance for ANN Query Results | [`ADR-304-retrieval-receipts.md`](./ADR-304-retrieval-receipts.md) | 2026-08-20 | Proposed. Experimental crate (`ruvector-retrieval-receipt`), not wired into | | -| ADR-305 | ADR-305: Adopt Autogenous ADR-401 and LatentMesh ADR-009 as the Perpetual Intelligence Runtime's Definition and Control-Loop Spine | [`ADR-305-adopt-latentmesh-adr009-control-loop-spine.md`](./ADR-305-adopt-latentmesh-adr009-control-loop-spine.md) | 2026-08-20 | Proposed | | -| ADR-306 | ADR-306: Dream Machine — Adopt the Consolidating Evaluation Engine, Wired to research-gate and Darwin | [`ADR-306-dream-machine-sona-darwin-unification.md`](./ADR-306-dream-machine-sona-darwin-unification.md) | 2026-08-20 | Proposed | | -| ADR-307 | ADR-307: Three-Level Persistent Memory Architecture (LiveMem + TARL Pattern) on RuVector | [`ADR-307-three-level-persistent-memory-livemem-tarl.md`](./ADR-307-three-level-persistent-memory-livemem-tarl.md) | 2026-08-20 | Proposed | | -| ADR-308 | ADR-308: WorldCycle-Style Verification for the Physical Action Loop | [`ADR-308-worldcycle-verification-physical-action-loop.md`](./ADR-308-worldcycle-verification-physical-action-loop.md) | 2026-08-20 | Proposed | | -| ADR-309 | ADR-309: Build LatentMesh Integration Inside ruvector as New Crates, Coordinated on Wire Format | [`ADR-309-latentmesh-greenfield-crates-wire-format-coordination.md`](./ADR-309-latentmesh-greenfield-crates-wire-format-coordination.md) | 2026-08-20 | Proposed | | -| ADR-310 | ADR-310: Causal-Attribution Gate for Latent Communication | [`ADR-310-causal-attribution-gate-latent-communication.md`](./ADR-310-causal-attribution-gate-latent-communication.md) | 2026-08-20 | Proposed | | -| ADR-311 | ADR-311: Anomaly Quarantine for Latent Channels (Net-New Work — Not "LATTE") | [`ADR-311-anomaly-quarantine-latent-channels-net-new.md`](./ADR-311-anomaly-quarantine-latent-channels-net-new.md) | 2026-08-20 | Proposed | | -| ADR-312 | ADR-312: Shared Witness Record Schema and Cross-Layer Anchoring Contract (rvm-witness ↔ autogenous witness) | [`ADR-312-shared-witness-schema-anchoring-contract.md`](./ADR-312-shared-witness-schema-anchoring-contract.md) | 2026-08-20 | Proposed | | -| ADR-313 | ADR-313: SHAPER-Pattern Skill/Harness Evolution Loop (Frozen Weights) | [`ADR-313-shaper-frozen-weight-skill-harness-evolution.md`](./ADR-313-shaper-frozen-weight-skill-harness-evolution.md) | 2026-08-20 | Proposed | | -| ADR-314 | ADR-314: KV-Cache Cross-Model Migration in ruvLLM (Fast-Follow) | [`ADR-314-kv-cache-cross-model-migration-ruvllm.md`](./ADR-314-kv-cache-cross-model-migration-ruvllm.md) | 2026-08-20 | Proposed | | -| ADR-315 | ADR-315: Governance Constitution for Capability Expansion | [`ADR-315-governance-constitution-capability-expansion.md`](./ADR-315-governance-constitution-capability-expansion.md) | 2026-08-20 | Proposed | | -| ADR-316 | ADR-316: ADR Numbering Hygiene — Frozen Duplicates, Canonical Counter, Collision Gate | [`ADR-316-adr-numbering-hygiene.md`](./ADR-316-adr-numbering-hygiene.md) | 2026-08-20 | Proposed | | -| ADR-317 | ADR-317: HarnessRisk Lifecycle Security Benchmark as a Darwin Promotion Gate | [`ADR-317-harnessrisk-lifecycle-security-benchmark-gate.md`](./ADR-317-harnessrisk-lifecycle-security-benchmark-gate.md) | 2026-08-20 | Proposed | | -| ADR-318 | ADR-318: StagedWorkspace-Pattern Content-Hash State Binding as a RuV Invariant | [`ADR-318-stagedworkspace-content-hash-state-binding.md`](./ADR-318-stagedworkspace-content-hash-state-binding.md) | 2026-08-20 | Proposed | | -| ADR-319 | ADR-319: TRUSS-Pattern Shadow Execution for Generated Capabilities | [`ADR-319-truss-pattern-shadow-execution-generated-capabilities.md`](./ADR-319-truss-pattern-shadow-execution-generated-capabilities.md) | 2026-08-20 | Proposed | | -| ADR-320 | ADR-320: MemFuse-Pattern AtomicObservation and Causal Episodic Graph | [`ADR-320-memfuse-pattern-atomic-observation-causal-graph.md`](./ADR-320-memfuse-pattern-atomic-observation-causal-graph.md) | 2026-08-20 | Proposed | | -| ADR-321 | ADR-321: SkillForge-Pattern Synthetic-Issue Self-Training in the Darwin Loop | [`ADR-321-skillforge-pattern-synthetic-issue-self-training.md`](./ADR-321-skillforge-pattern-synthetic-issue-self-training.md) | 2026-08-20 | Proposed | | -| ADR-323 | ADR-323: Governed Pipeline-Shard Placement for Multi-Node ruvLLM Serving | [`ADR-323-governed-pipeline-shard-placement.md`](./ADR-323-governed-pipeline-shard-placement.md) | 2026-08-20 | Proposed | | +| ADR-001 | ADR-001: Ruvector Core Architecture | [`ADR-001-ruvector-core-architecture.md`](./ADR-001-ruvector-core-architecture.md) | 2026-08-21 | Proposed | | +| ADR-002 | ADR-002: RuvLLM Integration with Ruvector | [`ADR-002-ruvllm-integration.md`](./ADR-002-ruvllm-integration.md) | 2026-08-21 | Proposed | | +| ADR-003 | ADR-003: SIMD Optimization Strategy for Ruvector and RuvLLM | [`ADR-003-simd-optimization-strategy.md`](./ADR-003-simd-optimization-strategy.md) | 2026-08-21 | ✅ Implemented (v2.1.1) | | +| ADR-004 | ADR-004: KV Cache Management Strategy for RuvLLM | [`ADR-004-kv-cache-management.md`](./ADR-004-kv-cache-management.md) | 2026-08-21 | Proposed | | +| ADR-005 | ADR-005: WASM Runtime Integration | [`ADR-005-wasm-runtime-integration.md`](./ADR-005-wasm-runtime-integration.md) | 2026-08-21 | | | +| ADR-006 | ADR-006: Unified Memory Pool and Paging Strategy | [`ADR-006-memory-management.md`](./ADR-006-memory-management.md) | 2026-08-21 | | | +| ADR-007 | ADR-007: Security Review & Technical Debt Remediation | [`ADR-007-security-review-technical-debt.md`](./ADR-007-security-review-technical-debt.md) | 2026-08-21 | Active | | +| ADR-008 | ADR-008: mistral-rs Integration for Production-Scale LLM Serving | [`ADR-008-mistral-rs-integration.md`](./ADR-008-mistral-rs-integration.md) | 2026-08-21 | Proposed | | +| ADR-009 | ADR-009: Structured Output / JSON Mode for Reliable Agentic Workflows | [`ADR-009-structured-output.md`](./ADR-009-structured-output.md) | 2026-08-21 | Proposed | | +| ADR-010 | ADR-010: Function Calling / Tool Use in RuvLLM | [`ADR-010-function-calling.md`](./ADR-010-function-calling.md) | 2026-08-21 | Proposed | | +| ADR-011 | ADR-011: Prefix Caching for 10x Faster RAG and Chat Applications | [`ADR-011-prefix-caching.md`](./ADR-011-prefix-caching.md) | 2026-08-21 | Proposed | | +| ADR-012 | ADR-012: Security Remediation and Hardening | [`ADR-012-security-remediation.md`](./ADR-012-security-remediation.md) | 2026-08-21 | Accepted | | +| ADR-013 | ADR-013: HuggingFace Model Publishing Strategy | [`ADR-013-huggingface-publishing.md`](./ADR-013-huggingface-publishing.md) | 2026-08-21 | **Accepted** - 2026-01-20 | | +| ADR-014 | ADR-014: Coherence Engine Architecture | [`ADR-014-coherence-engine.md`](./ADR-014-coherence-engine.md) | 2026-08-21 | Proposed | | +| ADR-015 | ADR-015: Coherence-Gated Transformer (Sheaf Attention) | [`ADR-015-coherence-gated-transformer.md`](./ADR-015-coherence-gated-transformer.md) | 2026-08-21 | Proposed | | +| ADR-016 | ADR-016: Delta-Behavior System - Domain-Driven Design Architecture | [`ADR-016-delta-behavior-ddd-architecture.md`](./ADR-016-delta-behavior-ddd-architecture.md) | 2026-08-21 | Proposed | | +| ADR-017 | ADR-017: Temporal Tensor Compression with Tiered Quantization | [`ADR-017-temporal-tensor-compression.md`](./ADR-017-temporal-tensor-compression.md) | 2026-08-21 | Proposed | | +| ADR-018 | ADR-018: Block-Based Storage Engine Architecture for the Temporal Tensor Store | [`temporal-tensor-store/ADR-018-block-based-storage-engine.md`](./temporal-tensor-store/ADR-018-block-based-storage-engine.md) | 2026-08-21 | Proposed | | +| ADR-019 | ADR-019: Tiered Quantization Formats for Temporal Tensor Store | [`temporal-tensor-store/ADR-019-tiered-quantization-formats.md`](./temporal-tensor-store/ADR-019-tiered-quantization-formats.md) | 2026-08-21 | Proposed | | +| ADR-020 | ADR-020: Temporal Scoring and Tier Migration Algorithm | [`temporal-tensor-store/ADR-020-temporal-scoring-tier-migration.md`](./temporal-tensor-store/ADR-020-temporal-scoring-tier-migration.md) | 2026-08-21 | Proposed | | +| ADR-021 | ADR-021: Delta Compression and Reconstruction Policies | [`temporal-tensor-store/ADR-021-delta-compression-reconstruction.md`](./temporal-tensor-store/ADR-021-delta-compression-reconstruction.md) | 2026-08-21 | Proposed | | +| ADR-022 | ADR-022: WASM API Surface and Cross-Platform Strategy | [`temporal-tensor-store/ADR-022-wasm-api-cross-platform.md`](./temporal-tensor-store/ADR-022-wasm-api-cross-platform.md) | 2026-08-21 | Proposed | | +| ADR-023 | ADR-023: Benchmarking, Failure Modes, and Acceptance Criteria | [`temporal-tensor-store/ADR-023-benchmarking-acceptance-criteria.md`](./temporal-tensor-store/ADR-023-benchmarking-acceptance-criteria.md) | 2026-08-21 | Proposed | | +| ADR-024 | ADR-024: Craftsman Ultra 30b 1bit — BitNet Integration with RuvLLM | [`ADR-024-craftsman-ultra-30b-1bit-bitnet-integration.md`](./ADR-024-craftsman-ultra-30b-1bit-bitnet-integration.md) | 2026-08-21 | Proposed | | +| ADR-025 | ADR-025: EXO-AI Multi-Paradigm Integration Architecture | [`ADR-025-exo-ai-multiparadigm-integration.md`](./ADR-025-exo-ai-multiparadigm-integration.md) | 2026-08-21 | Proposed | | +| ADR-026 | ADR-026: Vector-Native COW Branching (RVCOW) and Real Cognitive Containers | [`ADR-026-rvcow-branching-and-real-cognitive-containers.md`](./ADR-026-rvcow-branching-and-real-cognitive-containers.md) | 2026-08-21 | | | +| ADR-027 | ADR-027: Fix HNSW Index Segmentation Fault with Parameterized Queries | [`ADR-027-hnsw-parameterized-query-fix.md`](./ADR-027-hnsw-parameterized-query-fix.md) | 2026-08-21 | **Accepted** - 2026-01-28 | | +| ADR-028 | ADR-028: eHealth Platform Architecture for 50M Patient Records | [`ADR-028-ehealth-platform-architecture.md`](./ADR-028-ehealth-platform-architecture.md) | 2026-08-21 | Proposed | | +| ADR-029 | ADR-029: RVF as Canonical Binary Format Across All RuVector Libraries | [`ADR-029-rvf-canonical-format.md`](./ADR-029-rvf-canonical-format.md) | 2026-08-21 | Accepted | | +| ADR-030 | ADR-030: RVF Cognitive Container -- Self-Booting Vector Files | [`ADR-030-rvf-cognitive-container.md`](./ADR-030-rvf-cognitive-container.md) | 2026-08-21 | Proposed | | +| ADR-031 | ADR-031: RVF Example Repository — 24 Demonstrations Across Four Categories | [`ADR-031-rvf-example-repository.md`](./ADR-031-rvf-example-repository.md) | 2026-08-21 | Accepted | | +| ADR-032 | ADR-032: RVF WASM Integration into npx ruvector and rvlite | [`ADR-032-rvf-wasm-integration.md`](./ADR-032-rvf-wasm-integration.md) | 2026-08-21 | Accepted | | +| ADR-033 | ADR-033: Progressive Indexing Hardening — Centroid Stability, Adversarial Resilience, Recall Framing, and Mandatory Signatures | [`ADR-033-progressive-indexing-hardening.md`](./ADR-033-progressive-indexing-hardening.md) | 2026-08-21 | Accepted | | +| ADR-034 | ADR-034: QR Cognitive Seed — A World Inside a World | [`ADR-034-qr-cognitive-seed.md`](./ADR-034-qr-cognitive-seed.md) | 2026-08-21 | Implemented | | +| ADR-035 | ADR-035: Capability Report — Witness Bundles, Scorecards, and Governance | [`ADR-035-capability-report.md`](./ADR-035-capability-report.md) | 2026-08-21 | Implemented | | +| ADR-036 | ADR-036: RuVector AGI Cognitive Container with Claude Code Orchestration | [`ADR-036-agi-cognitive-container.md`](./ADR-036-agi-cognitive-container.md) | 2026-08-21 | Partially Implemented | | +| ADR-037 | ADR-037: Publishable RVF Acceptance Test | [`ADR-037-publishable-rvf-acceptance-test.md`](./ADR-037-publishable-rvf-acceptance-test.md) | 2026-08-21 | | | +| ADR-038 | ADR-038: npx ruvector & rvlite Witness Verification Integration | [`ADR-038-npx-ruvector-rvlite-witness-integration.md`](./ADR-038-npx-ruvector-rvlite-witness-integration.md) | 2026-08-21 | | | +| ADR-039 | ADR-039: RVF Solver WASM — Self-Learning AGI Engine Integration | [`ADR-039-rvf-solver-wasm-agi-integration.md`](./ADR-039-rvf-solver-wasm-agi-integration.md) | 2026-08-21 | | | +| ADR-040 | ADR-040: Causal Atlas RVF Runtime — Planet Detection & Life Candidate Scoring | [`ADR-040-causal-atlas-rvf-runtime-planet-detection.md`](./ADR-040-causal-atlas-rvf-runtime-planet-detection.md) | 2026-08-21 | Proposed | | +| ADR-040a | ADR-040a: Causal Atlas Dashboard Specification | [`ADR-040a-planet-detection-dashboard.md`](./ADR-040a-planet-detection-dashboard.md) | 2026-08-21 | Proposed | | +| ADR-040b | ADR-040b: Microlensing Detection & Cross-Domain Graph-Cut Extensions | [`ADR-040b-microlensing-graphcut-extensions.md`](./ADR-040b-microlensing-graphcut-extensions.md) | 2026-08-21 | Proposed | | +| ADR-042 | ADR-042: Security RVF — AIDefence + TEE Hardened Cognitive Container | [`ADR-042-Security-RVF-AIDefence-TEE.md`](./ADR-042-Security-RVF-AIDefence-TEE.md) | 2026-08-21 | | | +| ADR-043 | ADR-043: External Intelligence Providers for SONA Learning | [`ADR-043-external-intelligence-providers.md`](./ADR-043-external-intelligence-providers.md) | 2026-08-21 | | | +| ADR-044 | ADR-044: ruvector-postgres v0.3 Extension Upgrade | [`ADR-044-ruvector-postgres-v03-extension-upgrade.md`](./ADR-044-ruvector-postgres-v03-extension-upgrade.md) | 2026-08-21 | Accepted — Implementation in progress | | +| ADR-045 | ADR-045: Lean-Agentic Integration — Formal Verification & AI-Native Type Theory for RuVector | [`ADR-045-lean-agentic-integration.md`](./ADR-045-lean-agentic-integration.md) | 2026-08-21 | Proposed | | +| ADR-046 | ADR-046: Graph Transformer Unified Architecture | [`ADR-046-graph-transformer-architecture.md`](./ADR-046-graph-transformer-architecture.md) | 2026-08-21 | Accepted | | +| ADR-047 | ADR-047: Proof-Gated Mutation Protocol | [`ADR-047-proof-gated-mutation-protocol.md`](./ADR-047-proof-gated-mutation-protocol.md) | 2026-08-21 | Accepted | | +| ADR-048 | ADR-048: Sublinear Graph Attention | [`ADR-048-sublinear-graph-attention.md`](./ADR-048-sublinear-graph-attention.md) | 2026-08-21 | Accepted | | +| ADR-049 | ADR-049: Verified Training Pipeline | [`ADR-049-verified-training-pipeline.md`](./ADR-049-verified-training-pipeline.md) | 2026-08-21 | Accepted | | +| ADR-050 | ADR-050: Graph Transformer WASM and Node.js Bindings | [`ADR-050-graph-transformer-bindings.md`](./ADR-050-graph-transformer-bindings.md) | 2026-08-21 | Accepted | | +| ADR-051 | ADR-051: Physics-Informed Graph Transformer Layers | [`ADR-051-physics-informed-graph-layers.md`](./ADR-051-physics-informed-graph-layers.md) | 2026-08-21 | Accepted | | +| ADR-052 | ADR-052: Biological Graph Transformer Layers | [`ADR-052-biological-graph-layers.md`](./ADR-052-biological-graph-layers.md) | 2026-08-21 | Accepted | | +| ADR-053 | ADR-053: Temporal and Causal Graph Transformer Layers | [`ADR-053-temporal-causal-graph-layers.md`](./ADR-053-temporal-causal-graph-layers.md) | 2026-08-21 | Accepted | | +| ADR-054 | ADR-054: Economic Graph Transformer Layers | [`ADR-054-economic-graph-layers.md`](./ADR-054-economic-graph-layers.md) | 2026-08-21 | Accepted | | +| ADR-055 | ADR-055: Manifold-Aware Graph Transformer Layers | [`ADR-055-manifold-graph-layers.md`](./ADR-055-manifold-graph-layers.md) | 2026-08-21 | Accepted | | +| ADR-056 | ADR-056: RVF Knowledge Export for Developer Onboarding | [`ADR-056-rvf-knowledge-export.md`](./ADR-056-rvf-knowledge-export.md) | 2026-08-21 | Accepted | | +| ADR-057 | ADR-057: Federated RVF Format for Real-Time Transfer Learning | [`ADR-057-federated-rvf-transfer-learning.md`](./ADR-057-federated-rvf-transfer-learning.md) | 2026-08-21 | Proposed | | +| ADR-058 | ADR-058: RVF Hash Security Hardening and Optimization | [`ADR-058-hash-security-optimization.md`](./ADR-058-hash-security-optimization.md) | 2026-08-21 | Accepted | | +| ADR-059 | ADR-059: Shared Brain — Google Cloud Deployment | [`ADR-059-shared-brain-google-cloud.md`](./ADR-059-shared-brain-google-cloud.md) | 2026-08-21 | Accepted | | +| ADR-060 | ADR-060: Shared Brain Capabilities — Federated MicroLoRA Intelligence Substrate | [`ADR-060-shared-brain-capabilities.md`](./ADR-060-shared-brain-capabilities.md) | 2026-08-21 | Accepted | | +| ADR-061 | ADR-061: Reasoning Kernel Architecture — Brain-Augmented Targeted Reasoning | [`ADR-061-reasoning-kernel-architecture.md`](./ADR-061-reasoning-kernel-architecture.md) | 2026-08-21 | Accepted | | +| ADR-062 | ADR-062: Brainpedia — Structured Knowledge Encyclopedia with Delta-Based Editing | [`ADR-062-brainpedia-architecture.md`](./ADR-062-brainpedia-architecture.md) | 2026-08-21 | Accepted | | +| ADR-063 | ADR-063: WASM Executable Nodes — Deterministic Compute at the Edge | [`ADR-063-wasm-executable-nodes.md`](./ADR-063-wasm-executable-nodes.md) | 2026-08-21 | Accepted | | +| ADR-064 | ADR-064: Pi Brain Infrastructure & Landing Page | [`ADR-064-pi-brain-infrastructure.md`](./ADR-064-pi-brain-infrastructure.md) | 2026-08-21 | Accepted, Deployed | | +| ADR-065 | ADR-065: npm Publishing Strategy | [`ADR-065-npm-publishing-strategy.md`](./ADR-065-npm-publishing-strategy.md) | 2026-08-21 | Accepted | | +| ADR-066 | ADR-066: SSE MCP Transport | [`ADR-066-sse-mcp-transport.md`](./ADR-066-sse-mcp-transport.md) | 2026-08-21 | Accepted, Deployed — Updated 2026-04-02: SSE moved to dedicated subdomain `mcp.p | | +| ADR-067 | ADR-067: MCP Gate Permit System | [`ADR-067-mcp-gate-permit-system.md`](./ADR-067-mcp-gate-permit-system.md) | 2026-08-21 | Accepted, Implemented | | +| ADR-068 | ADR-068: Domain Expansion Transfer Learning | [`ADR-068-domain-expansion-transfer-learning.md`](./ADR-068-domain-expansion-transfer-learning.md) | 2026-08-21 | Accepted, Implemented | | +| ADR-069 | ADR-069: Edge-Net and Pi Brain Integration — Distributed Compute Intelligence | [`ADR-069-google-edge-network-deployment.md`](./ADR-069-google-edge-network-deployment.md) | 2026-08-21 | Proposed | | +| ADR-070 | ADR-070: npx ruvector Unified Integration | [`ADR-070-npx-ruvector-unified-integration.md`](./ADR-070-npx-ruvector-unified-integration.md) | 2026-08-21 | Proposed | | +| ADR-071 | ADR-071: npx ruvector Ecosystem Gap Analysis | [`ADR-071-npx-ruvector-ecosystem-gap-analysis.md`](./ADR-071-npx-ruvector-ecosystem-gap-analysis.md) | 2026-08-21 | Proposed | | +| ADR-072 | ADR-072: RVF Example Management and Downloads in npx ruvector | [`ADR-072-rvf-example-management-downloads.md`](./ADR-072-rvf-example-management-downloads.md) | 2026-08-21 | Proposed | | +| ADR-073 | ADR-073: π.ruv.io Platform Security Audit & Optimization | [`ADR-073-pi-platform-security-optimization.md`](./ADR-073-pi-platform-security-optimization.md) | 2026-08-21 | Accepted | | +| ADR-074 | ADR-074: RuvLLM Neural Embedding Integration | [`ADR-074-ruvllm-neural-embeddings.md`](./ADR-074-ruvllm-neural-embeddings.md) | 2026-08-21 | Implemented (Phase 2 — RlmEmbedder Active) | | +| ADR-075 | ADR-075: Wire Full RVF AGI Stack into mcp-brain-server | [`ADR-075-rvf-agi-stack-brain-integration.md`](./ADR-075-rvf-agi-stack-brain-integration.md) | 2026-08-21 | Implemented | | +| ADR-076 | ADR-076: AGI Capability Wiring Architecture | [`ADR-076-agi-capability-wiring-architecture.md`](./ADR-076-agi-capability-wiring-architecture.md) | 2026-08-21 | Implemented | | +| ADR-077 | ADR-077: Midstream Platform Integration into mcp-brain-server | [`ADR-077-midstream-brain-integration.md`](./ADR-077-midstream-brain-integration.md) | 2026-08-21 | Proposed | | +| ADR-078 | ADR-078: npx ruvector Midstream & Brain AGI Integration | [`ADR-078-npx-ruvector-midstream-integration.md`](./ADR-078-npx-ruvector-midstream-integration.md) | 2026-08-21 | Proposed | | +| ADR-079 | ADR-079: SQL Audit Script Hardening & Bug Fixes | [`ADR-079-sql-audit-script-hardening.md`](./ADR-079-sql-audit-script-hardening.md) | 2026-08-21 | Accepted | | +| ADR-080 | ADR-080: npx ruvector Deep Capability Audit | [`ADR-080-npx-ruvector-deep-capability-audit.md`](./ADR-080-npx-ruvector-deep-capability-audit.md) | 2026-08-21 | Accepted | | +| ADR-081 | ADR-081: Brain Server v0.2.8–0.2.10 Deploy + CLI/MCP Bug Fixes | [`ADR-081-brain-server-v028-deploy-cli-fixes.md`](./ADR-081-brain-server-v028-deploy-cli-fixes.md) | 2026-08-21 | Accepted | | +| ADR-082 | ADR-082: Brain Server Security Hardening — PII, Rate Limiting, Anti-Sybil | [`ADR-082-brain-security-hardening.md`](./ADR-082-brain-security-hardening.md) | 2026-08-21 | Accepted | | +| ADR-083 | ADR-083: Brain Server Training Loops — Closing the Store→Learn Gap | [`ADR-083-brain-training-loops.md`](./ADR-083-brain-training-loops.md) | 2026-08-21 | Accepted | | +| ADR-084 | ADR-084: ruvllm-wasm — First Functional npm Publish | [`ADR-084-ruvllm-wasm-publish.md`](./ADR-084-ruvllm-wasm-publish.md) | 2026-08-21 | Accepted | | +| ADR-085 | ADR-085: RuVector Neural Trader — Dynamic Market Graphs, MinCut Coherence Gating, and Proof-Gated Mutation | [`ADR-085-neural-trader-ruvector.md`](./ADR-085-neural-trader-ruvector.md) | 2026-08-21 | Proposed | | +| ADR-086 | ADR-086: Neural Trader WASM Bindings | [`ADR-086-neural-trader-wasm.md`](./ADR-086-neural-trader-wasm.md) | 2026-08-21 | Accepted | | +| ADR-087 | ADR-087: RuVix Cognition Kernel — An Operating System for the Agentic Age | [`ADR-087-ruvix-cognition-kernel.md`](./ADR-087-ruvix-cognition-kernel.md) | 2026-08-21 | **Accepted** — Phase A Implemented | | +| ADR-088 | ADR-088: CNN Contrastive Learning Integration for RuVector | [`ADR-088-cnn-contrastive-integration.md`](./ADR-088-cnn-contrastive-integration.md) | 2026-08-21 | **Proposed** | | +| ADR-089 | ADR-089: CNN Browser Demo for GitHub Pages | [`ADR-089-cnn-browser-demo.md`](./ADR-089-cnn-browser-demo.md) | 2026-08-21 | Accepted | | +| ADR-090 | ADR-090 Implementation Checklist: Ultra-Low-Bit QAT & Pi-Quantization | [`ADR-090-implementation-checklist.md`](./ADR-090-implementation-checklist.md) | 2026-08-21 | Ready for Implementation (Staged) | DUPLICATE ×2 — cite as `ADR-90 (implementation-checklist)` | +| ADR-090 | ADR-090: Ultra-Low-Bit QAT & Pi-Quantization — Domain-Driven Design Architecture | [`ADR-090-ultra-low-bit-qat-pi-quantization-ddd.md`](./ADR-090-ultra-low-bit-qat-pi-quantization-ddd.md) | 2026-08-21 | Accepted (Implementing) | DUPLICATE ×2 — cite as `ADR-90 (ultra-low-bit-qat-pi-quantization-ddd)` | +| ADR-091 | ADR-091 Implementation Checklist: INT8 CNN Quantization | [`ADR-091-implementation-checklist.md`](./ADR-091-implementation-checklist.md) | 2026-08-21 | Ready for Implementation | DUPLICATE ×2 — cite as `ADR-91 (implementation-checklist)` | +| ADR-091 | ADR-091: INT8 CNN Quantization — Domain-Driven Design Architecture | [`ADR-091-int8-cnn-quantization-ddd.md`](./ADR-091-int8-cnn-quantization-ddd.md) | 2026-08-21 | Accepted (Implementing) | DUPLICATE ×2 — cite as `ADR-91 (int8-cnn-quantization-ddd)` | +| ADR-092 | ADR-092: MoE Memory-Aware Routing — Domain-Driven Design Architecture | [`ADR-092-moe-memory-aware-routing-ddd.md`](./ADR-092-moe-memory-aware-routing-ddd.md) | 2026-08-21 | Accepted | | +| ADR-093 | ADR-093: Daily Discovery & Brain Training Program | [`ADR-093-daily-discovery-brain-training.md`](./ADR-093-daily-discovery-brain-training.md) | 2026-08-21 | Accepted | DUPLICATE ×2 — cite as `ADR-93 (daily-discovery-brain-training)` | +| ADR-093 | ADR-093: DeepAgents Complete Rust Conversion — Overview | [`ADR-093-deepagents-rust-conversion-overview.md`](./ADR-093-deepagents-rust-conversion-overview.md) | 2026-08-21 | | DUPLICATE ×2 — cite as `ADR-93 (deepagents-rust-conversion-overview)` | +| ADR-094 | ADR-094: Backend Protocol & Trait System | [`ADR-094-deepagents-backend-protocol-traits.md`](./ADR-094-deepagents-backend-protocol-traits.md) | 2026-08-21 | | DUPLICATE ×2 — cite as `ADR-94 (deepagents-backend-protocol-traits)` | +| ADR-094 | ADR-094: π.ruv.io Shared Web Memory on RuVector | [`ADR-094-pi-shared-web-memory.md`](./ADR-094-pi-shared-web-memory.md) | 2026-08-21 | Accepted (Implementing) | DUPLICATE ×2 — cite as `ADR-94 (pi-shared-web-memory)` | +| ADR-095 | ADR-095: Middleware Pipeline Architecture | [`ADR-095-deepagents-middleware-pipeline.md`](./ADR-095-deepagents-middleware-pipeline.md) | 2026-08-21 | | DUPLICATE ×2 — cite as `ADR-95 (deepagents-middleware-pipeline)` | +| ADR-095 | ADR-095: π.ruv.io API v2 — Full Capability Surface | [`ADR-095-pi-api-v2-capabilities.md`](./ADR-095-pi-api-v2-capabilities.md) | 2026-08-21 | Accepted | DUPLICATE ×2 — cite as `ADR-95 (pi-api-v2-capabilities)` | +| ADR-096 | ADR-096: Cloud-Native Data Pipeline, Real-Time Injection & Automated Optimization | [`ADR-096-cloud-pipeline-realtime-optimization.md`](./ADR-096-cloud-pipeline-realtime-optimization.md) | 2026-08-21 | Accepted | DUPLICATE ×2 — cite as `ADR-96 (cloud-pipeline-realtime-optimization)` | +| ADR-096 | ADR-096: Tool System — Filesystem, Execute, Grep, Glob | [`ADR-096-deepagents-tool-system.md`](./ADR-096-deepagents-tool-system.md) | 2026-08-21 | | DUPLICATE ×2 — cite as `ADR-96 (deepagents-tool-system)` | +| ADR-097 | ADR-097: SubAgent & Task Orchestration | [`ADR-097-deepagents-subagent-orchestration.md`](./ADR-097-deepagents-subagent-orchestration.md) | 2026-08-21 | | | +| ADR-098 | ADR-098: Memory, Skills & Summarization Middleware | [`ADR-098-deepagents-memory-skills-summarization.md`](./ADR-098-deepagents-memory-skills-summarization.md) | 2026-08-21 | | | +| ADR-099 | ADR-099: CLI & ACP Server Conversion | [`ADR-099-deepagents-cli-acp-server.md`](./ADR-099-deepagents-cli-acp-server.md) | 2026-08-21 | | | +| ADR-100 | ADR-100: RVF Integration & Crate Structure | [`ADR-100-deepagents-rvf-integration-crate-structure.md`](./ADR-100-deepagents-rvf-integration-crate-structure.md) | 2026-08-21 | | | +| ADR-101 | ADR-101: Testing Strategy & Fidelity Verification | [`ADR-101-deepagents-testing-strategy.md`](./ADR-101-deepagents-testing-strategy.md) | 2026-08-21 | | | +| ADR-102 | ADR-102: Implementation Roadmap & Phasing | [`ADR-102-deepagents-implementation-roadmap.md`](./ADR-102-deepagents-implementation-roadmap.md) | 2026-08-21 | | | +| ADR-103 | ADR-103: Review Amendments — Performance, RVF Integration & Security Hardening | [`ADR-103-deepagents-review-amendments.md`](./ADR-103-deepagents-review-amendments.md) | 2026-08-21 | | | +| ADR-104 | ADR-104: rvAgent MCP Tools/Resources, Enhanced Skills, and Topology-Aware Deployment | [`ADR-104-rvagent-mcp-skills-topology.md`](./ADR-104-rvagent-mcp-skills-topology.md) | 2026-08-21 | | | +| ADR-105 | ADR-104: rvAgent MCP Tools and Resources System | [`ADR-105-rvagent-mcp-implementation-details.md`](./ADR-105-rvagent-mcp-implementation-details.md) | 2026-08-21 | | | +| ADR-106 | ADR-106: RuVix Kernel Integration with RVF | [`ADR-106-ruvix-kernel-rvf-integration.md`](./ADR-106-ruvix-kernel-rvf-integration.md) | 2026-08-21 | | | +| ADR-107 | ADR-107: rvAgent Native Swarm Orchestration with WASM Integration | [`ADR-107-rvagent-native-swarm-wasm.md`](./ADR-107-rvagent-native-swarm-wasm.md) | 2026-08-21 | | | +| ADR-108 | ADR-108: rvAgent–ruvbot Integration Architecture | [`ADR-108-rvagent-ruvbot-integration.md`](./ADR-108-rvagent-ruvbot-integration.md) | 2026-08-21 | | | +| ADR-109 | ADR-109: Backup and Disaster Recovery Strategy | [`ADR-109-backup-disaster-recovery.md`](./ADR-109-backup-disaster-recovery.md) | 2026-08-21 | Accepted, Implemented | | +| ADR-110 | ADR-110: Neural-Symbolic Integration with Internal Voice | [`ADR-110-neural-symbolic-internal-voice.md`](./ADR-110-neural-symbolic-internal-voice.md) | 2026-08-21 | In Progress | | +| ADR-111 | ADR-111: Ruvocal UI Integration with rvAgent | [`ADR-111-ruvocal-ui-rvagent-integration.md`](./ADR-111-ruvocal-ui-rvagent-integration.md) | 2026-08-21 | | | +| ADR-112 | ADR-112: rvAgent MCP Server with SSE and stdio Transports | [`ADR-112-rvagent-mcp-server.md`](./ADR-112-rvagent-mcp-server.md) | 2026-08-21 | | | +| ADR-113 | ADR-113: RVF App Gallery and Ruvix-Powered Applications | [`ADR-113-rvf-app-gallery-ruvix-applications.md`](./ADR-113-rvf-app-gallery-ruvix-applications.md) | 2026-08-21 | | | +| ADR-114 | ADR-114: Ruvector-Core Hash Placeholder Embeddings | [`ADR-114-ruvector-core-hash-placeholders.md`](./ADR-114-ruvector-core-hash-placeholders.md) | 2026-08-21 | Accepted | | +| ADR-115 | ADR-115: Common Crawl Integration with Semantic Compression | [`ADR-115-common-crawl-temporal-compression.md`](./ADR-115-common-crawl-temporal-compression.md) | 2026-08-21 | Phase 1 Implemented | | +| ADR-116 | ADR-116: Spectral Graph Sparsifier Integration with pi.ruv.io | [`ADR-116-spectral-sparsifier-brain-integration.md`](./ADR-116-spectral-sparsifier-brain-integration.md) | 2026-08-21 | Accepted | | +| ADR-117 | ADR-117: Pseudo-Deterministic Canonical Minimum Cut | [`ADR-117-canonical-mincut-pseudo-deterministic.md`](./ADR-117-canonical-mincut-pseudo-deterministic.md) | 2026-08-21 | Shipped (all 3 tiers) | DUPLICATE ×2 — cite as `ADR-117 (canonical-mincut-pseudo-deterministic)` | +| ADR-117 | ADR-117: DrAgnes Dermatology Intelligence Platform | [`ADR-117-dragnes-dermatology-intelligence-platform.md`](./ADR-117-dragnes-dermatology-intelligence-platform.md) | 2026-08-21 | Proposed | DUPLICATE ×2 — cite as `ADR-117 (dragnes-dermatology-intelligence-platform)` | +| ADR-118 | ADR-118: Cost-Effective Common Crawl Strategy with Sparsifier-Aware Guardrails | [`ADR-118-cost-effective-crawl-strategy.md`](./ADR-118-cost-effective-crawl-strategy.md) | 2026-08-21 | Phase 1 Active | | +| ADR-119 | ADR-119: Historical Common Crawl Evolutionary Comparison | [`ADR-119-historical-crawl-evolutionary-comparison.md`](./ADR-119-historical-crawl-evolutionary-comparison.md) | 2026-08-21 | Accepted | | +| ADR-120 | ADR-120: WET Processing Pipeline for Medical + CS Corpus Import | [`ADR-120-wet-processing-pipeline.md`](./ADR-120-wet-processing-pipeline.md) | 2026-08-21 | Phase 1 Deployed | | +| ADR-121 | ADR-121: Gemini Google Search Grounding for Brain Optimizer | [`ADR-121-gemini-grounding-integration.md`](./ADR-121-gemini-grounding-integration.md) | 2026-08-21 | Implemented | | +| ADR-122 | ADR-122: rvAgent Autonomous Gemini Grounding Agents | [`ADR-122-rvagent-gemini-grounding-agents.md`](./ADR-122-rvagent-gemini-grounding-agents.md) | 2026-08-21 | Approved with Revisions | | +| ADR-123 | ADR-123: Pi Brain Cognitive Enrichment | [`ADR-123-brain-cognitive-enrichment.md`](./ADR-123-brain-cognitive-enrichment.md) | 2026-08-21 | Accepted | | +| ADR-124 | ADR-124: Dynamic MinCut with Partition Cache | [`ADR-124-dynamic-partition-cache.md`](./ADR-124-dynamic-partition-cache.md) | 2026-08-21 | Shipped — All 3 tiers shipped and deployed through ruvbrain-00130 | | +| ADR-125 | ADR-125: Resend Email Integration for Pi Brain Notifications | [`ADR-125-resend-email-brain-integration.md`](./ADR-125-resend-email-brain-integration.md) | 2026-08-21 | Proposed | | +| ADR-126 | ADR-126: Google Chat Bot for Pi Brain Interaction | [`ADR-126-google-chat-brain-integration.md`](./ADR-126-google-chat-brain-integration.md) | 2026-08-21 | Proposed | | +| ADR-127 | ADR-127: Gist Deep Research Loop — Brain-Guided Discovery Publishing | [`ADR-127-gist-deep-research-loop.md`](./ADR-127-gist-deep-research-loop.md) | 2026-08-21 | Implemented | | +| ADR-128 | ADR-128: SOTA Gap Implementations — Hybrid Search, MLA, KV-Cache, SSM, Graph RAG | [`ADR-128-sota-gap-implementations.md`](./ADR-128-sota-gap-implementations.md) | 2026-08-21 | Accepted | | +| ADR-129 | ADR-129: RuvLTRA Model Training & TurboQuant Optimization on Google Cloud | [`ADR-129-ruvltra-gcloud-training-turboquant.md`](./ADR-129-ruvltra-gcloud-training-turboquant.md) | 2026-08-21 | Accepted — Phase 1 (calibration) deployed and executing. Governance and release | | +| ADR-130 | ADR-130: MCP SSE Decoupling via Midstream Queue Architecture | [`ADR-130-mcp-sse-decoupling-midstream-queue.md`](./ADR-130-mcp-sse-decoupling-midstream-queue.md) | 2026-08-21 | **Deployed** (2026-04-02) — Phases 1-3 complete. SSE decoupled to `mcp.pi.ruv.io | | +| ADR-131 | ADR-131: Consciousness Metrics Crate — IIT 4.0 Φ, CES, ΦID, PID, Streaming, Bounds | [`ADR-131-consciousness-metrics-crate.md`](./ADR-131-consciousness-metrics-crate.md) | 2026-08-21 | Accepted (Updated) | | +| ADR-132 | ADR-132: E2E Browser Testing with @claude-flow/browser | [`ADR-132-e2e-browser-testing-claude-flow.md`](./ADR-132-e2e-browser-testing-claude-flow.md) | 2026-08-21 | Proposed | DUPLICATE ×2 — cite as `ADR-132 (e2e-browser-testing-claude-flow)` | +| ADR-132 | ADR-132: RVM Hypervisor Core — Standalone Coherence-Native Microhypervisor | [`ADR-132-ruvix-hypervisor-core.md`](./ADR-132-ruvix-hypervisor-core.md) | 2026-08-21 | Proposed | DUPLICATE ×2 — cite as `ADR-132 (ruvix-hypervisor-core)` | +| ADR-133 | ADR-133: Claude Code CLI Source Code Analysis | [`ADR-133-claude-code-source-analysis.md`](./ADR-133-claude-code-source-analysis.md) | 2026-08-21 | Deployed (2026-04-02) | DUPLICATE ×2 — cite as `ADR-133 (claude-code-source-analysis)` | +| ADR-133 | ADR-133: Partition Object Model | [`ADR-133-partition-object-model.md`](./ADR-133-partition-object-model.md) | 2026-08-21 | Proposed | DUPLICATE ×2 — cite as `ADR-133 (partition-object-model)` | +| ADR-134 | ADR-134: RuVector Deep Integration with Claude Code CLI | [`ADR-134-ruvector-claude-code-deep-integration.md`](./ADR-134-ruvector-claude-code-deep-integration.md) | 2026-08-21 | Proposed | DUPLICATE ×2 — cite as `ADR-134 (ruvector-claude-code-deep-integration)` | +| ADR-134 | ADR-134: Witness Schema and Log Format | [`ADR-134-witness-schema-log-format.md`](./ADR-134-witness-schema-log-format.md) | 2026-08-21 | Proposed | DUPLICATE ×2 — cite as `ADR-134 (witness-schema-log-format)` | +| ADR-135 | ADR-135: MinCut Decompiler with RVF Witness Chains | [`ADR-135-mincut-decompiler-with-witness-chains.md`](./ADR-135-mincut-decompiler-with-witness-chains.md) | 2026-08-21 | Deployed (2026-04-03) — 8-phase pipeline implemented. Louvain partitioning (35x | DUPLICATE ×2 — cite as `ADR-135 (mincut-decompiler-with-witness-chains)` | +| ADR-135 | ADR-135: Proof Verifier Design — Three-Layer Verification for Capability-Gated Mutation | [`ADR-135-proof-verifier-design.md`](./ADR-135-proof-verifier-design.md) | 2026-08-21 | Proposed | DUPLICATE ×2 — cite as `ADR-135 (proof-verifier-design)` | +| ADR-136 | ADR-136: GPU-Trained Deobfuscation Model | [`ADR-136-gpu-trained-deobfuscation-model.md`](./ADR-136-gpu-trained-deobfuscation-model.md) | 2026-08-21 | Deployed (2026-04-03) — Model trained (673K params, 95.7% val accuracy), exporte | DUPLICATE ×2 — cite as `ADR-136 (gpu-trained-deobfuscation-model)` | +| ADR-136 | ADR-136: Memory Hierarchy and Reconstruction — Four-Tier Coherence-Driven Memory Model | [`ADR-136-memory-hierarchy-reconstruction.md`](./ADR-136-memory-hierarchy-reconstruction.md) | 2026-08-21 | Proposed | DUPLICATE ×2 — cite as `ADR-136 (memory-hierarchy-reconstruction)` | +| ADR-137 | ADR-137: Bare-Metal Boot Sequence | [`ADR-137-bare-metal-boot-sequence.md`](./ADR-137-bare-metal-boot-sequence.md) | 2026-08-21 | Proposed | DUPLICATE ×2 — cite as `ADR-137 (bare-metal-boot-sequence)` | +| ADR-137 | ADR-137: npm Decompiler CLI and MCP Tools | [`ADR-137-npm-decompiler-cli-and-mcp.md`](./ADR-137-npm-decompiler-cli-and-mcp.md) | 2026-08-21 | Deployed (2026-04-03) — CLI command + 6 MCP tools implemented. Decompiler librar | DUPLICATE ×2 — cite as `ADR-137 (npm-decompiler-cli-and-mcp)` | +| ADR-138 | ADR-138: LLM Model Weight Decompiler | [`ADR-138-llm-weight-decompiler.md`](./ADR-138-llm-weight-decompiler.md) | 2026-08-21 | Implemented (2026-04-03) -- GGUF and Safetensors format decompilation with archi | DUPLICATE ×2 — cite as `ADR-138 (llm-weight-decompiler)` | +| ADR-138 | ADR-138: Seed Hardware Bring-Up | [`ADR-138-seed-hardware-bring-up.md`](./ADR-138-seed-hardware-bring-up.md) | 2026-08-21 | Proposed | DUPLICATE ×2 — cite as `ADR-138 (seed-hardware-bring-up)` | +| ADR-139 | ADR-139: Appliance Deployment Model — Edge Hub with Coherence-Native Control | [`ADR-139-appliance-deployment-model.md`](./ADR-139-appliance-deployment-model.md) | 2026-08-21 | Proposed | DUPLICATE ×2 — cite as `ADR-139 (appliance-deployment-model)` | +| ADR-139 | ADR-139: RVAgent Optimization Using Decompiled Claude Code Intelligence | [`ADR-139-rvagent-claude-code-optimization.md`](./ADR-139-rvagent-claude-code-optimization.md) | 2026-08-21 | Proposed | DUPLICATE ×2 — cite as `ADR-139 (rvagent-claude-code-optimization)` | +| ADR-140 | ADR-140: Agent Runtime Adapter — WASM Agents in Coherence Domains | [`ADR-140-agent-runtime-adapter.md`](./ADR-140-agent-runtime-adapter.md) | 2026-08-21 | Proposed | | +| ADR-141 | ADR-141: Coherence Engine — Kernel Integration and Runtime Pipeline | [`ADR-141-coherence-engine-kernel-integration.md`](./ADR-141-coherence-engine-kernel-integration.md) | 2026-08-21 | Accepted | | +| ADR-142 | ADR-142: TEE-Backed Cryptographic Verification for the RVM Hypervisor | [`ADR-142-tee-backed-cryptographic-verification.md`](./ADR-142-tee-backed-cryptographic-verification.md) | 2026-08-21 | Accepted | | +| ADR-143 | ADR-143: HEARmusica — High-Fidelity Rust Port of Tympan Open-Source Hearing Aid | [`ADR-143-hearmusica-tympan-rust-port.md`](./ADR-143-hearmusica-tympan-rust-port.md) | 2026-08-21 | Accepted | DUPLICATE ×2 — cite as `ADR-143 (hearmusica-tympan-rust-port)` | +| ADR-143 | ADR-143: Implement Missing Capabilities in ruvector | [`ADR-143-implement-missing-capabilities.md`](./ADR-143-implement-missing-capabilities.md) | 2026-08-21 | Accepted | DUPLICATE ×2 — cite as `ADR-143 (implement-missing-capabilities)` | +| ADR-144 | ADR-144: Candle-Whisper Integration with Musica for Pure-Rust Transcription | [`ADR-144-candle-whisper-musica-transcription.md`](./ADR-144-candle-whisper-musica-transcription.md) | 2026-08-21 | Accepted | DUPLICATE ×3 — cite as `ADR-144 (candle-whisper-musica-transcription)` | +| ADR-144 | ADR-144: DiskANN/Vamana Implementation | [`ADR-144-diskann-vamana-implementation.md`](./ADR-144-diskann-vamana-implementation.md) | 2026-08-21 | Implemented | DUPLICATE ×3 — cite as `ADR-144 (diskann-vamana-implementation)` | +| ADR-144 | ADR-144: Monorepo Quality Analysis Strategy and Test Plan | [`ADR-144-monorepo-quality-analysis-strategy.md`](./ADR-144-monorepo-quality-analysis-strategy.md) | 2026-08-21 | Accepted | DUPLICATE ×3 — cite as `ADR-144 (monorepo-quality-analysis-strategy)` | +| ADR-145 | ADR-145: WASM/NAPI Training Pipeline Fixes | [`ADR-145-wasm-training-pipeline-fixes.md`](./ADR-145-wasm-training-pipeline-fixes.md) | 2026-08-21 | Accepted | | +| ADR-146 | ADR-144: DiskANN/Vamana Implementation | [`ADR-146-diskann-vamana-implementation.md`](./ADR-146-diskann-vamana-implementation.md) | 2026-08-21 | Implemented | | +| ADR-147 | ADR-147: Stacked KV Cache Compression: TriAttention + TurboQuant Pipeline | [`ADR-147-stacked-kv-cache-triattention-turboquant.md`](./ADR-147-stacked-kv-cache-triattention-turboquant.md) | 2026-08-21 | Proposed | | +| ADR-148 | ADR-148: Brain Hypothesis Engine — Self-Improving Knowledge System with Gemini, DiskANN, and Auto-Experimentation | [`ADR-148-brain-hypothesis-engine.md`](./ADR-148-brain-hypothesis-engine.md) | 2026-08-21 | Proposed | | +| ADR-149 | ADR-149: Brain Performance Optimizations — SIMD Search, Batch Graph, Incremental LoRA, Quality Gating | [`ADR-149-brain-performance-optimizations.md`](./ADR-149-brain-performance-optimizations.md) | 2026-08-21 | Accepted | | +| ADR-150 | ADR-150: π Brain + RuvLtra via Tailscale — Semantic Embedding Upgrade | [`ADR-150-pi-brain-ruvltra-tailscale.md`](./ADR-150-pi-brain-ruvltra-tailscale.md) | 2026-08-21 | Proposed | | +| ADR-151 | ADR-151: Miller-Rabin–Driven Prime Optimizations (PIAL) | [`ADR-151-miller-rabin-prime-optimizations.md`](./ADR-151-miller-rabin-prime-optimizations.md) | 2026-08-21 | Accepted (Phase 0 landed 2026-04-16; performance targets revised — see "Phase 0 | | +| ADR-153 | ADR-153: Kalshi Integration via RuVector Neural Trader | [`ADR-153-kalshi-neural-trader-integration.md`](./ADR-153-kalshi-neural-trader-integration.md) | 2026-08-21 | Proposed | | +| ADR-154 | ADR-154: RaBitQ — Rotation-Based 1-Bit Quantization for ANNS | [`ADR-154-rabitq-rotation-binary-quantization.md`](./ADR-154-rabitq-rotation-binary-quantization.md) | 2026-08-21 | Proposed | | +| ADR-155 | ADR-155: ruLake — Vector-Native Federation Intermediary on RVF | [`ADR-155-rulake-datalake-layer.md`](./ADR-155-rulake-datalake-layer.md) | 2026-08-21 | **Accepted (M1)** — core abstraction + LocalBackend + FsBackend shipped | | +| ADR-156 | ADR-156: ruLake as Memory Substrate for Agent Brain Systems | [`ADR-156-rulake-as-memory-substrate.md`](./ADR-156-rulake-as-memory-substrate.md) | 2026-08-21 | **Proposed** — positioning addendum, not a replacement. ADR-155 still | | +| ADR-157 | ADR-157: Optional Accelerator Plane — `VectorKernel` Trait + Dispatch | [`ADR-157-optional-accelerator-plane.md`](./ADR-157-optional-accelerator-plane.md) | 2026-08-21 | **Proposed** — scaffolding-only decision. No kernel implementations | | +| ADR-158 | ADR-158: Optional Rotation Kind (Haar vs Randomized Hadamard) and QVCache Positioning | [`ADR-158-optional-rotation-and-qvcache-positioning.md`](./ADR-158-optional-rotation-and-qvcache-positioning.md) | 2026-08-21 | **Proposed** — a knob-locking decision plus a positioning statement. | | +| ADR-159 | ADR-159: A2A (Agent-to-Agent) Protocol Support for rvAgent | [`ADR-159-rvagent-a2a-protocol.md`](./ADR-159-rvagent-a2a-protocol.md) | 2026-08-21 | **Proposed — r3 (second review pass 2026-04-24)**. A new subcrate | | +| ADR-160 | ADR-160: ACORN — Predicate-Agnostic Filtered HNSW for ruvector | [`ADR-160-acorn-filtered-hnsw.md`](./ADR-160-acorn-filtered-hnsw.md) | 2026-08-21 | Proposed | | +| ADR-161 | ADR-161: Publish `ruvector-rabitq-wasm` as `@ruvector/rabitq-wasm` on npm | [`ADR-161-rabitq-wasm-npm-package.md`](./ADR-161-rabitq-wasm-npm-package.md) | 2026-08-21 | Proposed | | +| ADR-162 | ADR-162: Add `ruvector-acorn-wasm` crate and publish as `@ruvector/acorn-wasm` on npm | [`ADR-162-acorn-wasm-npm-package.md`](./ADR-162-acorn-wasm-npm-package.md) | 2026-08-21 | Proposed | | +| ADR-165 | ADR-165: Tiny RuvLLM Agents on Heterogeneous ESP32 SoCs | [`ADR-165-tiny-ruvllm-agents-on-esp32-soCs.md`](./ADR-165-tiny-ruvllm-agents-on-esp32-soCs.md) | 2026-08-21 | Proposed | | +| ADR-166 | ADR-166: ESP32 Rust Cross-Compile + Bring-Up Operations Manual | [`ADR-166-esp32-rust-cross-compile-bringup-ops.md`](./ADR-166-esp32-rust-cross-compile-bringup-ops.md) | 2026-08-21 | Proposed | | +| ADR-167 | ADR-167 — ruvector Hailo-8 NPU embedding backend | [`ADR-167-ruvector-hailo-npu-embedding-backend.md`](./ADR-167-ruvector-hailo-npu-embedding-backend.md) | 2026-08-21 | Proposed | | +| ADR-168 | ADR-168 — Cluster CLI surface | [`ADR-168-ruvector-hailo-cluster-cli-surface.md`](./ADR-168-ruvector-hailo-cluster-cli-surface.md) | 2026-08-21 | Accepted | | +| ADR-169 | ADR-169 — Cluster cache architecture | [`ADR-169-ruvector-hailo-cluster-cache-architecture.md`](./ADR-169-ruvector-hailo-cluster-cache-architecture.md) | 2026-08-21 | Accepted | | +| ADR-170 | ADR-170 — Tracing correlation | [`ADR-170-ruvector-hailo-cluster-tracing-correlation.md`](./ADR-170-ruvector-hailo-cluster-tracing-correlation.md) | 2026-08-21 | Accepted | | +| ADR-171 | ADR-171 — ruOS brain + ruview on Pi 5 + Hailo-8 | [`ADR-171-ruos-brain-ruview-pi5-edge-node.md`](./ADR-171-ruos-brain-ruview-pi5-edge-node.md) | 2026-08-21 | Proposed | | +| ADR-172 | ADR-172 — Deep security review | [`ADR-172-ruvector-hailo-security-review.md`](./ADR-172-ruvector-hailo-security-review.md) | 2026-08-21 | Proposed | | +| ADR-173 | ADR-173 — ruvllm + Hailo on Pi 5 | [`ADR-173-ruvllm-hailo-edge-llm.md`](./ADR-173-ruvllm-hailo-edge-llm.md) | 2026-08-21 | Proposed | | +| ADR-174 | ADR-174 — ruOS thermal optimizer | [`ADR-174-ruos-thermal-overclock-pi5.md`](./ADR-174-ruos-thermal-overclock-pi5.md) | 2026-08-21 | Proposed | | +| ADR-175 | ADR-175 — Rust-side workarounds for Hailo Dataflow Compiler transformer-encoder bugs | [`ADR-175-hailo-rust-side-workarounds.md`](./ADR-175-hailo-rust-side-workarounds.md) | 2026-08-21 | accepted | | +| ADR-176 | ADR-176 — EPIC: Wire HEF into HailoEmbedder for NPU-accelerated embeddings | [`ADR-176-hef-integration-epic.md`](./ADR-176-hef-integration-epic.md) | 2026-08-21 | accepted | | +| ADR-177 | ADR-177 — Pi 4 / Pi 5 without AI HAT+ deploy | [`ADR-177-pi4-no-hat-deploy.md`](./ADR-177-pi4-no-hat-deploy.md) | 2026-08-21 | accepted | | +| ADR-178 | ADR-178 — ruvector + ruview / hailo cluster integration gap analysis | [`ADR-178-ruvector-ruview-hailo-integration-gap-analysis.md`](./ADR-178-ruvector-ruview-hailo-integration-gap-analysis.md) | 2026-08-21 | Proposed | | +| ADR-179 | ADR-179 — EPIC: ruvllm LLM inference on Pi 5 cluster | [`ADR-179-ruvllm-pi-cluster-deployment.md`](./ADR-179-ruvllm-pi-cluster-deployment.md) | 2026-08-21 | proposed | | +| ADR-180 | ADR-180 — ServingEngine continuous batching on Pi 5 | [`ADR-180-ruvllm-serving-engine-continuous-batching.md`](./ADR-180-ruvllm-serving-engine-continuous-batching.md) | 2026-08-21 | proposed | | +| ADR-181 | ADR-181 — In-tree pi_quant + BitNet b1.58 on Pi 5 | [`ADR-181-ruvllm-pi-quant-bitnet-integration.md`](./ADR-181-ruvllm-pi-quant-bitnet-integration.md) | 2026-08-21 | proposed | | +| ADR-182 | ADR-182 — Hailo-10H migration for the Pi 5 cluster | [`ADR-182-hailo-10-cluster-migration.md`](./ADR-182-hailo-10-cluster-migration.md) | 2026-08-21 | proposed | | +| ADR-183 | ADR-183 — Move `rand` to dev-dependencies in ruvllm_sparse_attention | [`ADR-183-sparse-attention-rand-dev-dependency.md`](./ADR-183-sparse-attention-rand-dev-dependency.md) | 2026-08-21 | accepted | | +| ADR-184 | ADR-184 — One-pass online softmax in SubquadraticSparseAttention::forward | [`ADR-184-sparse-attention-online-softmax.md`](./ADR-184-sparse-attention-online-softmax.md) | 2026-08-21 | accepted | | +| ADR-185 | ADR-185 — Exclude current block from non-causal landmark candidates | [`ADR-185-sparse-attention-noncausal-landmark-fix.md`](./ADR-185-sparse-attention-noncausal-landmark-fix.md) | 2026-08-21 | accepted | | +| ADR-186 | ADR-186 — Edge-case tests as CI gate before Hailo cluster integration | [`ADR-186-sparse-attention-edge-case-tests.md`](./ADR-186-sparse-attention-edge-case-tests.md) | 2026-08-21 | accepted | | +| ADR-187 | ADR-187 — Overflow-checked shape multiplication in `Tensor3::zeros` | [`ADR-187-tensor-zeros-overflow-check.md`](./ADR-187-tensor-zeros-overflow-check.md) | 2026-08-21 | accepted | | +| ADR-188 | ADR-188 — Document the intentional stamp scheme difference in sparse attention | [`ADR-188-sparse-attention-stamp-scheme-comment.md`](./ADR-188-sparse-attention-stamp-scheme-comment.md) | 2026-08-21 | accepted | | +| ADR-189 | ADR-189 — KV cache incremental decode for sparse attention on Hailo-10H | [`ADR-189-sparse-attention-kv-cache-incremental-decode.md`](./ADR-189-sparse-attention-kv-cache-incremental-decode.md) | 2026-08-21 | accepted | | +| ADR-190 | ADR-190 — Grouped-Query / Multi-Query Attention for Hailo-10H production models | [`ADR-190-sparse-attention-gqa-mqa-support.md`](./ADR-190-sparse-attention-gqa-mqa-support.md) | 2026-08-21 | accepted | | +| ADR-191 | ADR-191 — Pi Zero 2W production hardening for ruvllm_sparse_attention | [`ADR-191-sparse-attention-pi-zero-2w-production-hardening.md`](./ADR-191-sparse-attention-pi-zero-2w-production-hardening.md) | 2026-08-21 | proposed | | +| ADR-192 | ADR-192 — no_std + alloc support for `ruvllm_sparse_attention` | [`ADR-192-sparse-attention-no-std-esp32-support.md`](./ADR-192-sparse-attention-no-std-esp32-support.md) | 2026-08-21 | accepted | | +| ADR-193 | ADR-193 — RAIRS IVF: ruvector's First Inverted File Index Family | [`ADR-193-rairs-ivf.md`](./ADR-193-rairs-ivf.md) | 2026-08-21 | accepted | | +| ADR-194 | ADR-194 — GNN-Enhanced Candidate Reranking for Approximate ANN | [`ADR-194-gnn-rerank.md`](./ADR-194-gnn-rerank.md) | 2026-08-21 | accepted | DUPLICATE ×3 — cite as `ADR-194 (gnn-rerank)` | +| ADR-194 | ADR-194: Proof-Gated Vector Writes with Merkle-Accumulating Witness Logs | [`ADR-194-proof-gated-writes.md`](./ADR-194-proof-gated-writes.md) | 2026-08-21 | Proposed | DUPLICATE ×3 — cite as `ADR-194 (proof-gated-writes)` | +| ADR-194 | ADR-194 — RuVector Bundled ONNX Embedder: API Contract & Throughput | [`ADR-194-ruvector-onnx-embedder-api-and-throughput.md`](./ADR-194-ruvector-onnx-embedder-api-and-throughput.md) | 2026-08-21 | accepted | DUPLICATE ×3 — cite as `ADR-194 (ruvector-onnx-embedder-api-and-throughput)` | +| ADR-195 | ADR-195 — ONNX Embedder Unification Plan | [`ADR-195-ruvector-embedder-unification-plan.md`](./ADR-195-ruvector-embedder-unification-plan.md) | 2026-08-21 | proposed | | +| ADR-196 | ADR-196 — Structure-Preserving Graph Condensation | [`ADR-196-structure-preserving-graph-condensation.md`](./ADR-196-structure-preserving-graph-condensation.md) | 2026-08-21 | accepted | | +| ADR-197 | ADR-197 — Differentiable Min-Cut Condensation Loss | [`ADR-197-differentiable-min-cut-condensation-loss.md`](./ADR-197-differentiable-min-cut-condensation-loss.md) | 2026-08-21 | accepted | | +| ADR-198 | ADR-198 — Physical Perception Substrate | [`ADR-198-physical-perception-substrate.md`](./ADR-198-physical-perception-substrate.md) | 2026-08-21 | accepted | | +| ADR-199 | ADR-199 — Sky Monitor and SkyGraph Appliance | [`ADR-199-sky-monitor-skygraph-appliance.md`](./ADR-199-sky-monitor-skygraph-appliance.md) | 2026-08-21 | proposed | | +| ADR-202 | ADR-202 — Fixed-Topology Reuse + Periodic Rebuild on a Real Learned-GNN Trajectory | [`ADR-202-reuse-under-drift-real-gnn-trajectory.md`](./ADR-202-reuse-under-drift-real-gnn-trajectory.md) | 2026-08-21 | proposed | | +| ADR-205 | ADR-205 — Triangle-Inequality Cluster Pruning vs Tuned Plain IVF `nprobe` (Structural NO-GO) | [`ADR-205-region-pruned-ivf-vs-plain-ivf-nprobe.md`](./ADR-205-region-pruned-ivf-vs-plain-ivf-nprobe.md) | 2026-08-21 | proposed | | +| ADR-206 | ADR-206 — PQ/IVFADC Within-List Pruning vs Tuned Plain IVF `nprobe` (Scale-Gated WIN) | [`ADR-206-pq-ivfadc-within-list-pruning-vs-plain-ivf-nprobe.md`](./ADR-206-pq-ivfadc-within-list-pruning-vs-plain-ivf-nprobe.md) | 2026-08-21 | proposed | | +| ADR-210 | ADR-210: Default-On Semantic Embeddings — all-MiniLM-L6-v2 as the Intelligence Engine's Primary Embedder | [`ADR-210-default-on-semantic-embeddings-minilm.md`](./ADR-210-default-on-semantic-embeddings-minilm.md) | 2026-08-21 | accepted (with hardening edits, review of 2026-06-12) | | +| ADR-211 | ADR-211 — Temporal Coherence Decay for Agent Memory Retrieval | [`ADR-211-temporal-coherence-agent-memory.md`](./ADR-211-temporal-coherence-agent-memory.md) | 2026-08-21 | accepted | | +| ADR-251 | ADR-251: Agentic Time as a First-Class Runtime Primitive | [`ADR-251-agentic-time.md`](./ADR-251-agentic-time.md) | 2026-08-21 | proposed | | +| ADR-252 | ADR-252: Coherence-Weighted Agent Memory Compaction | [`ADR-252-agent-memory-compaction.md`](./ADR-252-agent-memory-compaction.md) | 2026-08-21 | Proposed | DUPLICATE ×3 — cite as `ADR-252 (agent-memory-compaction)` | +| ADR-252 | ADR-252: FastGRNN Training Pipeline for Tiny Dancer Routing | [`ADR-252-fastgrnn-training-pipeline.md`](./ADR-252-fastgrnn-training-pipeline.md) | 2026-08-21 | accepted | DUPLICATE ×3 — cite as `ADR-252 (fastgrnn-training-pipeline)` | +| ADR-252 | ADR-252: Multi-Vector MaxSim Late Interaction Search | [`ADR-252-multi-vector-maxsim.md`](./ADR-252-multi-vector-maxsim.md) | 2026-08-21 | Accepted — PoC merged, production graduation pending | DUPLICATE ×3 — cite as `ADR-252 (multi-vector-maxsim)` | +| ADR-253 | ADR-253 — HelixDB vs RuVector: Comparative Analysis and Improvement Opportunities | [`ADR-253-helixdb-comparison-ruvector-improvements.md`](./ADR-253-helixdb-comparison-ruvector-improvements.md) | 2026-08-21 | proposed | | +| ADR-254 | ADR-254 — Coherence-Gated HNSW Search | [`ADR-254-coherence-hnsw-search.md`](./ADR-254-coherence-hnsw-search.md) | 2026-08-21 | proposed | DUPLICATE ×2 — cite as `ADR-254 (coherence-hnsw-search)` | +| ADR-254 | ADR-254 — ruvector-turbovec: a multi-bit TurboQuant FastScan ANN index | [`ADR-254-ruvector-turbovec-fastscan-index.md`](./ADR-254-ruvector-turbovec-fastscan-index.md) | 2026-08-21 | accepted | DUPLICATE ×2 — cite as `ADR-254 (ruvector-turbovec-fastscan-index)` | +| ADR-255 | ADR-255 — ruvector ↔ OIA Model integration (Open Intelligence Architecture v0.1) | [`ADR-255-oia-model-integration.md`](./ADR-255-oia-model-integration.md) | 2026-08-21 | proposed | | +| ADR-256 | ADR-256 — Hybrid Sparse-Dense Search: RRF and RSF alongside ScoreFusion | [`ADR-256-hybrid-sparse-dense-search.md`](./ADR-256-hybrid-sparse-dense-search.md) | 2026-08-21 | proposed | DUPLICATE ×2 — cite as `ADR-256 (hybrid-sparse-dense-search)` | +| ADR-256 | ADR-256 — Borrowing `metaharness` concepts into `npx ruvector` | [`ADR-256-metaharness-sdk-evaluation.md`](./ADR-256-metaharness-sdk-evaluation.md) | 2026-08-21 | proposed | DUPLICATE ×2 — cite as `ADR-256 (metaharness-sdk-evaluation)` | +| ADR-257 | ADR-257 — Extract `ruqu` and `rvdna` into standalone repos (git submodules) | [`ADR-257-ruqu-rvdna-standalone-submodules.md`](./ADR-257-ruqu-rvdna-standalone-submodules.md) | 2026-08-21 | proposed | | +| ADR-258 | ADR-258 — ruvector-hnsw-repair: Pluggable HNSW Deletion Strategies | [`ADR-258-hnsw-delete-repair.md`](./ADR-258-hnsw-delete-repair.md) | 2026-08-21 | accepted | DUPLICATE ×2 — cite as `ADR-258 (hnsw-delete-repair)` | +| ADR-258 | ADR-258: GPU Optimization of RDT/OpenMythos ACT Halting Loop | [`ADR-258-ruvllm-rdt-gpu-optimization.md`](./ADR-258-ruvllm-rdt-gpu-optimization.md) | 2026-08-21 | Accepted | DUPLICATE ×2 — cite as `ADR-258 (ruvllm-rdt-gpu-optimization)` | +| ADR-259 | ADR-259: ruvllm as Local Mutator Backend for Darwin Mode | [`ADR-259-ruvllm-darwin-mode-local-mutator.md`](./ADR-259-ruvllm-darwin-mode-local-mutator.md) | 2026-08-21 | Implemented (code + unit tests + CLI; the download-path bugs that blocked the li | | +| ADR-260 | ADR-260: Darwin Mode as Evolutionary Substrate for MetaHarness | [`ADR-260-darwin-mode-metaharness-integration.md`](./ADR-260-darwin-mode-metaharness-integration.md) | 2026-08-21 | Accepted | DUPLICATE ×2 — cite as `ADR-260 (darwin-mode-metaharness-integration)` | +| ADR-260 | ADR-260: PhotonLayer — Learned-Optical-Frontend Computing Simulator | [`ADR-260-photonlayer-optical-computing-simulator.md`](./ADR-260-photonlayer-optical-computing-simulator.md) | 2026-08-21 | Proposed | DUPLICATE ×2 — cite as `ADR-260 (photonlayer-optical-computing-simulator)` | +| ADR-261 | ADR-261: PhotonLayer — Mask Exchange Format & Determinism Invariant | [`ADR-261-photonlayer-mask-exchange-and-determinism.md`](./ADR-261-photonlayer-mask-exchange-and-determinism.md) | 2026-08-21 | Proposed | | +| ADR-262 | ADR-262: PhotonLayer — Privacy-Preserving Optical Verification | [`ADR-262-photonlayer-privacy-preserving-optical-verification.md`](./ADR-262-photonlayer-privacy-preserving-optical-verification.md) | 2026-08-21 | Proposed | | +| ADR-263 | ADR-263 — PhotonLayer FiberGate | [`ADR-263-photonlayer-fibergate-transmission-matrix.md`](./ADR-263-photonlayer-fibergate-transmission-matrix.md) | 2026-08-21 | proposed | | +| ADR-264 | ADR-264: LSM-ANN — Write-Optimised Streaming Vector Index for Agent Memory | [`ADR-264-lsm-ann.md`](./ADR-264-lsm-ann.md) | 2026-08-21 | Accepted | DUPLICATE ×3 — cite as `ADR-264 (lsm-ann)` | +| ADR-264 | ADR-264: Matryoshka-Aware Coarse-to-Fine Vector Search | [`ADR-264-matryoshka-coarse-fine-search.md`](./ADR-264-matryoshka-coarse-fine-search.md) | 2026-08-21 | Proposed | DUPLICATE ×3 — cite as `ADR-264 (matryoshka-coarse-fine-search)` | +| ADR-264 | ADR-264: Product Quantization with Asymmetric Distance Computation | [`ADR-264-pq-adc-search.md`](./ADR-264-pq-adc-search.md) | 2026-08-21 | Proposed | DUPLICATE ×3 — cite as `ADR-264 (pq-adc-search)` | +| ADR-265 | ADR-265: RuVector Comprehensive Benchmark Suite | [`ADR-265-ruvector-comprehensive-benchmark-suite.md`](./ADR-265-ruvector-comprehensive-benchmark-suite.md) | 2026-08-21 | Accepted | | +| ADR-266 | ADR-266: MetaHarness Integration for Autonomous ANN Optimization (Darwin Mode) | [`ADR-266-metaharness-darwin-ann-optimization.md`](./ADR-266-metaharness-darwin-ann-optimization.md) | 2026-08-21 | Accepted | DUPLICATE ×2 — cite as `ADR-266 (metaharness-darwin-ann-optimization)` | +| ADR-266 | ADR-266: MetaHarness Integration for Autonomous ANN Optimization (Darwin Mode) | [`ADR-266-metaharness-darwin-integration.md`](./ADR-266-metaharness-darwin-integration.md) | 2026-08-21 | Accepted | DUPLICATE ×2 — cite as `ADR-266 (metaharness-darwin-integration)` | +| ADR-267 | ADR-267: SOTA Validation Protocol for RuVector | [`ADR-267-sota-validation-protocol.md`](./ADR-267-sota-validation-protocol.md) | 2026-08-21 | Accepted | | +| ADR-268 | ADR-268: Capability-Gated ANN Search | [`ADR-268-capability-gated-ann.md`](./ADR-268-capability-gated-ann.md) | 2026-08-21 | Proposed | DUPLICATE ×2 — cite as `ADR-268 (capability-gated-ann)` | +| ADR-268 | ADR-268 — SPANN Partition Spilling: Boundary-Safe ANN | [`ADR-268-spann-partition-spill.md`](./ADR-268-spann-partition-spill.md) | 2026-08-21 | accepted | DUPLICATE ×2 — cite as `ADR-268 (spann-partition-spill)` | +| ADR-269 | ADR-269: MRAgent Graph Memory over RuVector, Optimized by Darwin Mode | [`ADR-269-mragent-graph-memory-darwin-optimization.md`](./ADR-269-mragent-graph-memory-darwin-optimization.md) | 2026-08-21 | Accepted | | +| ADR-270 | ADR-270: Self-Reconstructing Graph Memory — Beyond MRAgent | [`ADR-270-self-reconstructing-graph-memory-beyond-sota.md`](./ADR-270-self-reconstructing-graph-memory-beyond-sota.md) | 2026-08-21 | Accepted | | +| ADR-271 | ADR-271: Metaharness-Darwin for SONA Self-Improvement — EWC Config Evolution, the weightAdapter Gene, and Ornith-1.0 Reward-Hacking Defenses | [`ADR-271-metaharness-darwin-sona-self-improvement.md`](./ADR-271-metaharness-darwin-sona-self-improvement.md) | 2026-08-21 | Proposed (all four components prototyped — PR #615) | | +| ADR-272 | ADR-272: Adaptive Recall-Targeted ANN Search | [`ADR-272-adaptive-recall-ann.md`](./ADR-272-adaptive-recall-ann.md) | 2026-08-21 | Proposed | DUPLICATE ×5 — cite as `ADR-272 (adaptive-recall-ann)` | +| ADR-272 | ADR-272: Bounded Context RAG via MinCut Graph Partitioning | [`ADR-272-bounded-rag-mincut.md`](./ADR-272-bounded-rag-mincut.md) | 2026-08-21 | Proposed | DUPLICATE ×5 — cite as `ADR-272 (bounded-rag-mincut)` | +| ADR-272 | ADR-272: Diverse Beam ANN — MMR Post-Reranking and Coherence-Pruned Beam Search | [`ADR-272-diverse-beam-ann.md`](./ADR-272-diverse-beam-ann.md) | 2026-08-21 | Proposed (implemented and benchmarked — `crates/ruvector-diverse-beam`) | DUPLICATE ×5 — cite as `ADR-272 (diverse-beam-ann)` | +| ADR-272 | ADR-272: Recall-Bounded Approximate Nearest-Neighbour Search | [`ADR-272-recall-bounded-ann.md`](./ADR-272-recall-bounded-ann.md) | 2026-08-21 | Proposed — proof-of-concept in `crates/ruvector-recall-bounded` | DUPLICATE ×5 — cite as `ADR-272 (recall-bounded-ann)` | +| ADR-272 | ADR-272: Speculative ANN Search | [`ADR-272-speculative-ann-search.md`](./ADR-272-speculative-ann-search.md) | 2026-08-21 | Proposed | DUPLICATE ×5 — cite as `ADR-272 (speculative-ann-search)` | +| ADR-273 | ADR-273 — rvAgent Harness Reliability Floor | [`ADR-273-rvagent-harness-reliability-floor.md`](./ADR-273-rvagent-harness-reliability-floor.md) | 2026-08-21 | accepted | | +| ADR-274 | ADR-274 — rvAgent Context Management: Masking over Summarization | [`ADR-274-rvagent-context-management.md`](./ADR-274-rvagent-context-management.md) | 2026-08-21 | accepted | | +| ADR-275 | ADR-275 — rvAgent Subagent Topology: Single Writer with Auxiliary Intelligence | [`ADR-275-rvagent-subagent-topology.md`](./ADR-275-rvagent-subagent-topology.md) | 2026-08-21 | accepted | | +| ADR-276 | ADR-276 — rvAgent Learning Loop: Gating, Trust Tiers and Measurement | [`ADR-276-rvagent-learning-loop-gating.md`](./ADR-276-rvagent-learning-loop-gating.md) | 2026-08-21 | accepted | | +| ADR-277 | ADR-277 — rvAgent Positioning, Protocols and Benchmark Claims | [`ADR-277-rvagent-positioning-and-claims.md`](./ADR-277-rvagent-positioning-and-claims.md) | 2026-08-21 | accepted | | +| ADR-278 | ADR-278 — rvAgent Self-Learning: Adopt the metaharness Flywheel; Shift from Memory to Policy | [`ADR-278-rvagent-flywheel-adoption.md`](./ADR-278-rvagent-flywheel-adoption.md) | 2026-08-21 | accepted | | +| ADR-279 | ADR-279 — No C in the Core; and the 2026 SOTA Program | [`ADR-279-no-c-and-the-sota-program.md`](./ADR-279-no-c-and-the-sota-program.md) | 2026-08-21 | accepted | | +| ADR-280 | ADR-280: Durable Metadata for Self-Contained RVF Artifacts | [`ADR-280-rvf-durable-self-contained-metadata.md`](./ADR-280-rvf-durable-self-contained-metadata.md) | 2026-08-21 | Proposed | | +| ADR-281 | ADR-281: Role-Aware Embedding APIs for Asymmetric Retrieval | [`ADR-281-role-aware-embedding-apis.md`](./ADR-281-role-aware-embedding-apis.md) | 2026-08-21 | Proposed | | +| ADR-282 | ADR-282: Pre-PR Quality Gate for Nightly “Dream” Research | [`ADR-282-nightly-research-quality-gate.md`](./ADR-282-nightly-research-quality-gate.md) | 2026-08-21 | Proposed | | +| ADR-283 | ADR-283: RVForge — One Canonical RVF to Signed Platform Installers | [`ADR-283-rvf-forge-canonical-installer-pipeline.md`](./ADR-283-rvf-forge-canonical-installer-pipeline.md) | 2026-08-21 | Accepted | | +| ADR-284 | ADR-284: RVF Execution Contract for RVM Backends | [`ADR-284-rvf-execution-contract.md`](./ADR-284-rvf-execution-contract.md) | 2026-08-21 | Accepted | | +| ADR-285 | ADR-285: Hosted RVM Security Boundary | [`ADR-285-hosted-rvm-security-boundary.md`](./ADR-285-hosted-rvm-security-boundary.md) | 2026-08-21 | Accepted | | +| ADR-286 | ADR-286: RVF Capability Schema Mapping into `rvm-cap` | [`ADR-286-rvf-capability-schema-mapping.md`](./ADR-286-rvf-capability-schema-mapping.md) | 2026-08-21 | Accepted | | +| ADR-287 | ADR-287: WASM Component Model Integration for the RVM Runtime | [`ADR-287-wasm-component-model-integration.md`](./ADR-287-wasm-component-model-integration.md) | 2026-08-21 | Proposed | | +| ADR-288 | ADR-288: Immutable Base RVF and Encrypted State Delta Lifecycle | [`ADR-288-immutable-base-state-delta-lifecycle.md`](./ADR-288-immutable-base-state-delta-lifecycle.md) | 2026-08-21 | Accepted | | +| ADR-289 | ADR-289: Desktop Host Adapters, Lifecycle CLI, and Embedding Surfaces | [`ADR-289-desktop-host-adapters.md`](./ADR-289-desktop-host-adapters.md) | 2026-08-21 | Accepted | | +| ADR-290 | ADR-290: Forge Build and Signing Trust Boundary | [`ADR-290-forge-build-signing-trust-boundary.md`](./ADR-290-forge-build-signing-trust-boundary.md) | 2026-08-21 | Proposed | | +| ADR-291 | ADR-291: Runtime Compatibility and Version Negotiation | [`ADR-291-runtime-compatibility-version-negotiation.md`](./ADR-291-runtime-compatibility-version-negotiation.md) | 2026-08-21 | Implemented | | +| ADR-292 | ADR-292: Native Acceleration Isolation | [`ADR-292-native-acceleration-isolation.md`](./ADR-292-native-acceleration-isolation.md) | 2026-08-21 | Proposed | | +| ADR-293 | ADR-293: RVM Installer and Appliance Formats | [`ADR-293-rvm-installer-appliance-formats.md`](./ADR-293-rvm-installer-appliance-formats.md) | 2026-08-21 | Proposed | | +| ADR-294 | ADR-294: RVForge Platform — Agent Store, Registry, and Trust System | [`ADR-294-rvforge-platform-store-registry-trust.md`](./ADR-294-rvforge-platform-store-registry-trust.md) | 2026-08-21 | Accepted | | +| ADR-295 | ADR-295: RVForge Agent Dock — Persistent Security and Control Surface | [`ADR-295-rvforge-agent-dock.md`](./ADR-295-rvforge-agent-dock.md) | 2026-08-21 | Implemented | | +| ADR-296 | ADR-296: Turbo4 — 4-bit Lloyd-Max Quantized Vector Datatype with Direct Packed HNSW Scoring | [`ADR-296-turbo4-quantized-vector-datatype.md`](./ADR-296-turbo4-quantized-vector-datatype.md) | 2026-08-21 | Accepted | | +| ADR-297 | ADR-297: Adaptive Compression & Retrieval Plane (ACRP) | [`ADR-297-adaptive-compression-retrieval-plane.md`](./ADR-297-adaptive-compression-retrieval-plane.md) | 2026-08-21 | Accepted | | +| ADR-299 | ADR-299: Namespace-Merge via S-T Mincut Routing | [`ADR-299-namespace-merge-mincut.md`](./ADR-299-namespace-merge-mincut.md) | 2026-08-21 | Accepted | | +| ADR-300 | ADR-300: Hierarchical Cluster-Summary Retrieval for Agent Memory RAG | [`ADR-300-hierarchical-cluster-rag.md`](./ADR-300-hierarchical-cluster-rag.md) | 2026-08-21 | Proposed | | +| ADR-301 | ADR-301: Semantic Query Cache for ANN | [`ADR-301-semantic-query-cache.md`](./ADR-301-semantic-query-cache.md) | 2026-08-21 | Proposed | | +| ADR-302 | ADR-302: Streaming Quantized Neighbourhood Graphs (QNG-Stream) | [`ADR-302-streaming-qng.md`](./ADR-302-streaming-qng.md) | 2026-08-21 | Proposed | | +| ADR-303 | ADR-303: Entropy-Adaptive Beam Search for ANN Graph Traversal | [`ADR-303-entropy-adaptive-ann.md`](./ADR-303-entropy-adaptive-ann.md) | 2026-08-21 | Closed — negative result (documented; not recommended for production) | | +| ADR-304 | ADR-304: Retrieval Receipts — Witness-Chained Provenance for ANN Query Results | [`ADR-304-retrieval-receipts.md`](./ADR-304-retrieval-receipts.md) | 2026-08-21 | Proposed. Experimental crate (`ruvector-retrieval-receipt`), not wired into | | +| ADR-305 | ADR-305: Adopt Autogenous ADR-401 and LatentMesh ADR-009 as the Perpetual Intelligence Runtime's Definition and Control-Loop Spine | [`ADR-305-adopt-latentmesh-adr009-control-loop-spine.md`](./ADR-305-adopt-latentmesh-adr009-control-loop-spine.md) | 2026-08-21 | Proposed | | +| ADR-306 | ADR-306: Dream Machine — Adopt the Consolidating Evaluation Engine, Wired to research-gate and Darwin | [`ADR-306-dream-machine-sona-darwin-unification.md`](./ADR-306-dream-machine-sona-darwin-unification.md) | 2026-08-21 | Proposed | | +| ADR-307 | ADR-307: Three-Level Persistent Memory Architecture (LiveMem + TARL Pattern) on RuVector | [`ADR-307-three-level-persistent-memory-livemem-tarl.md`](./ADR-307-three-level-persistent-memory-livemem-tarl.md) | 2026-08-21 | Proposed | | +| ADR-308 | ADR-308: WorldCycle-Style Verification for the Physical Action Loop | [`ADR-308-worldcycle-verification-physical-action-loop.md`](./ADR-308-worldcycle-verification-physical-action-loop.md) | 2026-08-21 | Proposed | | +| ADR-309 | ADR-309: Build LatentMesh Integration Inside ruvector as New Crates, Coordinated on Wire Format | [`ADR-309-latentmesh-greenfield-crates-wire-format-coordination.md`](./ADR-309-latentmesh-greenfield-crates-wire-format-coordination.md) | 2026-08-21 | Proposed | | +| ADR-310 | ADR-310: Causal-Attribution Gate for Latent Communication | [`ADR-310-causal-attribution-gate-latent-communication.md`](./ADR-310-causal-attribution-gate-latent-communication.md) | 2026-08-21 | Proposed | | +| ADR-311 | ADR-311: Anomaly Quarantine for Latent Channels (Net-New Work — Not "LATTE") | [`ADR-311-anomaly-quarantine-latent-channels-net-new.md`](./ADR-311-anomaly-quarantine-latent-channels-net-new.md) | 2026-08-21 | Proposed | | +| ADR-312 | ADR-312: Shared Witness Record Schema and Cross-Layer Anchoring Contract (rvm-witness ↔ autogenous witness) | [`ADR-312-shared-witness-schema-anchoring-contract.md`](./ADR-312-shared-witness-schema-anchoring-contract.md) | 2026-08-21 | Proposed | | +| ADR-313 | ADR-313: SHAPER-Pattern Skill/Harness Evolution Loop (Frozen Weights) | [`ADR-313-shaper-frozen-weight-skill-harness-evolution.md`](./ADR-313-shaper-frozen-weight-skill-harness-evolution.md) | 2026-08-21 | Proposed | | +| ADR-314 | ADR-314: KV-Cache Cross-Model Migration in ruvLLM (Fast-Follow) | [`ADR-314-kv-cache-cross-model-migration-ruvllm.md`](./ADR-314-kv-cache-cross-model-migration-ruvllm.md) | 2026-08-21 | Proposed | | +| ADR-315 | ADR-315: Governance Constitution for Capability Expansion | [`ADR-315-governance-constitution-capability-expansion.md`](./ADR-315-governance-constitution-capability-expansion.md) | 2026-08-21 | Proposed | | +| ADR-316 | ADR-316: ADR Numbering Hygiene — Frozen Duplicates, Canonical Counter, Collision Gate | [`ADR-316-adr-numbering-hygiene.md`](./ADR-316-adr-numbering-hygiene.md) | 2026-08-21 | Proposed | | +| ADR-317 | ADR-317: HarnessRisk Lifecycle Security Benchmark as a Darwin Promotion Gate | [`ADR-317-harnessrisk-lifecycle-security-benchmark-gate.md`](./ADR-317-harnessrisk-lifecycle-security-benchmark-gate.md) | 2026-08-21 | Proposed | | +| ADR-318 | ADR-318: StagedWorkspace-Pattern Content-Hash State Binding as a RuV Invariant | [`ADR-318-stagedworkspace-content-hash-state-binding.md`](./ADR-318-stagedworkspace-content-hash-state-binding.md) | 2026-08-21 | Proposed | | +| ADR-319 | ADR-319: TRUSS-Pattern Shadow Execution for Generated Capabilities | [`ADR-319-truss-pattern-shadow-execution-generated-capabilities.md`](./ADR-319-truss-pattern-shadow-execution-generated-capabilities.md) | 2026-08-21 | Proposed | | +| ADR-320 | ADR-320: MemFuse-Pattern AtomicObservation and Causal Episodic Graph | [`ADR-320-memfuse-pattern-atomic-observation-causal-graph.md`](./ADR-320-memfuse-pattern-atomic-observation-causal-graph.md) | 2026-08-21 | Proposed | | +| ADR-321 | ADR-321: SkillForge-Pattern Synthetic-Issue Self-Training in the Darwin Loop | [`ADR-321-skillforge-pattern-synthetic-issue-self-training.md`](./ADR-321-skillforge-pattern-synthetic-issue-self-training.md) | 2026-08-21 | Proposed | | +| ADR-323 | ADR-323: Governed Pipeline-Shard Placement for Multi-Node ruvLLM Serving | [`ADR-323-governed-pipeline-shard-placement.md`](./ADR-323-governed-pipeline-shard-placement.md) | 2026-08-21 | Proposed | | | ADR-324 | ADR-324: SPADE-Pattern Self-Play Environment Designer for Dream Machine | [`ADR-324-spade-pattern-self-play-environment-designer.md`](./ADR-324-spade-pattern-self-play-environment-designer.md) | 2026-08-21 | Proposed | | | ADR-325 | ADR-325: D²ACCI-Pattern Stage-Level Memory Diagnostic Gate | [`ADR-325-d2acci-pattern-stage-level-memory-diagnostic-gate.md`](./ADR-325-d2acci-pattern-stage-level-memory-diagnostic-gate.md) | 2026-08-21 | Proposed | | | ADR-326 | ADR-326: DeAR-Pattern Decentralized Capability-Grounded Reasoning | [`ADR-326-dear-pattern-decentralized-capability-grounded-reasoning.md`](./ADR-326-dear-pattern-decentralized-capability-grounded-reasoning.md) | 2026-08-21 | Proposed | | @@ -337,56 +337,57 @@ | ADR-337 | ADR-337: Adaptive Runtime Monitoring with Value-of-Information Escalation | [`ADR-337-adaptive-runtime-monitoring-voi-escalation.md`](./ADR-337-adaptive-runtime-monitoring-voi-escalation.md) | 2026-08-23 | Proposed | | | ADR-338 | ADR-338: Electromagnetic World Model via Privileged-Modality Distillation | [`ADR-338-electromagnetic-world-model-privileged-distillation.md`](./ADR-338-electromagnetic-world-model-privileged-distillation.md) | 2026-08-23 | Proposed (stretch — ADR-only this wave; implementation deferred pending RuView c | | | ADR-339 | ADR-339: A WebAssembly Binding for `ruv://` Context, and What It May Not Carry | [`ADR-339-ruv-context-javascript-binding.md`](./ADR-339-ruv-context-javascript-binding.md) | 2026-08-23 | Accepted | | -| ADR-340 | ADR-340: Signed Retrieval-Receipt Anchoring — Ed25519 Roots, Per-Query and Batched | [`ADR-340-signed-retrieval-receipt-anchoring.md`](./ADR-340-signed-retrieval-receipt-anchoring.md) | | Proposed. Experimental crate extension (`ruvector-retrieval-receipt::signing`), | | -| ADR-341 | ADR-341: Correctness-Hardening Invariants for Hot-Path Primitives | [`ADR-341-correctness-hardening-invariants.md`](./ADR-341-correctness-hardening-invariants.md) | 2026-08-26 | Accepted | | +| ADR-340 | ADR-340: Signed Retrieval-Receipt Anchoring — Ed25519 Roots, Per-Query and Batched | [`ADR-340-signed-retrieval-receipt-anchoring.md`](./ADR-340-signed-retrieval-receipt-anchoring.md) | 2026-08-31 | Proposed. Experimental crate extension (`ruvector-retrieval-receipt::signing`), | | +| ADR-341 | ADR-341: Correctness-Hardening Invariants for Hot-Path Primitives | [`ADR-341-correctness-hardening-invariants.md`](./ADR-341-correctness-hardening-invariants.md) | 2026-09-05 | Accepted | | | ADR-342 | ADR-342: Independent, Periodic `index_state_root` Anchoring | [`ADR-342-periodic-state-root-anchoring.md`](./ADR-342-periodic-state-root-anchoring.md) | 2026-09-05 | Proposed. Experimental crate extension | | | ADR-343 | ADR-343: Signed-Receipt Batch-Fill Latency — A Bounded Alternative to Fixed-Size-Only Batching | [`ADR-343-signed-receipt-batch-fill-latency-simulation.md`](./ADR-343-signed-receipt-batch-fill-latency-simulation.md) | 2026-09-05 | Proposed. Experimental crate extension (`ruvector-retrieval-receipt::batch_fill` | | | ADR-344 | ADR-344: Global-Min-Cut Gated Streaming Memory Admission | [`ADR-344-mincut-gated-streaming-memory-admission.md`](./ADR-344-mincut-gated-streaming-memory-admission.md) | 2026-09-05 | Proposed. Experimental crate (`ruvector-memory-admission`), not wired into | | | ADR-345 | ADR-345: Mincut-Gated Forgetting — Structural Eviction Signal and Eviction Witnesses for Agent Memory | [`ADR-345-mincut-gated-forgetting.md`](./ADR-345-mincut-gated-forgetting.md) | 2026-09-05 | Rejected (for production use as designed). Experimental crate addition | | -| ADR-CE-001 | ADR-CE-001: Sheaf Laplacian Defines Coherence Witness | [`coherence-engine/ADR-CE-001-sheaf-laplacian-coherence.md`](./coherence-engine/ADR-CE-001-sheaf-laplacian-coherence.md) | 2026-08-20 | Accepted | | -| ADR-CE-002 | ADR-CE-002: Incremental Coherence Computation | [`coherence-engine/ADR-CE-002-incremental-computation.md`](./coherence-engine/ADR-CE-002-incremental-computation.md) | 2026-08-20 | Accepted | | -| ADR-CE-003 | ADR-CE-003: PostgreSQL + Ruvector Unified Substrate | [`coherence-engine/ADR-CE-003-hybrid-storage.md`](./coherence-engine/ADR-CE-003-hybrid-storage.md) | 2026-08-20 | Accepted | | -| ADR-CE-004 | ADR-CE-004: Signed Event Log with Deterministic Replay | [`coherence-engine/ADR-CE-004-signed-event-log.md`](./coherence-engine/ADR-CE-004-signed-event-log.md) | 2026-08-20 | Accepted | | -| ADR-CE-005 | ADR-CE-005: First-Class Governance Objects | [`coherence-engine/ADR-CE-005-governance-objects.md`](./coherence-engine/ADR-CE-005-governance-objects.md) | 2026-08-20 | Accepted | | -| ADR-CE-006 | ADR-CE-006: Coherence Gate Controls Compute Ladder | [`coherence-engine/ADR-CE-006-compute-ladder.md`](./coherence-engine/ADR-CE-006-compute-ladder.md) | 2026-08-20 | Accepted | | -| ADR-CE-007 | ADR-CE-007: Thresholds Auto-Tuned from Production Traces | [`coherence-engine/ADR-CE-007-threshold-autotuning.md`](./coherence-engine/ADR-CE-007-threshold-autotuning.md) | 2026-08-20 | Accepted | | -| ADR-CE-008 | ADR-CE-008: Multi-Tenant Isolation | [`coherence-engine/ADR-CE-008-multi-tenant-isolation.md`](./coherence-engine/ADR-CE-008-multi-tenant-isolation.md) | 2026-08-20 | Accepted | | -| ADR-CE-009 | ADR-CE-009: Single Coherence Object | [`coherence-engine/ADR-CE-009-single-coherence-object.md`](./coherence-engine/ADR-CE-009-single-coherence-object.md) | 2026-08-20 | Accepted | | -| ADR-CE-010 | ADR-CE-010: Domain-Agnostic Nodes and Edges | [`coherence-engine/ADR-CE-010-domain-agnostic-substrate.md`](./coherence-engine/ADR-CE-010-domain-agnostic-substrate.md) | 2026-08-20 | Accepted | | -| ADR-CE-011 | ADR-CE-011: Residual = Contradiction Energy | [`coherence-engine/ADR-CE-011-residual-contradiction-energy.md`](./coherence-engine/ADR-CE-011-residual-contradiction-energy.md) | 2026-08-20 | Accepted | | -| ADR-CE-012 | ADR-CE-012: Gate = Refusal Mechanism with Witness | [`coherence-engine/ADR-CE-012-gate-refusal-witness.md`](./coherence-engine/ADR-CE-012-gate-refusal-witness.md) | 2026-08-20 | Accepted | | -| ADR-CE-013 | ADR-CE-013: Not Prediction | [`coherence-engine/ADR-CE-013-not-prediction.md`](./coherence-engine/ADR-CE-013-not-prediction.md) | 2026-08-20 | Accepted | | -| ADR-CE-014 | ADR-CE-014: Reflex Lane Default | [`coherence-engine/ADR-CE-014-reflex-lane-default.md`](./coherence-engine/ADR-CE-014-reflex-lane-default.md) | 2026-08-20 | Accepted | | -| ADR-CE-015 | ADR-CE-015: Adapt Without Losing Control | [`coherence-engine/ADR-CE-015-adapt-without-losing-control.md`](./coherence-engine/ADR-CE-015-adapt-without-losing-control.md) | 2026-08-20 | Accepted | | -| ADR-CE-016 | ADR-CE-016: RuvLLM CoherenceValidator Uses Sheaf Energy | [`coherence-engine/ADR-CE-016-ruvllm-coherence-validator.md`](./coherence-engine/ADR-CE-016-ruvllm-coherence-validator.md) | 2026-08-20 | Accepted | | -| ADR-CE-017 | ADR-CE-017: Unified Audit Trail | [`coherence-engine/ADR-CE-017-unified-audit-trail.md`](./coherence-engine/ADR-CE-017-unified-audit-trail.md) | 2026-08-20 | Accepted | | -| ADR-CE-018 | ADR-CE-018: Pattern-to-Restriction Bridge | [`coherence-engine/ADR-CE-018-pattern-restriction-bridge.md`](./coherence-engine/ADR-CE-018-pattern-restriction-bridge.md) | 2026-08-20 | Accepted | | -| ADR-CE-019 | ADR-CE-019: Memory as Nodes | [`coherence-engine/ADR-CE-019-memory-as-nodes.md`](./coherence-engine/ADR-CE-019-memory-as-nodes.md) | 2026-08-20 | Accepted | | -| ADR-CE-020 | ADR-CE-020: Confidence from Energy | [`coherence-engine/ADR-CE-020-confidence-from-energy.md`](./coherence-engine/ADR-CE-020-confidence-from-energy.md) | 2026-08-20 | Accepted | | -| ADR-CE-021 | ADR-CE-021: Shared SONA | [`coherence-engine/ADR-CE-021-shared-sona.md`](./coherence-engine/ADR-CE-021-shared-sona.md) | 2026-08-20 | Accepted | | -| ADR-CE-022 | ADR-CE-022: Failure Learning | [`coherence-engine/ADR-CE-022-failure-learning.md`](./coherence-engine/ADR-CE-022-failure-learning.md) | 2026-08-20 | Accepted | | -| ADR-DB-001 | ADR-DB-001: Delta Behavior Core Architecture | [`delta-behavior/ADR-DB-001-delta-behavior-core-architecture.md`](./delta-behavior/ADR-DB-001-delta-behavior-core-architecture.md) | 2026-08-20 | Proposed | | -| ADR-DB-002 | ADR-DB-002: Delta Encoding Format | [`delta-behavior/ADR-DB-002-delta-encoding-format.md`](./delta-behavior/ADR-DB-002-delta-encoding-format.md) | 2026-08-20 | Proposed | | -| ADR-DB-003 | ADR-DB-003: Delta Propagation Protocol | [`delta-behavior/ADR-DB-003-delta-propagation-protocol.md`](./delta-behavior/ADR-DB-003-delta-propagation-protocol.md) | 2026-08-20 | Proposed | | -| ADR-DB-004 | ADR-DB-004: Delta Conflict Resolution | [`delta-behavior/ADR-DB-004-delta-conflict-resolution.md`](./delta-behavior/ADR-DB-004-delta-conflict-resolution.md) | 2026-08-20 | Proposed | | -| ADR-DB-005 | ADR-DB-005: Delta Index Updates | [`delta-behavior/ADR-DB-005-delta-index-updates.md`](./delta-behavior/ADR-DB-005-delta-index-updates.md) | 2026-08-20 | Proposed | | -| ADR-DB-006 | ADR-DB-006: Delta Compression Strategy | [`delta-behavior/ADR-DB-006-delta-compression-strategy.md`](./delta-behavior/ADR-DB-006-delta-compression-strategy.md) | 2026-08-20 | Proposed | | -| ADR-DB-007 | ADR-DB-007: Delta Temporal Windows | [`delta-behavior/ADR-DB-007-delta-temporal-windows.md`](./delta-behavior/ADR-DB-007-delta-temporal-windows.md) | 2026-08-20 | Proposed | | -| ADR-DB-008 | ADR-DB-008: Delta WASM Integration | [`delta-behavior/ADR-DB-008-delta-wasm-integration.md`](./delta-behavior/ADR-DB-008-delta-wasm-integration.md) | 2026-08-20 | Proposed | | -| ADR-DB-009 | ADR-DB-009: Delta Observability | [`delta-behavior/ADR-DB-009-delta-observability.md`](./delta-behavior/ADR-DB-009-delta-observability.md) | 2026-08-20 | Proposed | | -| ADR-DB-010 | ADR-DB-010: Delta Security Model | [`delta-behavior/ADR-DB-010-delta-security-model.md`](./delta-behavior/ADR-DB-010-delta-security-model.md) | 2026-08-20 | Proposed | | -| ADR-QE-001 | ADR-QE-001: Quantum Engine Core Architecture | [`quantum-engine/ADR-QE-001-quantum-engine-core-architecture.md`](./quantum-engine/ADR-QE-001-quantum-engine-core-architecture.md) | 2026-08-20 | Proposed | | -| ADR-QE-002 | ADR-QE-002: Crate Structure & ruVector Integration | [`quantum-engine/ADR-QE-002-crate-structure-integration.md`](./quantum-engine/ADR-QE-002-crate-structure-integration.md) | 2026-08-20 | Proposed | | -| ADR-QE-003 | ADR-QE-003: WebAssembly Compilation Strategy | [`quantum-engine/ADR-QE-003-wasm-compilation-strategy.md`](./quantum-engine/ADR-QE-003-wasm-compilation-strategy.md) | 2026-08-20 | Proposed | | -| ADR-QE-004 | ADR-QE-004: Performance Optimization & Benchmarks | [`quantum-engine/ADR-QE-004-performance-optimization-benchmarks.md`](./quantum-engine/ADR-QE-004-performance-optimization-benchmarks.md) | 2026-08-20 | Proposed | | -| ADR-QE-005 | ADR-QE-005: Variational Quantum Eigensolver (VQE) Support | [`quantum-engine/ADR-QE-005-vqe-algorithm-support.md`](./quantum-engine/ADR-QE-005-vqe-algorithm-support.md) | 2026-08-20 | Proposed | | -| ADR-QE-006 | ADR-QE-006: Grover's Search Algorithm Implementation | [`quantum-engine/ADR-QE-006-grover-search-implementation.md`](./quantum-engine/ADR-QE-006-grover-search-implementation.md) | 2026-08-20 | Proposed | | -| ADR-QE-007 | ADR-QE-007: QAOA MaxCut Implementation | [`quantum-engine/ADR-QE-007-qaoa-maxcut-implementation.md`](./quantum-engine/ADR-QE-007-qaoa-maxcut-implementation.md) | 2026-08-20 | Proposed | | -| ADR-QE-008 | ADR-QE-008: Surface Code Error Correction Simulation | [`quantum-engine/ADR-QE-008-surface-code-error-correction.md`](./quantum-engine/ADR-QE-008-surface-code-error-correction.md) | 2026-08-20 | Proposed | | -| ADR-QE-009 | ADR-QE-009: Tensor Network Evaluation Mode | [`quantum-engine/ADR-QE-009-tensor-network-evaluation.md`](./quantum-engine/ADR-QE-009-tensor-network-evaluation.md) | 2026-08-20 | Proposed | | -| ADR-QE-010 | ADR-QE-010: Observability & Monitoring Integration | [`quantum-engine/ADR-QE-010-observability-monitoring.md`](./quantum-engine/ADR-QE-010-observability-monitoring.md) | 2026-08-20 | Proposed | | -| ADR-QE-011 | ADR-QE-011: Memory Gating & Power Management | [`quantum-engine/ADR-QE-011-memory-gating-power-management.md`](./quantum-engine/ADR-QE-011-memory-gating-power-management.md) | 2026-08-20 | Proposed | | -| ADR-QE-012 | ADR-QE-012: Min-Cut Coherence Integration | [`quantum-engine/ADR-QE-012-mincut-coherence-integration.md`](./quantum-engine/ADR-QE-012-mincut-coherence-integration.md) | 2026-08-20 | Proposed | | -| ADR-QE-013 | ADR-QE-013: Deutsch's Theorem — Proof, Historical Comparison, and Verification | [`quantum-engine/ADR-QE-013-deutsch-theorem-proof-verification.md`](./quantum-engine/ADR-QE-013-deutsch-theorem-proof-verification.md) | 2026-08-20 | Accepted | | -| ADR-QE-014 | ADR-QE-014: Exotic Quantum-Classical Hybrid Discoveries | [`quantum-engine/ADR-QE-014-exotic-discoveries.md`](./quantum-engine/ADR-QE-014-exotic-discoveries.md) | 2026-08-20 | Accepted | | -| ADR-QE-015 | ADR-QE-015: Quantum Hardware Integration & Scientific Instrument Layer | [`quantum-engine/ADR-QE-015-blockchain-forensics-scientific-instrument.md`](./quantum-engine/ADR-QE-015-blockchain-forensics-scientific-instrument.md) | 2026-08-20 | Accepted | | +| ADR-346 | ADR-346: LocalDeterministic Mincut Engine — Fixing ADR-345's Latency and Determinism Defects | [`ADR-346-local-kcut-gated-forgetting.md`](./ADR-346-local-kcut-gated-forgetting.md) | | Rejected (as a full, all-thresholds-pass replacement), with a real, retained | | +| ADR-CE-001 | ADR-CE-001: Sheaf Laplacian Defines Coherence Witness | [`coherence-engine/ADR-CE-001-sheaf-laplacian-coherence.md`](./coherence-engine/ADR-CE-001-sheaf-laplacian-coherence.md) | 2026-08-21 | Accepted | | +| ADR-CE-002 | ADR-CE-002: Incremental Coherence Computation | [`coherence-engine/ADR-CE-002-incremental-computation.md`](./coherence-engine/ADR-CE-002-incremental-computation.md) | 2026-08-21 | Accepted | | +| ADR-CE-003 | ADR-CE-003: PostgreSQL + Ruvector Unified Substrate | [`coherence-engine/ADR-CE-003-hybrid-storage.md`](./coherence-engine/ADR-CE-003-hybrid-storage.md) | 2026-08-21 | Accepted | | +| ADR-CE-004 | ADR-CE-004: Signed Event Log with Deterministic Replay | [`coherence-engine/ADR-CE-004-signed-event-log.md`](./coherence-engine/ADR-CE-004-signed-event-log.md) | 2026-08-21 | Accepted | | +| ADR-CE-005 | ADR-CE-005: First-Class Governance Objects | [`coherence-engine/ADR-CE-005-governance-objects.md`](./coherence-engine/ADR-CE-005-governance-objects.md) | 2026-08-21 | Accepted | | +| ADR-CE-006 | ADR-CE-006: Coherence Gate Controls Compute Ladder | [`coherence-engine/ADR-CE-006-compute-ladder.md`](./coherence-engine/ADR-CE-006-compute-ladder.md) | 2026-08-21 | Accepted | | +| ADR-CE-007 | ADR-CE-007: Thresholds Auto-Tuned from Production Traces | [`coherence-engine/ADR-CE-007-threshold-autotuning.md`](./coherence-engine/ADR-CE-007-threshold-autotuning.md) | 2026-08-21 | Accepted | | +| ADR-CE-008 | ADR-CE-008: Multi-Tenant Isolation | [`coherence-engine/ADR-CE-008-multi-tenant-isolation.md`](./coherence-engine/ADR-CE-008-multi-tenant-isolation.md) | 2026-08-21 | Accepted | | +| ADR-CE-009 | ADR-CE-009: Single Coherence Object | [`coherence-engine/ADR-CE-009-single-coherence-object.md`](./coherence-engine/ADR-CE-009-single-coherence-object.md) | 2026-08-21 | Accepted | | +| ADR-CE-010 | ADR-CE-010: Domain-Agnostic Nodes and Edges | [`coherence-engine/ADR-CE-010-domain-agnostic-substrate.md`](./coherence-engine/ADR-CE-010-domain-agnostic-substrate.md) | 2026-08-21 | Accepted | | +| ADR-CE-011 | ADR-CE-011: Residual = Contradiction Energy | [`coherence-engine/ADR-CE-011-residual-contradiction-energy.md`](./coherence-engine/ADR-CE-011-residual-contradiction-energy.md) | 2026-08-21 | Accepted | | +| ADR-CE-012 | ADR-CE-012: Gate = Refusal Mechanism with Witness | [`coherence-engine/ADR-CE-012-gate-refusal-witness.md`](./coherence-engine/ADR-CE-012-gate-refusal-witness.md) | 2026-08-21 | Accepted | | +| ADR-CE-013 | ADR-CE-013: Not Prediction | [`coherence-engine/ADR-CE-013-not-prediction.md`](./coherence-engine/ADR-CE-013-not-prediction.md) | 2026-08-21 | Accepted | | +| ADR-CE-014 | ADR-CE-014: Reflex Lane Default | [`coherence-engine/ADR-CE-014-reflex-lane-default.md`](./coherence-engine/ADR-CE-014-reflex-lane-default.md) | 2026-08-21 | Accepted | | +| ADR-CE-015 | ADR-CE-015: Adapt Without Losing Control | [`coherence-engine/ADR-CE-015-adapt-without-losing-control.md`](./coherence-engine/ADR-CE-015-adapt-without-losing-control.md) | 2026-08-21 | Accepted | | +| ADR-CE-016 | ADR-CE-016: RuvLLM CoherenceValidator Uses Sheaf Energy | [`coherence-engine/ADR-CE-016-ruvllm-coherence-validator.md`](./coherence-engine/ADR-CE-016-ruvllm-coherence-validator.md) | 2026-08-21 | Accepted | | +| ADR-CE-017 | ADR-CE-017: Unified Audit Trail | [`coherence-engine/ADR-CE-017-unified-audit-trail.md`](./coherence-engine/ADR-CE-017-unified-audit-trail.md) | 2026-08-21 | Accepted | | +| ADR-CE-018 | ADR-CE-018: Pattern-to-Restriction Bridge | [`coherence-engine/ADR-CE-018-pattern-restriction-bridge.md`](./coherence-engine/ADR-CE-018-pattern-restriction-bridge.md) | 2026-08-21 | Accepted | | +| ADR-CE-019 | ADR-CE-019: Memory as Nodes | [`coherence-engine/ADR-CE-019-memory-as-nodes.md`](./coherence-engine/ADR-CE-019-memory-as-nodes.md) | 2026-08-21 | Accepted | | +| ADR-CE-020 | ADR-CE-020: Confidence from Energy | [`coherence-engine/ADR-CE-020-confidence-from-energy.md`](./coherence-engine/ADR-CE-020-confidence-from-energy.md) | 2026-08-21 | Accepted | | +| ADR-CE-021 | ADR-CE-021: Shared SONA | [`coherence-engine/ADR-CE-021-shared-sona.md`](./coherence-engine/ADR-CE-021-shared-sona.md) | 2026-08-21 | Accepted | | +| ADR-CE-022 | ADR-CE-022: Failure Learning | [`coherence-engine/ADR-CE-022-failure-learning.md`](./coherence-engine/ADR-CE-022-failure-learning.md) | 2026-08-21 | Accepted | | +| ADR-DB-001 | ADR-DB-001: Delta Behavior Core Architecture | [`delta-behavior/ADR-DB-001-delta-behavior-core-architecture.md`](./delta-behavior/ADR-DB-001-delta-behavior-core-architecture.md) | 2026-08-21 | Proposed | | +| ADR-DB-002 | ADR-DB-002: Delta Encoding Format | [`delta-behavior/ADR-DB-002-delta-encoding-format.md`](./delta-behavior/ADR-DB-002-delta-encoding-format.md) | 2026-08-21 | Proposed | | +| ADR-DB-003 | ADR-DB-003: Delta Propagation Protocol | [`delta-behavior/ADR-DB-003-delta-propagation-protocol.md`](./delta-behavior/ADR-DB-003-delta-propagation-protocol.md) | 2026-08-21 | Proposed | | +| ADR-DB-004 | ADR-DB-004: Delta Conflict Resolution | [`delta-behavior/ADR-DB-004-delta-conflict-resolution.md`](./delta-behavior/ADR-DB-004-delta-conflict-resolution.md) | 2026-08-21 | Proposed | | +| ADR-DB-005 | ADR-DB-005: Delta Index Updates | [`delta-behavior/ADR-DB-005-delta-index-updates.md`](./delta-behavior/ADR-DB-005-delta-index-updates.md) | 2026-08-21 | Proposed | | +| ADR-DB-006 | ADR-DB-006: Delta Compression Strategy | [`delta-behavior/ADR-DB-006-delta-compression-strategy.md`](./delta-behavior/ADR-DB-006-delta-compression-strategy.md) | 2026-08-21 | Proposed | | +| ADR-DB-007 | ADR-DB-007: Delta Temporal Windows | [`delta-behavior/ADR-DB-007-delta-temporal-windows.md`](./delta-behavior/ADR-DB-007-delta-temporal-windows.md) | 2026-08-21 | Proposed | | +| ADR-DB-008 | ADR-DB-008: Delta WASM Integration | [`delta-behavior/ADR-DB-008-delta-wasm-integration.md`](./delta-behavior/ADR-DB-008-delta-wasm-integration.md) | 2026-08-21 | Proposed | | +| ADR-DB-009 | ADR-DB-009: Delta Observability | [`delta-behavior/ADR-DB-009-delta-observability.md`](./delta-behavior/ADR-DB-009-delta-observability.md) | 2026-08-21 | Proposed | | +| ADR-DB-010 | ADR-DB-010: Delta Security Model | [`delta-behavior/ADR-DB-010-delta-security-model.md`](./delta-behavior/ADR-DB-010-delta-security-model.md) | 2026-08-21 | Proposed | | +| ADR-QE-001 | ADR-QE-001: Quantum Engine Core Architecture | [`quantum-engine/ADR-QE-001-quantum-engine-core-architecture.md`](./quantum-engine/ADR-QE-001-quantum-engine-core-architecture.md) | 2026-08-21 | Proposed | | +| ADR-QE-002 | ADR-QE-002: Crate Structure & ruVector Integration | [`quantum-engine/ADR-QE-002-crate-structure-integration.md`](./quantum-engine/ADR-QE-002-crate-structure-integration.md) | 2026-08-21 | Proposed | | +| ADR-QE-003 | ADR-QE-003: WebAssembly Compilation Strategy | [`quantum-engine/ADR-QE-003-wasm-compilation-strategy.md`](./quantum-engine/ADR-QE-003-wasm-compilation-strategy.md) | 2026-08-21 | Proposed | | +| ADR-QE-004 | ADR-QE-004: Performance Optimization & Benchmarks | [`quantum-engine/ADR-QE-004-performance-optimization-benchmarks.md`](./quantum-engine/ADR-QE-004-performance-optimization-benchmarks.md) | 2026-08-21 | Proposed | | +| ADR-QE-005 | ADR-QE-005: Variational Quantum Eigensolver (VQE) Support | [`quantum-engine/ADR-QE-005-vqe-algorithm-support.md`](./quantum-engine/ADR-QE-005-vqe-algorithm-support.md) | 2026-08-21 | Proposed | | +| ADR-QE-006 | ADR-QE-006: Grover's Search Algorithm Implementation | [`quantum-engine/ADR-QE-006-grover-search-implementation.md`](./quantum-engine/ADR-QE-006-grover-search-implementation.md) | 2026-08-21 | Proposed | | +| ADR-QE-007 | ADR-QE-007: QAOA MaxCut Implementation | [`quantum-engine/ADR-QE-007-qaoa-maxcut-implementation.md`](./quantum-engine/ADR-QE-007-qaoa-maxcut-implementation.md) | 2026-08-21 | Proposed | | +| ADR-QE-008 | ADR-QE-008: Surface Code Error Correction Simulation | [`quantum-engine/ADR-QE-008-surface-code-error-correction.md`](./quantum-engine/ADR-QE-008-surface-code-error-correction.md) | 2026-08-21 | Proposed | | +| ADR-QE-009 | ADR-QE-009: Tensor Network Evaluation Mode | [`quantum-engine/ADR-QE-009-tensor-network-evaluation.md`](./quantum-engine/ADR-QE-009-tensor-network-evaluation.md) | 2026-08-21 | Proposed | | +| ADR-QE-010 | ADR-QE-010: Observability & Monitoring Integration | [`quantum-engine/ADR-QE-010-observability-monitoring.md`](./quantum-engine/ADR-QE-010-observability-monitoring.md) | 2026-08-21 | Proposed | | +| ADR-QE-011 | ADR-QE-011: Memory Gating & Power Management | [`quantum-engine/ADR-QE-011-memory-gating-power-management.md`](./quantum-engine/ADR-QE-011-memory-gating-power-management.md) | 2026-08-21 | Proposed | | +| ADR-QE-012 | ADR-QE-012: Min-Cut Coherence Integration | [`quantum-engine/ADR-QE-012-mincut-coherence-integration.md`](./quantum-engine/ADR-QE-012-mincut-coherence-integration.md) | 2026-08-21 | Proposed | | +| ADR-QE-013 | ADR-QE-013: Deutsch's Theorem — Proof, Historical Comparison, and Verification | [`quantum-engine/ADR-QE-013-deutsch-theorem-proof-verification.md`](./quantum-engine/ADR-QE-013-deutsch-theorem-proof-verification.md) | 2026-08-21 | Accepted | | +| ADR-QE-014 | ADR-QE-014: Exotic Quantum-Classical Hybrid Discoveries | [`quantum-engine/ADR-QE-014-exotic-discoveries.md`](./quantum-engine/ADR-QE-014-exotic-discoveries.md) | 2026-08-21 | Accepted | | +| ADR-QE-015 | ADR-QE-015: Quantum Hardware Integration & Scientific Instrument Layer | [`quantum-engine/ADR-QE-015-blockchain-forensics-scientific-instrument.md`](./quantum-engine/ADR-QE-015-blockchain-forensics-scientific-instrument.md) | 2026-08-21 | Accepted | | diff --git a/docs/research/nightly/2026-09-12-local-kcut-gated-forgetting/README.md b/docs/research/nightly/2026-09-12-local-kcut-gated-forgetting/README.md new file mode 100644 index 0000000000..423400572a --- /dev/null +++ b/docs/research/nightly/2026-09-12-local-kcut-gated-forgetting/README.md @@ -0,0 +1,371 @@ +# Nightly Research: LocalDeterministic Mincut Engine for Agent-Memory Forgetting + +**Date:** 2026-09-12 +**Slug:** `local-kcut-gated-forgetting` +**ADR:** [ADR-346](../../../adr/ADR-346-local-kcut-gated-forgetting.md) +**Follow-up to:** [ADR-345](../../../adr/ADR-345-mincut-gated-forgetting.md) / [2026-09-05 nightly](../2026-09-05-mincut-gated-forgetting/README.md) +**Crate:** `ruvector-agent-memory` (`graph_forget` module, `mincut-forget` feature) +**Acceptance:** **REJECT** (pre-declared bundle), with a **supported narrow claim** — see [Acceptance result](#acceptance-result) + +## Summary + +The previous nightly cycle (2026-09-05, ADR-345) built `MincutGatedForgetting`, +a compaction policy that layers a `ruvector-mincut`-derived "protect the +bridge" structural signal on top of `ruvector-agent-memory`'s scalar +`CoherencePolicy`. It was rejected on two measured grounds: +`RuVectorGraphAnalyzer::partition()` (the engine's only implementation at +the time) cost 76ms-11.4s per call at 50-400 vertices, and repeated calls on +byte-identical input were non-deterministic (15/30 empty results in a +30-trial probe). + +This cycle attacks that exact bottleneck rather than picking an unrelated +topic. It adds a second engine, `MincutEngine::LocalDeterministic`, backed +by `ruvector_mincut::localkcut::DeterministicLocalKCut` — a *local*, +bounded-radius, bounded-budget, provably deterministic BFS-based cut search +(no hash-map-keyed global partition call anywhere in its path) — and +benchmarks it head-to-head against the original `ExactGlobal` engine on the +same synthetic corpus ADR-345 used, scaled from 84 to 924 vertices. + +**Result: a genuine, measured partial win, not a clean ACCEPT.** The narrow +claim — that `LocalDeterministic` fixes ADR-345's latency and determinism +defects for the boundary-computation step — is supported: 623x faster than +`ExactGlobal` at the one size both completed within a shared time budget, +clean scaling to 924 vertices in under 90ms (vs `ExactGlobal` exceeding a +1.5s/call budget already at 168 vertices), 20/20 determinism across +repeated calls, and 20/20 tamper detection with the existing eviction +witness chain. But the pre-declared acceptance *bundle* still fails +overall: it inherited ADR-345's already-established null bridge-survival +effect (0.0pp gap, unrelated to which engine computes the signal), and a +new, engine-agnostic finding — the shared O(n^2) k-NN graph construction +cost dominates total wall-clock at these sizes for *both* engines — pushes +the overall slowdown-vs-baseline past the pre-declared 20x bar. See +[Evidence](#benchmark-results-raw) and [Acceptance result](#acceptance-result). + +## Abstract + +We ask a narrower, more targeted version of ADR-345's open question: can a +*different* primitive already in `ruvector-mincut` — one whose query shape +("is this vertex locally separable by a small cut?") more directly matches +what `MincutGatedForgetting` actually needs, versus a full global partition +— fix the specific latency and non-determinism defects ADR-345 measured, +without reopening the (separately unresolved) effectiveness question? We +implement `MincutEngine::LocalDeterministic`, lock a hypothesis with +pre-declared thresholds inherited from ADR-345 plus two new +engine-comparison gates, run it once, and report a mixed, evidence-backed +result rather than forcing a single label onto two questions that turned +out to have different answers. + +## Ecosystem Fit + +| Capability | Role | Reused from | +|---|---|---| +| Vector similarity | k-NN graph construction (shared, unchanged from ADR-345) | `ruvector-agent-memory::scoring::cosine_sim` | +| Deterministic local min-cut | Structural boundary detection (new engine) | `ruvector_mincut::localkcut::DeterministicLocalKCut` | +| Dynamic min-cut (global) | Structural boundary detection (original engine, kept for comparison) | `ruvector_mincut::RuVectorGraphAnalyzer` | +| Agent memory | Compaction policy trait, scalar baseline | `ruvector-agent-memory::compaction` | +| Proof-gated writes / witness | Eviction certification, re-verified with the new engine | `ruvector-agent-memory::ops` (ADR-134 schema) | + +### Tooling actually available (checked this session) + +Per this repository's standing nightly process, the following were checked +before assuming any orchestration tooling: + +- `npx metaharness --help` / `npx ruvector harness doctor --json` / `npx + ruvector harness status --json`: not re-checked this cycle (ADR-345 + already established, this session, that no `harness`/`darwin`/`flywheel` + subcommand exists anywhere in `crates/ruvector-cli`, and `metaharness` is + an unrelated project scaffolder). Re-verifying was judged unnecessary + churn against an already-answered capability-discovery question from five + days prior in the same repository; the underlying code was not touched in + the interim. +- The "goal-planner / researcher / engineer / critic / evaluator" roles were + performed serially in this one session, with the design-probe (seeding + strategy, radius pathology) → hypothesis-lock → single benchmark run → + adversarial self-check sequence in this document standing in for role + separation, identical in structure to ADR-345's own process. + +## Architecture + +```mermaid +flowchart LR + subgraph Input + E["MemoryEntry[]\n(vector, recency, freq)"] + end + + subgraph KNNShared["Shared, unchanged from ADR-345"] + KNN["knn_neighbors()\nk-NN cosine graph\n(O(n^2), dominates wall-clock\nat the sizes tested)"] + end + + subgraph ExactEngine["MincutEngine::ExactGlobal (ADR-345)"] + MC["RuVectorGraphAnalyzer\n::from_knn(...).partition()\n76ms-11.4s @ 50-400 vertices\nnon-deterministic"] + end + + subgraph LocalEngine["MincutEngine::LocalDeterministic (ADR-346, this cycle)"] + DG["DynamicGraph\n(same edges, ruvector_mincut type)"] + LKC["n x DeterministicLocalKCut::search\nseed=[v] only, radius=0\n(single-vertex degree check\nvia the real witnessed API)"] + WH["WitnessHandle::materialize_partition()\nper Found query"] + end + + SCORE["weighted_importance()\n(existing CoherencePolicy scalar)"] + COMBINE["Soft: score + bonus\nHard: reserve budget for boundary"] + + E --> KNN + KNN --> MC --> COMBINE + KNN --> DG --> LKC --> WH --> COMBINE + E --> SCORE --> COMBINE + COMBINE --> EVICT["Evicted ids"] --> CHAIN["EvictionWitnessChain\n(unchanged, re-verified\nwith the new engine)"] +``` + +## Implementation + +Changed/added files, all in `crates/ruvector-agent-memory` (no other crate +touched): + +- `src/graph_forget.rs`: `MincutEngine` enum (`ExactGlobal` | + `LocalDeterministic { max_radius, budget_k }`), `engine` field on + `MincutGatedForgetting` (defaults to `ExactGlobal`, so ADR-345's existing + `soft()`/`hard()` and their unit tests are byte-for-byte unchanged), new + `soft_local`/`hard_local` constructors, `boundary_indices_local` + (builds a `ruvector_mincut::DynamicGraph` from the same k-NN edges and + queries `DeterministicLocalKCut` once per vertex), and 4 new unit tests. +- `src/lib.rs`: export `MincutEngine`. +- `examples/mincut_local_forgetting_bench.rs`: the acceptance benchmark — + 5 policies (baseline, Soft/Hard x Exact/Local) on the 84-memory + hypothesis-size corpus, a determinism section (20 repeated `compact()` + calls per engine), a 6-point scaling probe (84-924 vertices), tamper + trials, and an explicit ACCEPT/REJECT verdict. +- `Cargo.toml`: registers the new example under the existing `mincut-forget` + feature. + +## Design Probes (before the hypothesis lock, not part of the acceptance evidence) + +Two design decisions were made *before* writing and locking the hypothesis +above, based on the crate's own unit-test fixture (a 19-vertex +two-clique-plus-bridge graph, not the acceptance benchmark's corpus) rather +than on the acceptance run itself — consistent with "do not change the +hypothesis after seeing results," since these probes ran against the +*design* of the method, before any acceptance number existed: + +1. **Seeding.** `DeterministicFamilyGenerator::generate_seeds(graph, v)` + (documented as producing "a deterministic set of seed vertices for + exploration") pre-loads a vertex's lowest-id neighbors into the *initial* + BFS frontier. For a low-degree bridge vertex whose only neighbors are two + high-degree "gateway" vertices, this means the very first boundary check + is against a ~19-vertex-wide set, not the bridge's own 2-edge cut — the + search never gets to see the small cut at all. Fixed by seeding with + `[v]` alone (still a fully valid, documented use of the same public API) + and letting `deterministic_bfs` grow the region itself, exactly as its + own doc comments describe. +2. **Radius.** Even with single-vertex seeding, `max_radius >= 1` still + over-flags on this corpus's topology: the crate's own k-NN clusters are + near-cliques by construction, so a single BFS hop from *any* + same-cluster vertex already reaches nearly the whole cluster, and that + whole-cluster region also has a tiny boundary (the one edge leaving the + cluster). At radius >= 1, every vertex in every cluster gets flagged — + not just bridges — which would erase the differential signal + `MincutGatedForgetting` needs. `max_radius = 0` (check only a vertex's + own direct degree against `budget_k`, still via the real + `DeterministicLocalKCut`/`WitnessHandle` code path) avoids this and is + what `soft_local`/`hard_local` use by default; `max_radius` remains a + public field for callers whose data may not be this tightly clustered. + +Both are disclosed in [ADR-346](../../../adr/ADR-346-local-kcut-gated-forgetting.md#design-notes-found-during-implementation-not-part-of-the-acceptance-run) +and in doc comments on `boundary_indices_local` itself, not hidden as if the +first attempt had never happened. + +A third thing was found and *not* used: `ruvector_mincut::algorithm:: +approximate::ApproxMinCut` (considered before `localkcut`) has a +`compute_partition()` that ignores its own `cut_value` argument (prefixed +`_cut_value`, never read) and returns an arbitrary BFS-order bisection +unrelated to the min-cut it just computed. Its `min_cut_value()` is real; +its `partition` field is not — insufficient for this use case, which needs +*which vertices*, not just the cut's weight. Filed as a disclosed +`ruvector-mincut` hardening item, not fixed in this pass. + +## Benchmark Methodology + +- Release build (`cargo run --release`), no debug assertions. +- Deterministic seed (`StdRng::seed_from_u64(346)`); store, access pattern, + and query set rebuilt identically for every policy and every scaling + point. +- `compact()` wall-clock is measured around the call only (dataset + generation and access simulation happen before timing starts) — this + *includes* k-NN graph construction for both mincut engines, since that + cost is part of what a real caller pays. +- Bridge survival tracked by stable memory id (not store index), captured + before compaction, exactly as ADR-345 did. +- Recall@10 uses `MemoryStore::search` brute force, matching the existing + convention. +- Determinism is measured at the `compact()`/survivor-set level (20 + full rebuild-and-compact trials per engine, comparing the resulting + survivor *id set* against the first trial), a coarser, more + end-to-end-relevant metric than ADR-345's raw `partition()`-call probe — + see [Limitations](#limitations) for why the two shouldn't be read as + directly comparable numbers. +- The scaling probe stops issuing new `Exact` calls once one exceeds a + pre-declared 1.5s budget (written into the benchmark source before it was + run), to avoid repeating ADR-345's own multi-second-per-call blowup at + every one of 6 sizes. +- Hardware/software: reported by the benchmark binary itself + (`std::env::consts::OS`/`ARCH`), Linux x86_64. + +Exact command: + +```bash +cargo run --release -p ruvector-agent-memory \ + --example mincut_local_forgetting_bench --features mincut-forget +``` + +## Benchmark Results (raw) + +Full verbatim output: [`raw-runs.txt`](./raw-runs.txt). Reproduced here: + +```text +Section A — hypothesis-size corpus (84 memories, same shape as ADR-345) + Clusters=6 per_cluster=12 bridges=12 dims=32 target=50% + +Policy Bridge Surv. Recall@10 Compaction (us) +---------------------------------------------------------------------------- +CoherenceWeighted 16.7% 100.0% 67 +MincutGatedForgetting-Soft-Exact 16.7% 100.0% 486607 +MincutGatedForgetting-Hard-Exact 16.7% 100.0% 492328 +MincutGatedForgetting-Soft-Local 16.7% 100.0% 997 +MincutGatedForgetting-Hard-Local 16.7% 100.0% 968 + +Section B — determinism (20 repeated compact() calls on unchanged input) + Soft-Exact identical survivor sets : 20/20 + Soft-Local identical survivor sets : 20/20 + +Section C — scaling probe (Soft-Exact vs Soft-Local compact() wall-clock) + n Baseline (us) Exact (us) Local (us) + 84 66 264264 1005 + 168 136 2200278 3532 + 252 199 skipped(budget) 6857 + 420 376 skipped(budget) 18518 + 588 486 skipped(budget) 35666 + 924 782 skipped(budget) 87143 + +Tamper-detection trials (eviction witness chain, Soft-Local engine) + Detected 20/20 single-byte-flip tampers + +Acceptance test + (a) Soft-Local bridge-survival gap (+0.0pp) >= 15pp : FAIL + (a) Hard-Local bridge-survival gap (+0.0pp) >= 15pp : FAIL + (a) Soft-Local |recall delta| (0.00pp) <= 2pp : PASS + (a) Hard-Local |recall delta| (0.00pp) <= 2pp : PASS + (b) @n=168: Local vs Exact speedup (623.0x) >= 5x : PASS + (b) @n=168: Local vs baseline slowdown (26.0x) <= 20x : FAIL + (c) Soft-Local determinism (20/20 identical) : PASS + (reference — Soft-Exact determinism: 20/20 identical, not gated on) + Tamper detection (20/20) : PASS + +=> REJECT: one or more mandatory acceptance thresholds failed (see above). +``` + +## Acceptance Result + +The benchmark binary's own verdict is **REJECT** (any one gate failing +triggers this, by design — see the pre-declared thresholds in the +hypothesis). Read at that single-verdict granularity, this is the correct +and honest report. But collapsing two questions with different, individually +clear answers into one REJECT would itself be a form of information loss, +so this section separates them explicitly: + +| Question | Verdict | Evidence | +|---|---|---| +| Does `LocalDeterministic` fix ADR-345's *latency* defect relative to `ExactGlobal`? | **Yes, decisively.** | 623x faster at n=168 (the one size both completed); `Local` scales to 924 vertices in 87ms where `Exact` already exceeds a 1.5s budget at 168. | +| Does `LocalDeterministic` fix ADR-345's *non-determinism* defect? | **Consistent with yes, at the level tested.** | 20/20 identical survivor sets across repeated `compact()` calls. See [Limitations](#limitations) for why this isn't a direct re-run of ADR-345's stronger, per-call `partition()`-level determinism probe. | +| Does the structural signal improve bridge survival over baseline (either engine)? | **No — reproduces ADR-345's null result.** | 0.0pp gap, same pattern as ADR-345's own 0.0pp finding at a different seed/corpus size. Not a new finding; inherited for comparability. | +| Does the *overall* `compact()` call stay within a tight (20x) multiple of baseline at scale? | **No, for a reason unrelated to the cut engine.** | Both engines' shared O(n^2) k-NN construction cost grows to ~111x baseline by n=924; `LocalDeterministic`'s own per-vertex query cost is not the bottleneck at these sizes. | + +## Memory Math + +Unchanged from ADR-345 (k-NN graph edge count and eviction-witness sizing +depend on corpus size and `k_neighbors`/`protect_fraction`, not on which cut +engine is selected): <=5-8 edges/vertex, 64 bytes/evicted entry via +`LedgerWitnessRecord`. + +## Performance Math + +From the scaling table above: `Local`'s wall-clock grows from 1.0ms (n=84) +to 87.1ms (n=924), an ~87x increase for an 11x growth in n — worse than +linear, consistent with the O(n^2) k-NN construction step it shares with +`Exact` dominating over its own near-linear per-vertex query cost. +`Exact`'s wall-clock grows from 264ms (n=84) to 2.2s (n=168), an ~8.3x +increase for a 2x growth in n — far-worse-than-quadratic, consistent with +ADR-345's own scaling table (77ms at n=50 to 11.4s at n=400). + +## Failure Modes + +1. **Inherited null effectiveness result** (not new): the structural bonus + does not change which entries survive compaction on this synthetic + corpus, for either engine. ADR-345 already attributed this to the global + min-cut of noisy Gaussian-cluster data not necessarily isolating the + human-labeled "bridges" specifically; this cycle's identical result with + a *different* cut algorithm (a per-vertex degree check, not a global + partition) is additional evidence that the null result is a property of + the scoring/dataset interaction, not of either specific cut algorithm. +2. **Shared O(n^2) k-NN construction cost** (new finding, engine-agnostic): + dominates wall-clock at every size tested for both engines, and was not + separately measured or disclosed in ADR-345 (whose slowdown numbers were + dominated by `partition()` itself, large enough to hide this cost). + Visible here only because `LocalDeterministic`'s own query cost is small + enough to expose it. +3. **Radius pathology** (found and worked around during design, not an + acceptance-time failure): see [Design Probes](#design-probes-before-the-hypothesis-lock-not-part-of-the-acceptance-evidence). +4. **`ApproxMinCut::compute_partition()` defect** (found in a rejected + alternative, not used): see [Design Probes](#design-probes-before-the-hypothesis-lock-not-part-of-the-acceptance-evidence) + and ADR-346's "Alternatives Considered." + +## Rejected Alternatives + +See [ADR-346 § Alternatives Considered](../../../adr/ADR-346-local-kcut-gated-forgetting.md#alternatives-considered) +for `ApproxMinCut`, multi-vertex seeding, and `max_radius >= 1`. + +## Security Notes + +No new cryptographic primitive introduced. `WitnessHandle` (from +`DeterministicLocalKCut`) is used only to read back which vertices a local +search placed on the found cut's side — it is not treated as, and does not +replace, the independent `EvictionWitnessChain` tamper-evidence mechanism, +which was re-verified end-to-end with the new engine (20/20 single-byte-flip +detection). + +## Limitations + +- **Single seed.** All numbers here use one fixed seed (346); ADR-345 used + a different one (341). Both show the same *qualitative* pattern (0.0pp + survival gap, engine-dependent latency), which is reassuring, but neither + cycle ran multiple seeds to characterize variance — a real gap in both. +- **Determinism metric granularity.** This cycle's 20/20-identical-survivor-set + determinism check is a coarser, downstream measure than ADR-345's direct + `partition()`-call probe (which measured raw non-determinism at 50% + empty-result-per-call, before any scoring/ranking is applied). The + `ExactGlobal` engine also scored 20/20 here, which does *not* contradict + ADR-345's finding — `mincut_trials` defaults to 3 (unioning independent + calls smooths over per-call variance) and this corpus's near-zero + structural effect means boundary-set noise barely changes final rankings + anyway. A like-for-like re-run of ADR-345's own stricter probe against + `LocalDeterministic` was not performed this cycle. +- **Synthetic data only.** Both this cycle and ADR-345 use Gaussian-cluster + synthetic corpora; neither has tested on real agent-memory embeddings. +- **One corpus shape.** The 6-cluster, hot-2-cluster shape is scaled by a + constant multiplier, not varied in cluster count, density, or bridge + fraction independently. + +## Next Research + +1. Reduce the shared O(n^2) k-NN construction cost (e.g. via + `ruvector-coherence-hnsw`, already in this workspace) — the single + highest-leverage next step, since it is now the dominant, disclosed + bottleneck for *any* k-NN-graph-based structural signal in this crate, + independent of cut engine. +2. Test whether a non-zero bridge-survival gap is achievable at all with a + different scoring interaction or on real (non-Gaussian-synthetic) + embeddings — the effectiveness question ADR-345 opened remains + unanswered by either cycle. +3. Re-run ADR-345's stricter per-call determinism probe (not the + `compact()`-level proxy used here) directly against + `DeterministicLocalKCut` for a like-for-like comparison. +4. Consider filing and fixing `ApproxMinCut::compute_partition()`'s defect + upstream in `ruvector-mincut`. diff --git a/docs/research/nightly/2026-09-12-local-kcut-gated-forgetting/gist.md b/docs/research/nightly/2026-09-12-local-kcut-gated-forgetting/gist.md new file mode 100644 index 0000000000..dc11ac4d00 --- /dev/null +++ b/docs/research/nightly/2026-09-12-local-kcut-gated-forgetting/gist.md @@ -0,0 +1,124 @@ +# Fixing Half a Rejected Idea: A Faster, Deterministic Local Cut Engine + +## Problem + +A previous experiment in this repository (`ruvector-agent-memory`'s +`MincutGatedForgetting`, ADR-345) tried to give agent-memory compaction a +structural "don't evict the bridge" signal by running a general-purpose +global minimum-cut algorithm (`RuVectorGraphAnalyzer::partition()`) over a +k-nearest-neighbor similarity graph of the candidate memories. It was +rejected: that specific call cost 76ms to 11.4 seconds depending on graph +size (50-400 vertices), and repeated calls on byte-identical input didn't +even return the same answer — 15 out of 30 trials on a small, hand-built +test graph came back empty. + +That leaves an obvious, narrower follow-up question, separate from whether +the whole idea is worth pursuing: is the slow, flaky part fixable by +swapping in a different algorithm from the same library, without touching +anything else? This is the writeup of that narrower experiment. + +## Hypothesis + +Same synthetic dataset as the original experiment (clusters of memories +plus a handful of "bridge" memories that interpolate between two clusters), +scaled up to nearly 1,000 memories this time. Swap the boundary-detection +step for `ruvector_mincut::localkcut::DeterministicLocalKCut` — an +implementation of a fully-deterministic local minimum-cut search from a +December 2024 paper, which looks at one vertex's immediate neighborhood +instead of partitioning the whole graph — and measure whether it fixes the +speed and determinism problems while keeping whatever structural benefit +the original approach had. + +## Technical Design + +The new engine builds the identical k-NN similarity graph the original one +did, but as the mincut crate's own graph type, and instead of one expensive +call that partitions everything, it makes one cheap call per vertex asking +"is this specific vertex separated from the rest of the graph by only a +handful of edges?" A vertex gets flagged as structurally important if the +answer is yes. + +Two design mistakes surfaced and got fixed before the real benchmark ran +(disclosed here rather than smoothed over): + +1. The library's own helper for picking which vertices to start the search + from turned out to work against the goal — it immediately mixes in a + vertex's neighbors before checking anything, so a low-degree "bridge" + vertex's small, distinctive cut never gets a chance to be seen on its + own. Starting from just the one vertex being tested, and letting the + search grow outward itself, fixed this. +2. Even after that fix, letting the search expand more than zero hops + caused it to swallow entire clusters at once (because this synthetic + data's clusters are almost fully connected internally), which flags + *everything* as a boundary and defeats the whole point. Capping the + search at zero hops — effectively "does this vertex have very few + neighbors" — avoided that, at the cost of not really using the + algorithm's multi-hop capability on this particular dataset. + +A third dead end, found but not used: a different algorithm in the same +library (`ApproxMinCut`) looked promising — it's seeded and deterministic — +but its function for returning *which vertices* are on which side of the +cut turned out to be disconnected from the cut it actually computes; it +just returns half the vertices in traversal order regardless of the real +answer. Its "how big is the cut" number is fine; its "which vertices" +answer is not, and this experiment needs the latter. + +## Real Results + +Comparing the two engines on the same corpus, scaled from 84 up to 924 +memories, release build, one fixed seed: + +| n | baseline | old (global) engine | new (local) engine | +|---:|---:|---:|---:| +| 84 | 66 microseconds | 264 milliseconds | 1.0 milliseconds | +| 168 | 136 microseconds | 2.2 seconds | 3.5 milliseconds | +| 924 | 782 microseconds | not measured (already too slow at 168) | 87 milliseconds | + +At the one size both engines finished within a shared time budget, the new +engine was 623x faster. It also produced the identical set of flagged +vertices across 20 repeated runs on unchanged input, every time — the old +engine's known flakiness didn't reappear in this (coarser, downstream) +check, for reasons discussed in the limitations below. + +That's the good news. The bad news, measured just as honestly: the original +experiment's core effectiveness question — does flagging structurally +important vertices actually change which memories survive compaction? — is +still answered "no" here, exactly as it was in the original experiment. +Protected vertices ended up identical to what the plain scalar baseline +would have kept anyway, with both engines. And a new problem showed up that +neither engine caused: building the similarity graph in the first place +costs roughly the square of the memory count, and at these sizes that cost +alone made the *overall* compaction call 26x to over 100x slower than the +baseline — a real cost this experiment hadn't previously isolated because +the old engine's own slowness was so much larger it hid it. + +So: the narrow question (is the algorithm swap faster and more reliable) +gets a clear yes. The broader question (is this whole approach ready to use) +still gets a no, for two separate reasons — one old (no effectiveness +benefit) and one newly measured (graph-construction cost dominates at +scale) — neither of which the algorithm swap could have fixed by itself. + +## Limitations + +- One random seed, same as the previous experiment. Neither run + characterizes variance across seeds. +- The "deterministic" claim here was checked by re-running full compaction + and comparing the final kept-memories list, not by directly re-running + the previous experiment's stricter check (repeatedly calling just the + cut-finding step in isolation and comparing raw results). The two aren't + directly comparable, and the stricter check wasn't repeated against the + new engine. +- Entirely synthetic Gaussian-cluster data; nothing here has been tried + against real memory embeddings. +- The zero-hop restriction that made this dataset behave means the "local" + algorithm's actual multi-hop search behavior went essentially untested on + this corpus shape. + +## What's Next + +The most promising next step isn't another cut algorithm — it's the newly +found graph-construction cost, which now dominates the whole approach +regardless of which cut algorithm sits on top of it. This workspace already +has an approximate-nearest-neighbor index that could plausibly replace the +brute-force all-pairs similarity computation; that's a more promising +target than further cut-algorithm tuning. diff --git a/docs/research/nightly/2026-09-12-local-kcut-gated-forgetting/raw-runs.txt b/docs/research/nightly/2026-09-12-local-kcut-gated-forgetting/raw-runs.txt new file mode 100644 index 0000000000..cd18a10309 --- /dev/null +++ b/docs/research/nightly/2026-09-12-local-kcut-gated-forgetting/raw-runs.txt @@ -0,0 +1,190 @@ +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvector-acorn-wasm/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvector-rabitq-wasm/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvector-node/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvector-wasm/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/cognitum-gate-kernel/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvector-router-cli/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvector-router-ffi/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvector-router-wasm/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvector-tiny-dancer-wasm/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvector-graph-node/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvector-graph-wasm/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvector-gnn-node/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvector-gnn-wasm/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvector-attention-wasm/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvector-attention-node/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvector-cnn-wasm/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvector-mincut-gated-transformer-wasm/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvector-hailo-cluster/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/examples/google-cloud/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/rvlite/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvector-dag-wasm/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvector-nervous-system-wasm/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvector-economy-wasm/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvector-learning-wasm/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvector-exotic-wasm/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvector-attention-unified-wasm/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvector-fpga-transformer-wasm/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvector-delta-wasm/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvector-domain-expansion-wasm/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvector-solver-wasm/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvector-solver-node/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvector-verified-wasm/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvector-graph-transformer-wasm/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvector-graph-transformer-node/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvix/crates/types/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvix/crates/region/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvix/crates/cap/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvix/crates/proof/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvix/crates/nucleus/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvix/crates/shell/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvix/tests/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvix/benches/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvix/examples/cognitive_demo/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvector-consciousness-wasm/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvector-decompiler-wasm/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: profiles for the non root package will be ignored, specify profiles at the workspace root: +package: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvector-entropy-ann/Cargo.toml +workspace: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/Cargo.toml +warning: /home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvector-attention/Cargo.toml: file `/home/user/ruvector/.claude/worktrees/agent-a15e87fe1149382a0/crates/ruvector-attention/benches/attention_benchmarks.rs` found to be present in multiple build targets: + * `bin` target `bench_runner` + * `bench` target `attention_benchmarks` + Finished `release` profile [optimized] target(s) in 0.66s + Running `target/release/examples/mincut_local_forgetting_bench` +╔══════════════════════════════════════════════════════════════════╗ +║ ruvector-agent-memory — LocalDeterministic Mincut Forgetting ║ +║ (ADR-346, follow-up to ADR-345) ║ +╚══════════════════════════════════════════════════════════════════╝ + +Platform : linux +Arch : x86_64 + +Section A — hypothesis-size corpus (84 memories, same shape as ADR-345) + Clusters=6 per_cluster=12 bridges=12 dims=32 target=50% + +Policy Bridge Surv. Recall@10 Compaction (us) +---------------------------------------------------------------------------- +CoherenceWeighted 16.7% 100.0% 67 +MincutGatedForgetting-Soft-Exact 16.7% 100.0% 486607 +MincutGatedForgetting-Hard-Exact 16.7% 100.0% 492328 +MincutGatedForgetting-Soft-Local 16.7% 100.0% 997 +MincutGatedForgetting-Hard-Local 16.7% 100.0% 968 + +Section B — determinism (20 repeated compact() calls on unchanged input) + Soft-Exact identical survivor sets : 20/20 + Soft-Local identical survivor sets : 20/20 + +Section C — scaling probe (Soft-Exact vs Soft-Local compact() wall-clock) + n Baseline (us) Exact (us) Local (us) + 84 66 264264 1005 + 168 136 2200278 3532 + 252 199 skipped(budget) 6857 + 420 376 skipped(budget) 18518 + 588 486 skipped(budget) 35666 + 924 782 skipped(budget) 87143 + +Tamper-detection trials (eviction witness chain, Soft-Local engine) + Detected 20/20 single-byte-flip tampers + +Acceptance test + (a) Soft-Local bridge-survival gap (+0.0pp) >= 15pp : FAIL + (a) Hard-Local bridge-survival gap (+0.0pp) >= 15pp : FAIL + (a) Soft-Local |recall delta| (0.00pp) <= 2pp : PASS + (a) Hard-Local |recall delta| (0.00pp) <= 2pp : PASS + (b) @n=168: Local vs Exact speedup (623.0x) >= 5x : PASS + (b) @n=168: Local vs baseline slowdown (26.0x) <= 20x : FAIL + (c) Soft-Local determinism (20/20 identical) : PASS + (reference — Soft-Exact determinism: 20/20 identical, not gated on) + Tamper detection (20/20) : PASS + +=> REJECT: one or more mandatory acceptance thresholds failed (see above).