diff --git a/crates/ruvector-agent-memory/Cargo.toml b/crates/ruvector-agent-memory/Cargo.toml index cfb8136029..1c7d341553 100644 --- a/crates/ruvector-agent-memory/Cargo.toml +++ b/crates/ruvector-agent-memory/Cargo.toml @@ -35,6 +35,12 @@ ruvector-mincut = { path = "../ruvector-mincut", optional = true } default = [] proof-gate = ["dep:ruvector-proof-gate"] mincut-forget = ["dep:ruvector-mincut"] +# ADR-346 (PIR nightly 2026-09-10): same boundary-signal idea as +# `mincut-forget`, but reuses ruvector-mincut's `canonical` feature +# (deterministic cactus/Stoer-Wagner cut) instead of the general dynamic +# `RuVectorGraphAnalyzer` wrapper, to attack ADR-345's rejection root cause +# (non-determinism + latency). +mincut-forget-cactus = ["mincut-forget", "ruvector-mincut/canonical"] [[example]] name = "mincut_gated_forgetting_bench" @@ -51,5 +57,25 @@ name = "mincut_scaling_probe" path = "examples/mincut_scaling_probe.rs" required-features = ["mincut-forget"] +[[example]] +name = "cactus_gated_forgetting_bench" +path = "examples/cactus_gated_forgetting_bench.rs" +required-features = ["mincut-forget-cactus"] + +[[example]] +name = "cactus_determinism_probe" +path = "examples/cactus_determinism_probe.rs" +required-features = ["mincut-forget-cactus"] + +[[example]] +name = "cactus_scaling_probe" +path = "examples/cactus_scaling_probe.rs" +required-features = ["mincut-forget-cactus"] + +[[example]] +name = "cactus_seed_sensitivity_probe" +path = "examples/cactus_seed_sensitivity_probe.rs" +required-features = ["mincut-forget-cactus"] + [dev-dependencies] serde_json = { workspace = true } diff --git a/crates/ruvector-agent-memory/examples/cactus_determinism_probe.rs b/crates/ruvector-agent-memory/examples/cactus_determinism_probe.rs new file mode 100644 index 0000000000..592ab30dc8 --- /dev/null +++ b/crates/ruvector-agent-memory/examples/cactus_determinism_probe.rs @@ -0,0 +1,119 @@ +//! Determinism probe for `ruvector_mincut::CactusGraph::canonical_cut`, +//! directly comparable to ADR-345's `mincut_determinism_probe` (which found +//! `RuVectorGraphAnalyzer::partition()` returned an empty/degenerate result +//! on 50% of repeated calls on byte-identical input). Same 19-vertex +//! two-clique-plus-bridge topology. +//! +//! Run: +//! cargo run --release -p ruvector-agent-memory --example cactus_determinism_probe --features mincut-forget-cactus + +use ruvector_mincut::{CactusGraph, DynamicGraph}; +use std::collections::HashSet; +use std::sync::Arc; +use std::time::Instant; + +fn normalize3(v: [f32; 3]) -> Vec { + let n = (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]).sqrt(); + vec![v[0] / n, v[1] / n, v[2] / n] +} +fn cosine_sim(a: &[f32], b: &[f32]) -> f32 { + let dot: f32 = a.iter().zip(b).map(|(x, y)| x * y).sum(); + let na: f32 = a.iter().map(|x| x * x).sum::().sqrt(); + let nb: f32 = b.iter().map(|x| x * x).sum::().sqrt(); + if na < 1e-9 || nb < 1e-9 { + 0.0 + } else { + (dot / (na * nb)).clamp(-1.0, 1.0) + } +} + +fn main() { + let mut entries: Vec> = Vec::new(); + for axis in 0..2 { + let plain = if axis == 0 { + [1.0, 0.0, 0.0] + } else { + [0.0, 1.0, 0.0] + }; + let gateway = if axis == 0 { + normalize3([1.0, 0.0, 0.5]) + } else { + normalize3([0.0, 1.0, 0.5]) + }; + for _ in 0..8 { + entries.push(plain.to_vec()); + } + entries.push(gateway); + } + entries.push(vec![0.0, 0.0, 1.0]); + let n = entries.len(); + let bridge_idx = n - 1; + + let k = 8usize; + let min_sim = 0.05f32; + + let trials: usize = std::env::var("TRIALS") + .ok() + .and_then(|s| s.parse().ok()) + .unwrap_or(50); + + let mut empty = 0usize; + let mut bridge_detected_boundary = 0usize; + let mut distinct_partitions: HashSet> = HashSet::new(); + let t0 = Instant::now(); + for _ in 0..trials { + let graph = Arc::new(DynamicGraph::new()); + for i in 0..n { + let mut sims: Vec<(usize, f32)> = (0..n) + .filter(|&j| j != i) + .map(|j| (j, cosine_sim(&entries[i], &entries[j]))) + .filter(|&(_, s)| s >= min_sim) + .collect(); + sims.sort_unstable_by(|a, b| b.1.partial_cmp(&a.1).unwrap()); + sims.truncate(k); + for (j, s) in sims { + // See graph_forget_cactus.rs: unconditional on i < j, since + // k-NN truncation is asymmetric and `insert_edge` no-ops on + // an already-present undirected pair. + let weight = (1.0 / (1.0 - s).max(1e-4)) as f64; + let _ = graph.insert_edge(i as u64, j as u64, weight); + } + } + + let cactus = CactusGraph::build_from_graph(&graph); + let cut = cactus.canonical_cut(); + let (side_a, side_b) = &cut.partition; + if side_a.is_empty() || side_b.is_empty() { + empty += 1; + continue; + } + let mut key = side_a.clone(); + key.sort_unstable(); + distinct_partitions.insert(key.clone()); + + let side_a_set: HashSet = side_a.iter().copied().collect(); + let mut boundary = false; + for edge in graph.edges() { + let u = edge.source as usize; + let v = edge.target as usize; + let u_in_a = side_a_set.contains(&u); + let v_in_a = side_a_set.contains(&v); + if u_in_a != v_in_a && (u == bridge_idx || v == bridge_idx) { + boundary = true; + } + } + if boundary { + bridge_detected_boundary += 1; + } + } + let elapsed = t0.elapsed(); + println!( + "trials={trials} elapsed={:.4}s avg_per_call={:.3}ms empty_or_degenerate={empty} ({:.0}%) \ + bridge_detected_as_boundary={bridge_detected_boundary} ({:.0}%) distinct_partitions={}", + elapsed.as_secs_f64(), + elapsed.as_secs_f64() * 1000.0 / trials as f64, + 100.0 * empty as f64 / trials as f64, + 100.0 * bridge_detected_boundary as f64 / trials as f64, + distinct_partitions.len(), + ); +} diff --git a/crates/ruvector-agent-memory/examples/cactus_gated_forgetting_bench.rs b/crates/ruvector-agent-memory/examples/cactus_gated_forgetting_bench.rs new file mode 100644 index 0000000000..253d5a40a9 --- /dev/null +++ b/crates/ruvector-agent-memory/examples/cactus_gated_forgetting_bench.rs @@ -0,0 +1,422 @@ +//! Nightly research benchmark (2026-09-10, ADR-346): canonical-cactus-cut +//! forgetting, attacking ADR-345's rejection root cause. +//! +//! Hypothesis (fixed before this exact run of the benchmark): +//! +//! Given the identical synthetic corpus ADR-345 used (6 topic clusters, 12 +//! memories each = 72, plus 12 "bridge" memories interpolated 50/50 between +//! two randomly paired clusters, 32-dim, hot-cluster access simulation with 2 +//! of 6 clusters getting proportionally more accesses, k-NN k=8 cosine >= +//! 0.05 similarity graph), +//! +//! when the 84-entry store is compacted to 50% (42 entries) using +//! CactusGatedForgetting-Soft (candidate A, structural bonus δ=0.5) and +//! CactusGatedForgetting-Hard (candidate B, 20% protected budget) — backed by +//! `ruvector-mincut`'s `canonical` feature (`CactusGraph::canonical_cut`, +//! dense Stoer-Wagner + lexicographic tie-break) instead of ADR-345's +//! `RuVectorGraphAnalyzer::partition()` — versus the existing CoherencePolicy +//! baseline and versus ADR-345's own MincutGatedForgetting-Soft/Hard, +//! +//! then (a) the cactus backend is deterministic: 100% identical +//! `boundary_indices` results across repeated calls on byte-identical input +//! (measured separately in `cactus_determinism_probe`, ADR-345's comparable +//! number was 50% degenerate/empty), (b) each cactus candidate's compaction +//! wall-clock stays within 20x the scalar baseline's (ADR-345's bound was +//! 100x, and ADR-345 still failed a >1000x measurement — this experiment +//! commits to a materially tighter bar before running), and (c) both cactus +//! candidates retain a bridge-memory survival rate at least 15 percentage +//! points higher than baseline while Recall@10 over 20 hot-cluster test +//! queries stays within 2 percentage points of baseline, +//! +//! subject to: 100% tamper-detection across 20 independent single-byte-flip +//! trials against the (unchanged, reused) eviction witness chain. +//! +//! This file measures (b) and (c) plus the tamper-detection subject clause, +//! and includes ADR-345's own policies in the same run for a direct, +//! same-process, same-corpus comparison. (a) is measured in the sibling +//! `cactus_determinism_probe` example; absolute scaling behavior up to 400 +//! vertices (informational, not a gate — mirroring how ADR-345 treated its +//! own scaling probe) is measured in `cactus_scaling_probe`. +//! +//! Run: +//! cargo run --release -p ruvector-agent-memory --example cactus_gated_forgetting_bench --features mincut-forget-cactus + +use rand::rngs::StdRng; +use rand::{Rng, SeedableRng}; +use ruvector_agent_memory::{ + compact, compact_witnessed, recall_at_k, CactusGatedForgetting, CoherencePolicy, + CoherenceWeights, CompactionPolicy, EvictionWitnessChain, MemoryStore, MemoryWitnessLog, + MincutGatedForgetting, +}; +use std::collections::HashSet; +use std::time::{Duration, Instant}; + +// ── Dataset parameters (identical to ADR-345's mincut_gated_forgetting_bench) ── +const N_CLUSTERS: usize = 6; +const PER_CLUSTER: usize = 12; +const N_CORE: usize = N_CLUSTERS * PER_CLUSTER; // 72 +const N_BRIDGES: usize = 12; +const N_MEMORIES: usize = N_CORE + N_BRIDGES; // 84 +const N_HOT_CLUSTERS: usize = 2; +const DIMS: usize = 32; +const N_QUERIES: usize = 20; +const K: usize = 5; +const TARGET_SIZE: usize = N_MEMORIES / 2; // 42, 50% compaction +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; +// Tighter than ADR-345's 100x: the whole point of this experiment is that +// the canonical-cactus backend should be *usably* fast, not merely bounded. +const MAX_SLOWDOWN_VS_BASELINE: f64 = 20.0; +const N_TAMPER_TRIALS: usize = 20; +const MINCUT_TRIALS: usize = 1; // ADR-345 backend, unmitigated (see its own README) + +// ── Vector utilities (mirrors src/main.rs / ADR-345 bench) ────────────────── + +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)) +} + +// ── Dataset ────────────────────────────────────────────────────────────────── + +struct Dataset { + centroids: Vec>, + cluster_of: Vec, + bridge_indices: HashSet, + queries: Vec<(Vec, Vec)>, +} + +fn generate_dataset(store: &mut MemoryStore, rng: &mut StdRng) -> Dataset { + let centroids: Vec> = (0..N_CLUSTERS).map(|_| unit_gaussian(rng, DIMS)).collect(); + let mut cluster_of = Vec::with_capacity(N_MEMORIES); + + for (c, centroid) in centroids.iter().enumerate() { + for _ in 0..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..N_BRIDGES { + let a = rng.gen_range(0..N_CLUSTERS); + let mut b = rng.gen_range(0..N_CLUSTERS); + while b == a { + b = rng.gen_range(0..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; + 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, + dataset: &Dataset, + rng: &mut StdRng, +) -> Vec> { + for _ in 0..N_COLD_ERA_ACCESSES { + let idx = rng.gen_range(0..N_MEMORIES); + store.access_by_index(idx); + } + + 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..N_HOT_CLUSTERS); + hot_c * PER_CLUSTER + rng.gen_range(0..PER_CLUSTER) + } else { + let cold_c = rng.gen_range(N_HOT_CLUSTERS..N_CLUSTERS); + cold_c * PER_CLUSTER + rng.gen_range(0..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 +} + +fn run_policy(policy: &dyn CompactionPolicy, 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, &mut rng); + let mut rng2 = StdRng::seed_from_u64(seed + 1); + let context_window = simulate_accesses(&mut store, &dataset, &mut rng2); + assert_eq!(store.len(), N_MEMORIES); + + let bridge_ids: HashSet = dataset + .bridge_indices + .iter() + .map(|&i| store.entries()[i].id) + .collect(); + + 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() as f32; + + let recall = measure_recall(&dataset.queries, &store); + (survival_rate, recall, elapsed) +} + +fn run_tamper_trials(seed: u64) -> (usize, usize) { + 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, &mut rng); + let mut rng2 = StdRng::seed_from_u64(seed + trial as u64 + 1); + let context_window = simulate_accesses(&mut store, &dataset, &mut rng2); + + let policy = CactusGatedForgetting::soft(CoherenceWeights::default(), STRUCTURAL_BONUS); + let mut chain = EvictionWitnessChain::new(); + let mut log = MemoryWitnessLog::default(); + compact_witnessed( + &mut store, + &policy, + TARGET_SIZE, + &context_window, + "nightly-bench", + 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 — Canonical-Cactus-Cut Forgetting (ADR-346) ║"); + println!("╚══════════════════════════════════════════════════════════════════╝\n"); + + println!("Platform : {}", std::env::consts::OS); + println!("Arch : {}", std::env::consts::ARCH); + println!(); + + println!("Dataset (identical to ADR-345)"); + println!(" Clusters : {N_CLUSTERS} ({PER_CLUSTER} core memories each = {N_CORE})"); + println!(" Bridge memories : {N_BRIDGES}"); + println!(" Total memories : {N_MEMORIES}"); + println!(" Target size : {TARGET_SIZE} (50% compaction)"); + println!(); + + let cow = CoherencePolicy::default(); + let mut old_soft = MincutGatedForgetting::soft(CoherenceWeights::default(), STRUCTURAL_BONUS); + old_soft.mincut_trials = MINCUT_TRIALS; + let mut old_hard = MincutGatedForgetting::hard(CoherenceWeights::default(), PROTECT_FRACTION); + old_hard.mincut_trials = MINCUT_TRIALS; + let new_soft = CactusGatedForgetting::soft(CoherenceWeights::default(), STRUCTURAL_BONUS); + let new_hard = CactusGatedForgetting::hard(CoherenceWeights::default(), PROTECT_FRACTION); + + struct Row { + name: String, + survival: f32, + recall: f32, + micros: u128, + } + let mut rows = Vec::new(); + let policies: [&dyn CompactionPolicy; 5] = [&cow, &old_soft, &old_hard, &new_soft, &new_hard]; + for policy in policies { + let (survival, recall, dur) = run_policy(policy, seed); + rows.push(Row { + name: policy.name().to_string(), + survival, + recall, + micros: dur.as_micros(), + }); + } + + println!( + "{:<30} {:>16} {:>12} {:>16}", + "Policy", "Bridge Surv.", "Recall@10", "Compaction (us)" + ); + println!("{}", "-".repeat(78)); + for r in &rows { + println!( + "{:<30} {:>15.1}% {:>11.1}% {:>16}", + r.name, + r.survival * 100.0, + r.recall * 100.0, + r.micros + ); + } + println!(); + + let baseline = &rows[0]; + let cactus_soft = &rows[3]; + let cactus_hard = &rows[4]; + + println!("Tamper-detection trials (eviction witness chain, cactus backend)"); + let (detected, total) = run_tamper_trials(seed + 1_000); + println!(" Detected {detected}/{total} single-byte-flip tampers\n"); + + println!("Acceptance test (ADR-346 hypothesis, cactus candidates only)"); + let survival_gap_soft = (cactus_soft.survival - baseline.survival) * 100.0; + let survival_gap_hard = (cactus_hard.survival - baseline.survival) * 100.0; + let soft_gap_pass = survival_gap_soft >= BRIDGE_SURVIVAL_GAP_THRESHOLD_PP; + let hard_gap_pass = survival_gap_hard >= BRIDGE_SURVIVAL_GAP_THRESHOLD_PP; + println!( + " Soft bridge-survival gap ({survival_gap_soft:+.1}pp) >= {BRIDGE_SURVIVAL_GAP_THRESHOLD_PP:.0}pp : {}", + if soft_gap_pass { "PASS" } else { "FAIL" } + ); + println!( + " Hard bridge-survival gap ({survival_gap_hard:+.1}pp) >= {BRIDGE_SURVIVAL_GAP_THRESHOLD_PP:.0}pp : {}", + if hard_gap_pass { "PASS" } else { "FAIL" } + ); + + let recall_delta_soft = (cactus_soft.recall - baseline.recall).abs(); + let recall_delta_hard = (cactus_hard.recall - baseline.recall).abs(); + let soft_recall_pass = recall_delta_soft <= RECALL_TOLERANCE; + let hard_recall_pass = recall_delta_hard <= RECALL_TOLERANCE; + println!( + " Soft |recall delta| ({:.2}pp) <= {:.0}pp : {}", + recall_delta_soft * 100.0, + RECALL_TOLERANCE * 100.0, + if soft_recall_pass { "PASS" } else { "FAIL" } + ); + println!( + " Hard |recall delta| ({:.2}pp) <= {:.0}pp : {}", + recall_delta_hard * 100.0, + RECALL_TOLERANCE * 100.0, + if hard_recall_pass { "PASS" } else { "FAIL" } + ); + + let slowdown_soft = cactus_soft.micros as f64 / baseline.micros.max(1) as f64; + let slowdown_hard = cactus_hard.micros as f64 / baseline.micros.max(1) as f64; + let soft_speed_pass = slowdown_soft <= MAX_SLOWDOWN_VS_BASELINE; + let hard_speed_pass = slowdown_hard <= MAX_SLOWDOWN_VS_BASELINE; + println!( + " Soft compaction slowdown ({slowdown_soft:.1}x) <= {MAX_SLOWDOWN_VS_BASELINE:.0}x : {}", + if soft_speed_pass { "PASS" } else { "FAIL" } + ); + println!( + " Hard compaction slowdown ({slowdown_hard:.1}x) <= {MAX_SLOWDOWN_VS_BASELINE:.0}x : {}", + if hard_speed_pass { "PASS" } else { "FAIL" } + ); + + let tamper_pass = detected == total; + println!( + " Tamper detection ({detected}/{total}) : {}", + if tamper_pass { "PASS" } else { "FAIL" } + ); + println!(); + + let old_soft_row = &rows[1]; + let old_hard_row = &rows[2]; + println!("Backend comparison (informational; see ADR-345 for the old backend's own numbers)"); + println!( + " MincutGatedForgetting-Soft (ADR-345 backend): {}us vs. CactusGatedForgetting-Soft: {}us ({:.1}x)", + old_soft_row.micros, + cactus_soft.micros, + old_soft_row.micros as f64 / cactus_soft.micros.max(1) as f64 + ); + println!( + " MincutGatedForgetting-Hard (ADR-345 backend): {}us vs. CactusGatedForgetting-Hard: {}us ({:.1}x)", + old_hard_row.micros, + cactus_hard.micros, + old_hard_row.micros as f64 / cactus_hard.micros.max(1) as f64 + ); + println!(); + + let all_pass = soft_gap_pass + && hard_gap_pass + && soft_recall_pass + && hard_recall_pass + && soft_speed_pass + && hard_speed_pass + && tamper_pass; + + if all_pass { + println!("=> ACCEPT: canonical-cactus-cut forgetting protects structural bridges at acceptable recall and speed cost, with the reused witness mechanism intact."); + } else { + println!("=> REJECT: one or more mandatory acceptance thresholds failed (see above)."); + std::process::exit(1); + } +} diff --git a/crates/ruvector-agent-memory/examples/cactus_scaling_probe.rs b/crates/ruvector-agent-memory/examples/cactus_scaling_probe.rs new file mode 100644 index 0000000000..64240cfbe3 --- /dev/null +++ b/crates/ruvector-agent-memory/examples/cactus_scaling_probe.rs @@ -0,0 +1,48 @@ +//! Scaling probe for `ruvector_mincut::CactusGraph::{build_from_graph, +//! canonical_cut}` latency, directly comparable to ADR-345's +//! `mincut_scaling_probe` (same ring k-NN topology, same sizes). Not itself +//! part of the acceptance gate — informational, per ADR-345's own precedent. +//! +//! Run: +//! cargo run --release -p ruvector-agent-memory --example cactus_scaling_probe --features mincut-forget-cactus + +use ruvector_mincut::{CactusGraph, DynamicGraph}; +use std::sync::Arc; +use std::time::Instant; + +fn main() { + let sizes = [19usize, 50, 100, 200, 400, 800]; + let k = 8usize; + for &n in &sizes { + let t0 = Instant::now(); + let graph = Arc::new(DynamicGraph::new()); + for i in 0..n { + for d in 1..=k { + let j = (i + d) % n; + // Unconditional on i < j: matches ADR-345's `from_knn`, + // which inserts every (vertex, neighbor) pair regardless of + // direction; `insert_edge` no-ops on an already-present + // undirected pair. + let weight = 0.1 + (d as f64) * 0.01; + let _ = graph.insert_edge(i as u64, j as u64, weight); + } + } + let build_elapsed = t0.elapsed(); + + let t1 = Instant::now(); + let cactus = CactusGraph::build_from_graph(&graph); + let cactus_build_elapsed = t1.elapsed(); + + let t2 = Instant::now(); + let _ = cactus.canonical_cut(); + let cut_elapsed = t2.elapsed(); + + println!( + "n={n:<5} graph_build={:>10.3}ms cactus_build={:>10.3}ms canonical_cut={:>10.3}ms total={:>10.3}ms", + build_elapsed.as_secs_f64() * 1000.0, + cactus_build_elapsed.as_secs_f64() * 1000.0, + cut_elapsed.as_secs_f64() * 1000.0, + (build_elapsed + cactus_build_elapsed + cut_elapsed).as_secs_f64() * 1000.0, + ); + } +} diff --git a/crates/ruvector-agent-memory/examples/cactus_seed_sensitivity_probe.rs b/crates/ruvector-agent-memory/examples/cactus_seed_sensitivity_probe.rs new file mode 100644 index 0000000000..779a620b56 --- /dev/null +++ b/crates/ruvector-agent-memory/examples/cactus_seed_sensitivity_probe.rs @@ -0,0 +1,189 @@ +//! Informational (non-gating) follow-up probe to `cactus_gated_forgetting_bench`: +//! is the single-seed (346) bridge-survival result representative, or an +//! artifact of that specific random corpus? Runs the same dataset generator +//! and both backends (ADR-345's single-trial `MincutGatedForgetting` and this +//! experiment's `CactusGatedForgetting`) across 10 independent seeds and +//! reports the distribution of the bridge-survival gap vs. baseline. +//! +//! Explicitly informational: this does not redefine or re-run the +//! pre-registered acceptance test in `cactus_gated_forgetting_bench` (which +//! stays fixed at seed 346, decided before any benchmark ran). It exists to +//! characterize *why* that test failed on the survival criterion. +//! +//! Run: +//! cargo run --release -p ruvector-agent-memory --example cactus_seed_sensitivity_probe --features mincut-forget-cactus + +use rand::rngs::StdRng; +use rand::{Rng, SeedableRng}; +use ruvector_agent_memory::{ + compact, CactusGatedForgetting, CoherencePolicy, CoherenceWeights, CompactionPolicy, + MemoryStore, MincutGatedForgetting, +}; +use std::collections::HashSet; + +const N_CLUSTERS: usize = 6; +const PER_CLUSTER: usize = 12; +const N_CORE: usize = N_CLUSTERS * PER_CLUSTER; +const N_BRIDGES: usize = 12; +const N_MEMORIES: usize = N_CORE + N_BRIDGES; +const N_HOT_CLUSTERS: usize = 2; +const DIMS: usize = 32; +const TARGET_SIZE: usize = N_MEMORIES / 2; +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 N_SEEDS: u64 = 10; + +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)) +} + +struct Dataset { + centroids: Vec>, + cluster_of: Vec, + bridge_indices: HashSet, +} + +fn generate_dataset(store: &mut MemoryStore, rng: &mut StdRng) -> Dataset { + let centroids: Vec> = (0..N_CLUSTERS).map(|_| unit_gaussian(rng, DIMS)).collect(); + let mut cluster_of = Vec::with_capacity(N_MEMORIES); + for (c, centroid) in centroids.iter().enumerate() { + for _ in 0..PER_CLUSTER { + store.insert(perturb(centroid, 0.35, rng)); + cluster_of.push(c); + } + } + let mut bridge_indices = HashSet::new(); + for _ in 0..N_BRIDGES { + let a = rng.gen_range(0..N_CLUSTERS); + let mut b = rng.gen_range(0..N_CLUSTERS); + while b == a { + b = rng.gen_range(0..N_CLUSTERS); + } + let mid = midpoint(¢roids[a], ¢roids[b]); + let idx = store.len(); + store.insert(perturb(&mid, 0.15, rng)); + bridge_indices.insert(idx); + cluster_of.push(usize::MAX); + } + Dataset { + centroids, + cluster_of, + bridge_indices, + } +} + +fn simulate_accesses( + store: &mut MemoryStore, + dataset: &Dataset, + rng: &mut StdRng, +) -> Vec> { + for _ in 0..N_COLD_ERA_ACCESSES { + store.access_by_index(rng.gen_range(0..N_MEMORIES)); + } + 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..N_HOT_CLUSTERS); + hot_c * PER_CLUSTER + rng.gen_range(0..PER_CLUSTER) + } else { + let cold_c = rng.gen_range(N_HOT_CLUSTERS..N_CLUSTERS); + cold_c * PER_CLUSTER + rng.gen_range(0..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 survival_rate(policy: &dyn CompactionPolicy, seed: u64) -> f32 { + let mut rng = StdRng::seed_from_u64(seed); + let mut store = MemoryStore::new(DIMS); + let dataset = generate_dataset(&mut store, &mut rng); + let mut rng2 = StdRng::seed_from_u64(seed + 1); + let context_window = simulate_accesses(&mut store, &dataset, &mut rng2); + let bridge_ids: HashSet = dataset + .bridge_indices + .iter() + .map(|&i| store.entries()[i].id) + .collect(); + compact(&mut store, policy, TARGET_SIZE, &context_window); + let surviving = store + .entries() + .iter() + .filter(|e| bridge_ids.contains(&e.id)) + .count(); + surviving as f32 / bridge_ids.len() as f32 +} + +fn mean_std(xs: &[f32]) -> (f32, f32) { + let mean = xs.iter().sum::() / xs.len() as f32; + let var = xs.iter().map(|x| (x - mean).powi(2)).sum::() / xs.len() as f32; + (mean, var.sqrt()) +} + +fn main() { + let cow = CoherencePolicy::default(); + let mut old_soft = MincutGatedForgetting::soft(CoherenceWeights::default(), STRUCTURAL_BONUS); + old_soft.mincut_trials = 1; + let new_soft = CactusGatedForgetting::soft(CoherenceWeights::default(), STRUCTURAL_BONUS); + + let mut baseline_gaps_old = Vec::new(); + let mut baseline_gaps_new = Vec::new(); + println!( + "{:<6} {:>14} {:>18} {:>18}", + "seed", "baseline", "old(mincut) gap pp", "new(cactus) gap pp" + ); + for i in 0..N_SEEDS { + let seed = 1000 + i; + let base = survival_rate(&cow, seed); + let old = survival_rate(&old_soft, seed); + let new = survival_rate(&new_soft, seed); + let gap_old = (old - base) * 100.0; + let gap_new = (new - base) * 100.0; + baseline_gaps_old.push(gap_old); + baseline_gaps_new.push(gap_new); + println!( + "{seed:<6} {:>13.1}% {:>17.1}pp {:>17.1}pp", + base * 100.0, + gap_old, + gap_new + ); + } + let (mean_old, std_old) = mean_std(&baseline_gaps_old); + let (mean_new, std_new) = mean_std(&baseline_gaps_new); + let pass_old = baseline_gaps_old.iter().filter(|&&g| g >= 15.0).count(); + let pass_new = baseline_gaps_new.iter().filter(|&&g| g >= 15.0).count(); + println!(); + println!( + "old(mincut) gap : mean={mean_old:+.1}pp std={std_old:.1}pp seeds_meeting_15pp_bar={pass_old}/{N_SEEDS}" + ); + println!( + "new(cactus) gap : mean={mean_new:+.1}pp std={std_new:.1}pp seeds_meeting_15pp_bar={pass_new}/{N_SEEDS}" + ); +} diff --git a/crates/ruvector-agent-memory/src/graph_forget_cactus.rs b/crates/ruvector-agent-memory/src/graph_forget_cactus.rs new file mode 100644 index 0000000000..2c59e35b44 --- /dev/null +++ b/crates/ruvector-agent-memory/src/graph_forget_cactus.rs @@ -0,0 +1,303 @@ +//! Canonical-cactus-cut forgetting: attacking ADR-345's rejection root cause +//! (ADR-346, docs/research/nightly/2026-09-10-canonical-cactus-forgetting). +//! +//! [`crate::graph_forget::MincutGatedForgetting`] (ADR-345) implemented the +//! same idea this module implements — a k-NN graph min-cut boundary as a +//! structural "don't evict the bridge" signal for compaction — using +//! [`ruvector_mincut::RuVectorGraphAnalyzer`], the crate's general dynamic +//! min-cut wrapper. That experiment was **rejected**: `partition()` returned +//! an empty (unusable) result on 50% of repeated calls on byte-identical +//! input, and cost 1,800-2,700x the scalar baseline even on an 84-vertex +//! corpus (see ADR-345's "Failure modes"). +//! +//! `ruvector-mincut` separately ships a `canonical` feature +//! (`source_anchored`/`tree_packing`/`dynamic` tiers, plus a standalone +//! [`ruvector_mincut::CactusGraph`]) whose entire purpose is a +//! *deterministic* global min-cut: it runs dense-array Stoer-Wagner to +//! enumerate every minimum-cut partition, encodes them in a cactus, and +//! picks the lexicographically smallest one as `canonical_cut()`. It was not +//! used by ADR-345 and nobody had measured it against that experiment's own +//! rejection criteria. This module does that: same boundary-signal idea, same +//! `ForgetMode::{Soft,Hard}` policies, same acceptance-test shape, swapped +//! backend. + +use crate::compaction::{weighted_importance, CoherenceWeights, CompactionPolicy}; +use crate::graph_forget::ForgetMode; +use crate::memory::MemoryEntry; +use crate::scoring::cosine_sim; +use ruvector_mincut::CactusGraph; +use ruvector_mincut::DynamicGraph; +use std::collections::HashSet; +use std::sync::Arc; + +/// Cactus-canonical-cut forgetting compaction policy (ADR-346 candidates). +/// +/// Identical scoring/eviction logic to +/// [`crate::graph_forget::MincutGatedForgetting`]; the only difference is +/// [`Self::boundary_indices`]'s backend. +#[derive(Debug, Clone)] +pub struct CactusGatedForgetting { + pub weights: CoherenceWeights, + pub mode: ForgetMode, + /// Max neighbors per vertex when building the similarity graph. + pub k_neighbors: usize, + /// Minimum cosine similarity for an edge to be added. + pub min_similarity: f32, + /// [`ForgetMode::Soft`] only: bonus added to a boundary vertex's scalar + /// importance score. + pub structural_bonus: f32, + /// [`ForgetMode::Hard`] only: fraction of `target_size` reserved for + /// boundary vertices. + pub protect_fraction: f32, +} + +impl CactusGatedForgetting { + /// [`ForgetMode::Soft`] with the given weights and bonus. + pub fn soft(weights: CoherenceWeights, structural_bonus: f32) -> Self { + Self { + weights, + mode: ForgetMode::Soft, + k_neighbors: 8, + min_similarity: 0.05, + structural_bonus, + protect_fraction: 0.0, + } + } + + /// [`ForgetMode::Hard`] with the given weights and protected fraction. + pub fn hard(weights: CoherenceWeights, protect_fraction: f32) -> Self { + Self { + weights, + mode: ForgetMode::Hard, + k_neighbors: 8, + min_similarity: 0.05, + structural_bonus: 0.0, + protect_fraction, + } + } + + /// Build a k-NN cosine-similarity graph (identical construction to + /// [`crate::graph_forget::MincutGatedForgetting::boundary_indices`]) and + /// return the indices of vertices with at least one neighbor edge + /// crossing [`ruvector_mincut::CactusGraph::canonical_cut`]'s partition. + /// + /// Unlike the ADR-345 backend this makes exactly one min-cut call: the + /// canonical cut is deterministic by construction (dense Stoer-Wagner + /// plus lexicographic tie-break), so there is no retry-and-union + /// mitigation to apply. See + /// `docs/research/nightly/2026-09-10-canonical-cactus-forgetting/README.md` + /// for the measured determinism and latency comparison against ADR-345. + fn boundary_indices(&self, entries: &[MemoryEntry]) -> HashSet { + let n = entries.len(); + if n < 4 { + return HashSet::new(); + } + + let k = self.k_neighbors.max(1); + let graph = Arc::new(DynamicGraph::new()); + let mut any_edge = false; + for i in 0..n { + 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); + for (j, s) in sims { + // Mirror `RuVectorGraphAnalyzer::from_knn`: weight = 1/distance, + // so near-duplicate pairs get heavy, cut-resistant edges. + // + // Deliberately unconditional on `i < j`: k-NN truncation is + // asymmetric (i can be in j's top-k without j being in i's, + // e.g. a low-degree "gateway" vertex whose k-nearest are all + // same-cluster and so never lists a farther bridge, even + // though the bridge's own short candidate list lists the + // gateway). An `i < j` guard would silently require *both* + // endpoints to agree, which can drop exactly the + // low-similarity bridging edges this policy exists to find. + // `DynamicGraph::insert_edge` is undirected and returns + // `EdgeExists` on the second, redundant attempt, so calling + // it from both endpoints is a correct no-op, not a bug. + let weight = (1.0 / (1.0 - s).max(1e-4)) as f64; + let _ = graph.insert_edge(i as u64, j as u64, weight); + any_edge = true; + } + } + if !any_edge { + return HashSet::new(); + } + + let cactus = CactusGraph::build_from_graph(&graph); + let cut = cactus.canonical_cut(); + let (side_a, _side_b) = &cut.partition; + if side_a.is_empty() || side_a.len() == n { + return HashSet::new(); + } + let side_a_set: HashSet = side_a.iter().copied().collect(); + + let mut boundary = HashSet::new(); + for edge in graph.edges() { + let u = edge.source as usize; + let v = edge.target as usize; + if side_a_set.contains(&u) != side_a_set.contains(&v) { + boundary.insert(u); + boundary.insert(v); + } + } + boundary + } +} + +impl CompactionPolicy for CactusGatedForgetting { + fn name(&self) -> &str { + match self.mode { + ForgetMode::Soft => "CactusGatedForgetting-Soft", + ForgetMode::Hard => "CactusGatedForgetting-Hard", + } + } + + fn select_survivors( + &self, + entries: &[MemoryEntry], + target_size: usize, + context: &[Vec], + ) -> Vec { + if entries.is_empty() { + return Vec::new(); + } + + let boundary = self.boundary_indices(entries); + let scalar = weighted_importance(entries, &self.weights, context); + + match self.mode { + ForgetMode::Soft => { + let mut scored: Vec<(usize, f32)> = scalar + .iter() + .enumerate() + .map(|(i, &s)| { + let bonus = if boundary.contains(&i) { + self.structural_bonus + } else { + 0.0 + }; + (i, s + bonus) + }) + .collect(); + scored.sort_unstable_by(|a, b| b.1.partial_cmp(&a.1).unwrap()); + scored + .into_iter() + .take(target_size) + .map(|(i, _)| i) + .collect() + } + ForgetMode::Hard => { + let protect_budget = + ((target_size as f32) * self.protect_fraction.clamp(0.0, 1.0)).floor() as usize; + let protect_budget = protect_budget.min(target_size).min(boundary.len()); + + let mut boundary_ranked: Vec<(usize, f32)> = + boundary.iter().map(|&i| (i, scalar[i])).collect(); + boundary_ranked.sort_unstable_by(|a, b| b.1.partial_cmp(&a.1).unwrap()); + let protected: Vec = boundary_ranked + .into_iter() + .take(protect_budget) + .map(|(i, _)| i) + .collect(); + let protected_set: HashSet = protected.iter().copied().collect(); + + let remaining_budget = target_size - protected.len(); + let mut rest: Vec<(usize, f32)> = (0..entries.len()) + .filter(|i| !protected_set.contains(i)) + .map(|i| (i, scalar[i])) + .collect(); + rest.sort_unstable_by(|a, b| b.1.partial_cmp(&a.1).unwrap()); + + let mut survivors = protected; + survivors.extend(rest.into_iter().take(remaining_budget).map(|(i, _)| i)); + survivors + } + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::memory::MemoryEntry; + + fn normalize3(v: [f32; 3]) -> Vec { + let n = (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]).sqrt(); + vec![v[0] / n, v[1] / n, v[2] / n] + } + + /// Identical dataset to `graph_forget::tests::bridge_dataset` (see that + /// module for the full topology rationale): two 9-member orthogonal + /// clusters joined by a single degree-2 bridge vertex. + fn bridge_dataset() -> (Vec, usize) { + let mut entries = Vec::new(); + let mut id = 0u64; + let mut push = |v: Vec, access_count: u64, entries: &mut Vec| { + let mut e = MemoryEntry::new(id, v, 0); + e.access_count = access_count; + entries.push(e); + id += 1; + }; + + for axis in 0..2 { + let plain = if axis == 0 { + [1.0, 0.0, 0.0] + } else { + [0.0, 1.0, 0.0] + }; + let gateway = if axis == 0 { + normalize3([1.0, 0.0, 0.5]) + } else { + normalize3([0.0, 1.0, 0.5]) + }; + for _ in 0..8 { + push(plain.to_vec(), 1, &mut entries); + } + push(gateway, 0, &mut entries); + } + push(vec![0.0, 0.0, 1.0], 0, &mut entries); // bridge + let bridge_idx = entries.len() - 1; + (entries, bridge_idx) + } + + #[test] + fn soft_mode_protects_the_structural_bridge_deterministically() { + let (entries, bridge_idx) = bridge_dataset(); + let policy = CactusGatedForgetting::soft(CoherenceWeights::default(), 1.0); + // Single call, no retry budget (unlike ADR-345's `mincut_trials`): + // the point of this experiment is that one call should suffice. + for _ in 0..5 { + let survivors = policy.select_survivors(&entries, 16, &[]); + assert!( + survivors.contains(&bridge_idx), + "cactus-gated forgetting must retain the sole cross-cluster bridge on every call" + ); + } + } + + #[test] + fn hard_mode_reserves_budget_for_boundary_vertices() { + let (entries, bridge_idx) = bridge_dataset(); + let policy = CactusGatedForgetting::hard(CoherenceWeights::default(), 0.3); + let survivors = policy.select_survivors(&entries, 16, &[]); + assert!( + survivors.contains(&bridge_idx), + "hard cactus-gated forgetting must protect the bridge within its reserved budget" + ); + } + + #[test] + fn 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 = CactusGatedForgetting::soft(CoherenceWeights::default(), 1.0); + let survivors = policy.select_survivors(&entries, 2, &[]); + assert_eq!(survivors.len(), 2); + } +} diff --git a/crates/ruvector-agent-memory/src/lib.rs b/crates/ruvector-agent-memory/src/lib.rs index 63a12a2a0a..c0f4f9b2ce 100644 --- a/crates/ruvector-agent-memory/src/lib.rs +++ b/crates/ruvector-agent-memory/src/lib.rs @@ -52,6 +52,8 @@ pub mod diagnostic; pub mod fusion; #[cfg(feature = "mincut-forget")] pub mod graph_forget; +#[cfg(feature = "mincut-forget-cactus")] +pub mod graph_forget_cactus; pub mod ledger; pub mod memory; pub mod observation; @@ -75,6 +77,8 @@ pub use diagnostic::{ pub use fusion::{CausalEpisodicGraph, ClusterId, FusedCluster, FusionError, NodeRef}; #[cfg(feature = "mincut-forget")] pub use graph_forget::{ForgetMode, MincutGatedForgetting}; +#[cfg(feature = "mincut-forget-cactus")] +pub use graph_forget_cactus::CactusGatedForgetting; #[cfg(feature = "proof-gate")] pub use ledger::WriteGateAdapter; pub use ledger::{replay_history, AlwaysAdmitGate, LedgerEntry, ProofGate, TransactionalLedger}; diff --git a/docs/adr/ADR-346-canonical-cactus-cut-forgetting.md b/docs/adr/ADR-346-canonical-cactus-cut-forgetting.md new file mode 100644 index 0000000000..7a59288bd8 --- /dev/null +++ b/docs/adr/ADR-346-canonical-cactus-cut-forgetting.md @@ -0,0 +1,309 @@ +# ADR-346: Canonical-Cactus-Cut Forgetting — Attacking ADR-345's Rejection Root Cause + +## Status + +Rejected (for production use as designed), on a different and more specific +basis than ADR-345. Experimental crate addition +(`ruvector-agent-memory::graph_forget_cactus`, feature-gated behind +`mincut-forget-cactus`, off by default) retained as evidence and reference +implementation, not promoted. `ruvector-mincut`'s `canonical` feature itself +is validated as correct, fast, and genuinely deterministic — the rejection is +about the *forgetting-signal design*, not about the min-cut backend. + +## Context + +ADR-345 (`docs/research/nightly/2026-09-05-mincut-gated-forgetting`) +implemented `MincutGatedForgetting`: a `CompactionPolicy` that builds a k-NN +similarity graph over compaction candidates and uses +`ruvector_mincut::RuVectorGraphAnalyzer::partition()` (the crate's general +dynamic min-cut wrapper) to find a global min-cut boundary, then treats +boundary vertices as structurally load-bearing "bridges" worth protecting +from eviction. It was **rejected** on two measured grounds: + +1. **Non-determinism**: `partition()` returned an empty/unusable result on + 50% of repeated calls (30 trials) on byte-identical input. +2. **Latency**: 76ms-11.4s per call at 50-400 vertices, 1,800-2,700x the + scalar `CoherencePolicy` baseline even at an 84-vertex corpus. + +`ruvector-mincut` separately ships a `canonical` feature +(`crates/ruvector-mincut/src/canonical/`) whose stated purpose is exactly a +fix for problem (1): a `CactusGraph` built by dense-array Stoer-Wagner +enumerates *every* global minimum cut and `canonical_cut()` deterministically +selects the lexicographically smallest one. It was not used by ADR-345 and +nobody had measured it against ADR-345's own rejection criteria. This ADR +does that: same k-NN-graph-plus-boundary-bonus design, same +`ForgetMode::{Soft,Hard}` policies, same acceptance-test shape and +thresholds where reusable, swapped min-cut backend +(`ruvector_mincut::CactusGraph` instead of `RuVectorGraphAnalyzer`). + +## Hypothesis + +```text +Given the identical synthetic corpus ADR-345 used (6 topic clusters, 12 +memories each = 72, plus 12 "bridge" memories interpolated 50/50 between two +randomly paired clusters, 32-dim, hot-cluster access simulation, k-NN k=8 +cosine >= 0.05 similarity graph), + +when the 84-entry store is compacted to 50% (42 entries) using +CactusGatedForgetting-Soft (structural bonus delta=0.5) and +CactusGatedForgetting-Hard (20% protected budget) -- backed by +CactusGraph::canonical_cut() instead of RuVectorGraphAnalyzer::partition() -- +versus the existing CoherencePolicy baseline and versus ADR-345's own +MincutGatedForgetting-Soft/Hard, + +then (a) the cactus backend is deterministic (100% identical boundary result +across repeated calls on byte-identical input, vs. ADR-345's measured 50% +degenerate rate), (b) each cactus candidate's compaction wall-clock stays +within 20x the scalar baseline's (a materially tighter bar than ADR-345's +100x, chosen because Stoer-Wagner on graphs this small is expected to be fast +in absolute terms, not merely bounded), and (c) both cactus candidates retain +a bridge-memory survival rate at least 15 percentage points higher than +baseline while Recall@10 stays within 2 percentage points of baseline, + +subject to: 100% tamper-detection across 20 single-byte-flip trials against +the reused eviction-witness chain. +``` + +Fixed before any benchmark ran; not modified after seeing results. Full +methodology, raw output, and three supporting probes +(`examples/cactus_determinism_probe.rs`, `examples/cactus_scaling_probe.rs`, +`examples/cactus_seed_sensitivity_probe.rs`) live in +`docs/research/nightly/2026-09-10-canonical-cactus-forgetting/README.md`. + +## Decision + +**Do not promote `CactusGatedForgetting` to a default-enabled compaction +policy.** Keep it as an opt-in, feature-gated experimental module +(`mincut-forget-cactus`) alongside ADR-345's own retained +`MincutGatedForgetting`, both off by default. Two sub-findings, both backed +by measurement: + +- **(a) and (b) are CONFIRMED**, resoundingly: 100/100 identical partitions + across two independent determinism runs (0% degenerate, vs. ADR-345's 50%), + and 85-93x faster than `RuVectorGraphAnalyzer` at the identical 84-vertex + corpus (1.6ms vs. 138-152ms). `ruvector-mincut`'s `canonical` feature is a + strict, measured upgrade over the general dynamic wrapper for this + workload on both axes ADR-345 flagged as blocking. +- **(c) is FALSIFIED, and not only for the cactus backend.** At this ADR's + pre-registered seed (346), *neither* backend beat the scalar baseline: + bridge survival was 16.7% for `CoherencePolicy`, `MincutGatedForgetting-Soft`, + and `MincutGatedForgetting-Hard` alike (a 0.0pp gap for ADR-345's own + policy, run fresh in this experiment), and 8.3% (a *negative* 8.3pp gap) + for both `CactusGatedForgetting` variants. A follow-up 10-seed sweep + (`cactus_seed_sensitivity_probe`, seeds 1000-1009) found the 15pp + survival-gap bar met by **0 of 10 seeds for either backend**, with mean + gaps of -3.3pp (old backend) and -4.2pp (cactus) and standard deviations + around 8pp -- i.e., statistical noise centered at zero, not a real effect + that a faster backend failed to preserve. + +The deeper, more general lesson: **a single global-minimum-cut call on a +many-cluster k-NN graph identifies one structurally weakest point in the +*entire* graph** (generically, whichever vertex or small vertex-set has the +least total edge weight -- e.g. one lightly-connected "gateway" vertex), +**not all of the semantically engineered "bridge" vertices this experiment's +corpus generator constructs.** With `mincut_trials = 1` (used by both +backends here, matching ADR-345's own main-benchmark configuration), the +signal genuinely does correlate with *some* structural weak point, but that +point is not reliably one of the 12 constructed bridges out of 84 vertices, +so it does not reliably help *this specific eviction task*. ADR-345's +original single-seed (341) run happening to show a 15pp+ gap looks, on this +evidence, like a favorable-seed artifact rather than a reproducible property +of the approach -- itself a useful, previously-undocumented finding about +that benchmark's sensitivity. + +## Evidence + +All commands below are exactly reproducible; raw stdout is in the nightly +research README. + +```bash +cargo run --release -p ruvector-agent-memory --example cactus_determinism_probe --features mincut-forget-cactus +# trials=50 elapsed=0.0043s avg_per_call=0.086ms empty_or_degenerate=0 (0%) +# bridge_detected_as_boundary=50 (100%) distinct_partitions=1 + +cargo run --release -p ruvector-agent-memory --example cactus_scaling_probe --features mincut-forget-cactus +# n=19..800 ring graph: total latency 0.77ms (n=19) to 8236ms (n=800); +# at n=400 (ADR-345's largest measured size), 1086ms total vs. ADR-345's +# reported multi-second RuVectorGraphAnalyzer measurements at the same size. + +cargo run --release -p ruvector-agent-memory --example cactus_gated_forgetting_bench --features mincut-forget-cactus +# CoherenceWeighted 16.7% survival, 100.0% recall, 41us +# MincutGatedForgetting-Soft 16.7% survival, 100.0% recall, 151802us +# MincutGatedForgetting-Hard 16.7% survival, 100.0% recall, 138776us +# CactusGatedForgetting-Soft 8.3% survival, 100.0% recall, 1632us +# CactusGatedForgetting-Hard 8.3% survival, 100.0% recall, 1615us +# Tamper detection: 20/20 +# => REJECT (survival-gap and speed-vs-scalar-baseline criteria both fail) + +cargo run --release -p ruvector-agent-memory --example cactus_seed_sensitivity_probe --features mincut-forget-cactus +# old(mincut) gap : mean=-3.3pp std=7.6pp seeds_meeting_15pp_bar=0/10 +# new(cactus) gap : mean=-4.2pp std=8.5pp seeds_meeting_15pp_bar=0/10 + +cargo test --release -p ruvector-agent-memory --features mincut-forget-cactus +# 34/34 tests pass (3 new: soft/hard bridge-detection unit tests on the +# original ADR-345 two-clique-plus-bridge fixture, plus a below-minimum-size +# fallback test) +``` + +Hardware/software: this run's container (`uname -a`: Linux x86_64, 4 vCPU), +`rustc 1.94.1`, `cargo 1.94.1`, release profile throughout. + +## Consequences + +- `ruvector-mincut`'s `canonical` feature is now empirically validated as a + correct, fast, deterministic drop-in for small-graph (tested to n=800) + global min-cut queries -- a reusable fact for any future crate (not just + `ruvector-agent-memory`) that needs a min-cut boundary and cannot tolerate + ADR-345's non-determinism or latency. +- `ruvector-agent-memory`'s eviction-witness mechanism + (`compact_witnessed`/`EvictionWitnessChain`, unchanged by this ADR) is + re-confirmed independently sound: 20/20 tamper detections, identical to + ADR-345. +- The "protect the global-min-cut boundary" *idea itself*, not just its + ADR-345 implementation, is now weakened as a compaction-policy candidate: + two independent min-cut backends and 11 total seeds (1 pre-registered + 10 + sensitivity) found no reproducible bridge-protection benefit over the + existing scalar `CoherencePolicy`. A future attempt would need either (i) a + richer signal than a single global cut (e.g. per-community local cuts, or + `ruvector-mincut`'s `all-cut-queries`/`jtree` sparsest-cut primitives, which + this ADR did not test), or (ii) a benchmark corpus where "the weakest + global cut" and "the engineered semantic bridges" are constructed to + coincide, which this one does not guarantee. +- `docs/research/nightly/2026-09-05-mincut-gated-forgetting`'s own positive + 15pp-gap number should be read as seed-specific, not as evidence the + *scalar-baseline-beating* part of that design worked in general; its + rejection for speed/determinism reasons stands independently and is not + weakened by this finding. + +## Alternatives Considered + +1. **Fix `RuVectorGraphAnalyzer::partition()`'s hash-map-order + non-determinism directly** (filed as a follow-up hardening item by + ADR-345, not attempted here or there). Rejected as this ADR's approach + because `canonical` already exists, is purpose-built for exactly this + property, and required zero changes to `ruvector-mincut` itself -- + strictly less engineering risk than patching the general wrapper's + internals. +2. **`tree_packing::canonical_mincut_fast`** (Gomory-Hu tree packing, "Tier + 2", advertised as `O(V * T_maxflow)`) instead of the plain `CactusGraph` + used here. Not benchmarked in this ADR; worth a follow-up if larger + corpora (the originally-desired ~2,000-memory scale ADR-345 could not + reach) are still wanted, since dense Stoer-Wagner's measured ~cubic + scaling (25ms at n=100 to 8.2s at n=800) will not get there either. +3. **Community/local cuts instead of one global cut** (e.g. run the + boundary detector per-cluster, or use `ruvector-mincut`'s + `all-cut-queries` sparsest-cut query) to better target "the semantic + bridges between the corpus's 6 clusters" specifically, rather than "the + single weakest point in the whole 84-vertex graph". Plausible fix for the + (c) falsification above; out of scope for this ADR, which committed in + advance to reusing ADR-345's exact policy design to isolate the backend + variable. Recorded as the concrete next experiment. + +## Implementation Plan + +Already implemented and merged as an experimental, default-off module: +`ruvector-agent-memory::graph_forget_cactus::CactusGatedForgetting` +(`Soft`/`Hard`, reusing `graph_forget::ForgetMode`), plus three research +examples. No further implementation is planned under this ADR given the +rejection; a follow-up ADR would be needed for alternative #3 above. + +## API Shape + +```rust +pub struct CactusGatedForgetting { + pub weights: CoherenceWeights, + pub mode: ForgetMode, // shared with graph_forget::MincutGatedForgetting + pub k_neighbors: usize, + pub min_similarity: f32, + pub structural_bonus: f32, + pub protect_fraction: f32, +} +impl CactusGatedForgetting { + pub fn soft(weights: CoherenceWeights, structural_bonus: f32) -> Self; + pub fn hard(weights: CoherenceWeights, protect_fraction: f32) -> Self; +} +impl CompactionPolicy for CactusGatedForgetting { /* ... */ } +``` + +No `mincut_trials` field (present on ADR-345's `MincutGatedForgetting`): the +canonical backend needs no retry-and-union mitigation because it is +deterministic by construction. + +## Feature Flags + +`mincut-forget-cactus = ["mincut-forget", "ruvector-mincut/canonical"]` in +`ruvector-agent-memory`'s `Cargo.toml`. Composes with, rather than replaces, +ADR-345's `mincut-forget`, so both backends can be built and compared in the +same binary (as `cactus_gated_forgetting_bench` does). Off by default. + +## Benchmark Evidence + +See [Evidence](#evidence) above and the full research README for raw tables, +the seed-sensitivity distribution, and the scaling probe's complete +19-800-vertex curve. + +## Security + +No new security surface: `CactusGraph::build_from_graph` and +`canonical_cut()` are pure, allocation-only computations over an in-memory +graph with no I/O, no unsafe code introduced by this ADR, and no persisted +state. The reused eviction-witness chain's security properties are unchanged +from ADR-345/ADR-134 (SHA-256 content addressing, chained hashes, +tamper-evidence re-confirmed at 20/20 in this run). + +## Governance + +Same governance posture as ADR-345: this remains an opt-in, non-default +compaction policy. No autonomous system is authorized to enable +`mincut-forget-cactus` in production without a human decision informed by +this ADR's rejection. + +## Failure Modes + +- **Falsified as designed**: see [Decision](#decision) -- the structural + bonus does not reliably improve bridge survival over the scalar baseline + at `mincut_trials = 1`, regardless of min-cut backend. +- **Scaling ceiling**: dense Stoer-Wagner's measured cubic-ish growth (25ms + at n=100 -> 8.2s at n=800) means this backend, while dramatically faster + than `RuVectorGraphAnalyzer` at small n, still cannot reach the + ~2,000-memory corpus ADR-345 originally wanted to test at. +- **`CactusGraph::build_from_graph` uses `f64::INFINITY`-based sentinel + values and 1e-12 epsilon comparisons for cut-value ties** (see its source); + this ADR did not stress-test numerical edge cases (e.g. all-equal edge + weights, or graphs with many tied minimum cuts) beyond the two corpora + used here. + +## Migration + +None: nothing is enabled by default before or after this ADR. + +## Rollback + +Delete `crates/ruvector-agent-memory/src/graph_forget_cactus.rs`, its four +example files, and the `mincut-forget-cactus` feature entry. No default +behavior depends on it. + +## Rejection Criteria + +This ADR's hypothesis is rejected under its own pre-registered thresholds: +sub-claims (a) determinism and (b) speed-vs-scalar-baseline both hold with +wide margins, but sub-claim (c) bridge-survival-gap does not hold at the +pre-registered seed nor across a 10-seed sensitivity sweep (0/10 seeds meet +the 15pp bar for either backend). Per this nightly process's own rule, all +three sub-claims needed to hold for acceptance; two of three holding is not +a partial promotion. + +## Open Questions + +1. Does a per-cluster/local-cut variant (alternative #3 above) produce a + bridge-survival gap that actually correlates with the corpus's + constructed bridges, rather than one arbitrary global weak point? +2. Does `tree_packing::canonical_mincut_fast`'s Gomory-Hu approach scale + meaningfully better than dense Stoer-Wagner past n=800, and is it still + deterministic in the same sense? +3. Is ADR-345's original seed-341 result reproducible under `mincut_trials = + 3` (its policy default, though not what its own main benchmark used)? + This ADR did not test the multi-trial-union mitigation against the + cactus backend (which has no retry mechanism to test, being already + deterministic) or re-verify it against the old backend beyond what + ADR-345 itself measured. diff --git a/docs/adr/INDEX.md b/docs/adr/INDEX.md index ffd65a6d0a..0e9bd4145d 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: Canonical-Cactus-Cut Forgetting — Attacking ADR-345's Rejection Root Cause | [`ADR-346-canonical-cactus-cut-forgetting.md`](./ADR-346-canonical-cactus-cut-forgetting.md) | | Rejected (for production use as designed), on a different and more specific | | +| 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-10-canonical-cactus-forgetting/README.md b/docs/research/nightly/2026-09-10-canonical-cactus-forgetting/README.md new file mode 100644 index 0000000000..c0bbe88725 --- /dev/null +++ b/docs/research/nightly/2026-09-10-canonical-cactus-forgetting/README.md @@ -0,0 +1,455 @@ +# Nightly Research: Canonical-Cactus-Cut Forgetting for Agent Memory + +**Date:** 2026-09-10 +**Slug:** `canonical-cactus-forgetting` +**ADR:** [ADR-346](../../../adr/ADR-346-canonical-cactus-cut-forgetting.md) +**Crate:** `ruvector-agent-memory` (`graph_forget_cactus` module, `mincut-forget-cactus` feature) +**Acceptance:** **REJECT** (nuanced — two of three pre-registered sub-claims CONFIRMED, one FALSIFIED) — see [Acceptance result](#acceptance-result) + +## Summary + +Nine days ago, the 2026-09-05 nightly run +(`docs/research/nightly/2026-09-05-mincut-gated-forgetting`, ADR-345) tried +using `ruvector-mincut`'s general dynamic min-cut wrapper +(`RuVectorGraphAnalyzer`) to give `ruvector-agent-memory`'s compaction policy +a structural "don't evict the bridge" signal, and rejected it on two +measured grounds: the wrapper's `.partition()` call was non-deterministic +(50% of repeated calls on identical input returned an empty/unusable result) +and slow (1,800-2,700x the scalar baseline at only 84 vertices). + +This run attacks that specific bottleneck rather than picking a new topic. +`ruvector-mincut` separately ships a `canonical` feature purpose-built for +exactly the determinism problem: `CactusGraph::canonical_cut()` runs dense +Stoer-Wagner to enumerate every global minimum cut and deterministically +picks the lexicographically smallest one. Nobody had measured it against +ADR-345's own rejection criteria. This run does, keeping everything else +identical (same corpus, same `Soft`/`Hard` policy logic, same acceptance +thresholds where reusable) so the min-cut backend is the only variable. + +**Result: a genuinely mixed, evidence-backed outcome.** The backend swap +completely fixes both of ADR-345's original blockers — 100% deterministic +(vs. 50% degenerate) and 85-93x faster than the old backend at the same +corpus size — but a new, independent measurement (a 10-seed sensitivity +sweep, run because the single pre-registered seed showed *both* backends +failing to beat the scalar baseline) shows the underlying idea itself, +independent of backend, does not reliably produce the bridge-protection +benefit ADR-345's own single positive seed suggested. 0 of 10 additional +seeds met the pre-registered 15-percentage-point survival-gap bar for +*either* backend. The eviction-witness mechanism, reused unchanged, again +worked exactly as designed (20/20 tamper trials detected). + +## Abstract + +We ask whether `ruvector-mincut`'s `canonical` feature — a deterministic +cactus-graph-based global min-cut, built for reproducibility rather than for +this use case — fixes the specific performance and determinism defects that +sank ADR-345's `MincutGatedForgetting` compaction policy, and whether doing +so is sufficient to make the underlying structural-forgetting idea viable. +We implement `CactusGatedForgetting` as a drop-in backend swap (same policy +shape, same k-NN graph construction, same corpus), measure it against +ADR-345's own acceptance criteria plus a materially tighter speed bar we +commit to in advance, and additionally run a 10-seed sensitivity sweep once +the single pre-registered seed produced a surprising result (neither backend +beating baseline). The backend-level hypothesis is confirmed; the +policy-level hypothesis is falsified with better evidence than ADR-345 had +available, because ADR-345 never tested more than one seed. + +## Hypothesis + +```text +Given the identical synthetic corpus ADR-345 used (6 topic clusters, 12 +memories each = 72, plus 12 "bridge" memories interpolated 50/50 between two +randomly paired clusters, 32-dim, hot-cluster access simulation, k-NN k=8 +cosine >= 0.05 similarity graph), + +when the 84-entry store is compacted to 50% (42 entries) using +CactusGatedForgetting-Soft (structural bonus delta=0.5) and +CactusGatedForgetting-Hard (20% protected budget) -- backed by +CactusGraph::canonical_cut() instead of RuVectorGraphAnalyzer::partition() -- +versus the existing CoherencePolicy baseline and versus ADR-345's own +MincutGatedForgetting-Soft/Hard, + +then (a) the cactus backend is deterministic (100% identical boundary result +across repeated calls on byte-identical input, vs. ADR-345's measured 50% +degenerate rate), (b) each cactus candidate's compaction wall-clock stays +within 20x the scalar baseline's (tighter than ADR-345's 100x bar), and (c) +both cactus candidates retain a bridge-memory survival rate at least 15 +percentage points higher than baseline while Recall@10 stays within 2 +percentage points of baseline, + +subject to: 100% tamper-detection across 20 single-byte-flip trials against +the reused eviction-witness chain. +``` + +Fixed (in the benchmark's own doc comment, `examples/cactus_gated_forgetting_bench.rs`) +before it was run, and not modified afterward. The 10-seed sensitivity sweep +below is explicitly labeled informational/follow-up, not a redefinition of +this acceptance test. + +## Why This Matters (2026) + +`ruvector-mincut` ships three independent "make min-cut deterministic and/or +fast" mechanisms (`canonical`'s three tiers: `source_anchored`, +`tree_packing`, `dynamic`) that no downstream crate in the workspace was +using as of ADR-345's rejection. ADR-345 explicitly filed its non-determinism +finding as "a follow-up hardening item against `ruvector-mincut`" without +checking whether the fix already existed. Closing that loop — either +promoting a real fix or documenting why the existing fix doesn't solve the +actual product problem — is higher-leverage than opening an unrelated new +topic, and is exactly the "attack its primary bottleneck" instruction this +process's own novelty gate calls for when prior work exists. + +## Why RuVector Is the Right Substrate + +Same as ADR-345: `ruvector-mincut` and `ruvector-agent-memory` both live in +this workspace, and `canonical_cut()`'s cactus representation is a genuinely +different code path (dense Stoer-Wagner over flat arrays, not the general +dynamic-graph wrapper) that only this repository could compare head-to-head +against the already-measured baseline, using the exact same corpus generator +and acceptance harness. + +## Ecosystem Fit + +| Capability | Role | Reused from | +|---|---|---| +| Vector similarity | k-NN graph construction | `ruvector-agent-memory::scoring::cosine_sim` (unchanged from ADR-345) | +| Deterministic min-cut | Structural boundary detection | `ruvector_mincut::CactusGraph` (`canonical` feature, previously unused in-tree) | +| Agent memory | Compaction policy trait, scalar baseline | `ruvector-agent-memory::compaction` | +| Proof-gated writes / witness | Eviction certification | `ruvector-agent-memory::ops`/`witnessed_compaction` (ADR-134 schema, unchanged) | +| Prior nightly lineage | Rejection root-cause tracking | ADR-345 (`graph_forget`, `MincutGatedForgetting`) | + +### MetaHarness / Flywheel / Darwin capability discovery + +Re-verified, not assumed, per this process's own rule (and consistent with +ADR-345's identical finding nine days ago): + +```bash +npx metaharness --help +# metaharness@0.4.16 -- a generic *project-scaffolding* CLI +# ("npx metaharness --template ...") for generating new, +# separate harness projects (with optional Darwin-mode +# self-improvement as an opt-in generator flag). Not wired into +# this repository's build, tests, or CI. + +npx ruvector harness doctor --json +# npm error could not determine executable to run -- no globally +# installed `ruvector` package provides a `harness` subcommand. +``` + +**These capabilities still do not exist in this repository as callable, +in-repo research orchestration tools.** As with ADR-345, the "Goal Planner / +Researcher / Rust Engineer / Benchmark Engineer / Adversarial Reviewer" +roles this process calls for were performed serially in one agent session, +with this document's discover -> deepen -> attack -> implement -> measure -> +sensitivity-check sequence standing in for role separation. No Flywheel +evidence store, Darwin evolution loop, or witness-signing service beyond +`ruvector-agent-memory`'s own existing `EvictionWitnessChain` was available +to invoke; this document and the two ADRs (345, 346) are the durable record +that would otherwise live in a Flywheel store. + +### Architecture + +```mermaid +flowchart TD + A[MemoryEntry corpus, 84 entries] --> B["k-NN cosine graph
(k=8, cos>=0.05)"] + B --> C1["RuVectorGraphAnalyzer::partition()
(ADR-345 backend)"] + B --> C2["CactusGraph::build_from_graph(&g)
.canonical_cut()
(ADR-346 backend)"] + C1 --> D1[boundary vertex set] + C2 --> D2[boundary vertex set] + D1 --> E1[MincutGatedForgetting Soft/Hard] + D2 --> E2[CactusGatedForgetting Soft/Hard] + E1 --> F[select_survivors] + E2 --> F + F --> G[compact_witnessed] + G --> H["EvictionWitnessChain
(reused, unchanged)"] +``` + +## Implementation + +`crates/ruvector-agent-memory/src/graph_forget_cactus.rs`: +`CactusGatedForgetting` mirrors ADR-345's `MincutGatedForgetting` field-for-field +(`Soft`/`Hard` via the shared `graph_forget::ForgetMode` enum), with one +structural difference in `boundary_indices`: it builds a `DynamicGraph` +directly and calls `CactusGraph::build_from_graph(&graph).canonical_cut()` +instead of `RuVectorGraphAnalyzer::from_knn(...).partition()`. No +`mincut_trials` retry field exists on the new type — the whole point of the +canonical backend is that one call suffices. + +**A real bug was found and fixed while building this**, worth recording as +its own micro-lesson: an initial implementation only inserted a k-NN edge +`(i, j)` when `i < j`, assuming symmetric agreement between both endpoints' +truncated neighbor lists. K-NN truncation is not symmetric — a low-degree +"bridge" vertex can have a "gateway" vertex in its own short candidate list +without the reverse being true (the gateway's list is dominated by its +many same-cluster neighbors, which outrank the more-distant bridge and push +it out of the top-`k`). The `i < j` guard silently dropped exactly the +bridging edges this policy exists to detect, and both new unit tests failed +loudly (not silently) as a result. Fixed by inserting unconditionally in +both directions and relying on `DynamicGraph::insert_edge`'s undirected +dedup (it returns `EdgeExists` on the second, redundant call, which the code +already ignores). Filed as a comment in the source rather than a separate +document, since it's implementation-detail-level, not a research finding. + +## Benchmark Methodology + +Three research examples, all `cargo run --release -p ruvector-agent-memory +--features mincut-forget-cactus --example `: + +1. **`cactus_determinism_probe`** — exact ADR-345-comparable topology (19 + vertices, two 9-cliques joined by one degree-2 bridge), 50 repeated + `build_from_graph(...).canonical_cut()` calls on byte-identical input. +2. **`cactus_scaling_probe`** — exact ADR-345-comparable ring k-NN topology + at n=19,50,100,200,400 (ADR-345's own sizes) plus n=800 (new), timing + graph construction, cactus construction, and `canonical_cut()` separately. +3. **`cactus_gated_forgetting_bench`** — the pre-registered acceptance test: + identical 84-memory/12-bridge corpus (seed 346), all 5 policies + (`CoherencePolicy`, `MincutGatedForgetting-{Soft,Hard}`, + `CactusGatedForgetting-{Soft,Hard}`) run in the same process for a direct, + apples-to-apples comparison, plus 20 tamper-detection trials against the + cactus backend's witnessed-compaction output. +4. **`cactus_seed_sensitivity_probe`** — informational follow-up, not part + of the acceptance gate: same corpus generator and both backends' `Soft` + policy (1 trial each) across 10 additional seeds (1000-1009), reporting + the bridge-survival gap's mean/std and how many seeds meet the + pre-registered 15pp bar. + +Release builds throughout (`rustc 1.94.1`, `cargo 1.94.1`, Linux x86_64, 4 +vCPU container). Fixed seeds via `StdRng::seed_from_u64`. `cargo test +--release -p ruvector-agent-memory --features mincut-forget-cactus`: 34/34 +pass (3 new unit tests for `CactusGatedForgetting`). + +## Benchmark Results + +### Determinism (vs. ADR-345's 50% degenerate rate) + +``` +trials=50 elapsed=0.0043s avg_per_call=0.086ms empty_or_degenerate=0 (0%) +bridge_detected_as_boundary=50 (100%) distinct_partitions=1 +``` + +100% identical output across every trial; the bridge is flagged as boundary +every time. ADR-345's comparable number: 50% empty/degenerate, +841ms/call average. + +### Scaling (vs. ADR-345's 76ms-11.4s at 50-400 vertices) + +| n | graph_build (ms) | cactus_build (ms) | canonical_cut (ms) | total (ms) | +|---|---|---|---|---| +| 19 | 0.130 | 0.143 | 0.497 | 0.770 | +| 50 | 0.172 | 0.517 | 3.787 | 4.477 | +| 100 | 0.283 | 2.328 | 22.520 | 25.131 | +| 200 | 0.578 | 11.563 | 148.942 | 161.083 | +| 400 | 1.179 | 76.792 | 1008.149 | 1086.119 | +| 800 | 2.216 | 556.717 | 7676.652 | 8235.586 | + +Growth is roughly cubic (each doubling of `n` past 100 multiplies total time +by ~6.4-7.6x, consistent with dense Stoer-Wagner's `O(n^3)` shape). At the +one size directly comparable to ADR-345's own table (n=400), this backend +measured ~1.1s total versus ADR-345's reported multi-second +`RuVectorGraphAnalyzer` calls at the same size — a large constant-factor win +that does **not** change the asymptotic ceiling: ADR-345's originally-desired +~2,000-memory corpus is still out of reach for either backend (n=800 already +costs 8.2s per call). + +### Main acceptance benchmark (84-memory corpus, seed 346) + +| Policy | Bridge Surv. | Recall@10 | Compaction (us) | +|---|---|---|---| +| CoherenceWeighted (baseline) | 16.7% | 100.0% | 41 | +| MincutGatedForgetting-Soft (ADR-345) | 16.7% | 100.0% | 151,802 | +| MincutGatedForgetting-Hard (ADR-345) | 16.7% | 100.0% | 138,776 | +| CactusGatedForgetting-Soft (this ADR) | 8.3% | 100.0% | 1,632 | +| CactusGatedForgetting-Hard (this ADR) | 8.3% | 100.0% | 1,615 | + +Tamper detection: 20/20 single-byte-flip trials detected (cactus backend, +reused witness chain). + +Backend-only comparison at this corpus size: 93.0x faster (Soft), +85.9x faster (Hard) than ADR-345's backend. + +### Seed sensitivity (10 additional seeds, informational) + +| seed | baseline survival | old(mincut) gap | new(cactus) gap | +|---|---|---|---| +| 1000 | 66.7% | -8.3pp | -8.3pp | +| 1001 | 58.3% | -16.7pp | -16.7pp | +| 1002 | 8.3% | +8.3pp | 0.0pp | +| 1003 | 75.0% | 0.0pp | 0.0pp | +| 1004 | 50.0% | 0.0pp | 0.0pp | +| 1005 | 50.0% | -8.3pp | -16.7pp | +| 1006 | 16.7% | +8.3pp | +8.3pp | +| 1007 | 75.0% | 0.0pp | +8.3pp | +| 1008 | 16.7% | -8.3pp | -8.3pp | +| 1009 | 58.3% | -8.3pp | -8.3pp | +| **mean / std** | — | **-3.3pp / 7.6pp** | **-4.2pp / 8.5pp** | +| **seeds meeting 15pp bar** | — | **0/10** | **0/10** | + +## Memory Math + +`CactusGraph::build_from_graph` allocates a dense `n x n` `f64` adjacency +matrix (`Vec` of length `n^2`) plus `O(n)` auxiliary buffers for +Stoer-Wagner's per-phase state, and the cactus itself is `O(n)` +vertices/edges/cycles. At n=800: the dense matrix alone is `800^2 * 8 bytes += 5.12MB`; negligible next to typical embedding-store memory at that scale, +but it is allocated fresh on every call (no incremental reuse), which is +part of why latency, not memory, is the binding constraint here. + +## Performance Math + +Dense Stoer-Wagner is `O(n^3)` in the worst case (`n-1` phases, each +scanning `O(n)` remaining active nodes `O(n)` times). The measured +100->800 growth (25ms -> 8236ms, a 329x increase over an 8x increase in `n`, +i.e. exponent `log(329)/log(8) ≈ 2.79`) is consistent with that bound. This +is the same complexity class the general dynamic wrapper's rejected `.partition()` +call likely also pays somewhere internally, but the cactus backend's smaller +constant factor (flat contiguous arrays, no hash-map-backed dynamic graph +maintenance, no incremental-update bookkeeping the general wrapper carries +for use cases this benchmark doesn't need) is what actually produces the +85-93x measured win at n=84. + +## Failure Modes + +See ADR-346's own "Failure Modes" section: the survival-gap falsification, +the cubic scaling ceiling, and un-stress-tested numerical tie-breaking in +`CactusGraph`'s epsilon comparisons. + +## Rejected Alternatives + +See ADR-346's "Alternatives Considered": patching the old backend directly, +`tree_packing::canonical_mincut_fast` (Gomory-Hu, not benchmarked here), and +community/local cuts instead of one global cut (the most promising follow-up, +also not attempted here to keep this experiment's single variable — the +backend — isolated). + +## Security + +No new attack surface: pure in-memory graph computation, no I/O, no new +unsafe code, reused witness/signing machinery unchanged from ADR-134/ADR-345. + +## Governance + +Opt-in, default-off feature (`mincut-forget-cactus`). No autonomous +promotion; this document and ADR-346 exist so a human reviewer has the full +evidence trail before ever considering enabling it. + +## MCP Implications + +None proposed. Exposing a min-cut-boundary query as an MCP tool would be +premature given the falsified survival-benefit finding above; revisit only +if a follow-up (local/community cuts) produces a positive, seed-robust +result. + +## WASM Implications + +`ruvector-mincut`'s `canonical` feature has no WASM-incompatible +dependencies (pure computation over `std` collections); not benchmarked +under `wasm32` in this run. Given the measured cubic scaling, a WASM/edge +deployment would face the same n<~200 practical ceiling as the native +benchmark, likely tighter given WASM's typical 1.2-2x native-speed overhead +for this kind of scalar-heavy code. + +## Edge Implications + +Not evaluated beyond the note above; the falsified survival benefit makes +further edge-specific analysis premature. + +## RVF Implications + +If a future local/community-cut variant *did* produce a robust +survival benefit, the resulting boundary set would be a natural candidate +for inclusion in an RVF portable memory snapshot (alongside the existing +eviction-witness chain), since `canonical_cut()`'s determinism means the +same snapshot replayed elsewhere reproduces the identical boundary -- +exactly the reproducibility property RVF packages need. Not applicable to +the rejected candidate itself. + +## RVM Implications + +None beyond ADR-345's own assessment: no privileged-operation or +coherence-domain boundary is implicated by a pure library computation over +already-in-process data. + +## ruFlo Implications + +None proposed for this rejected candidate. If a follow-up local-cut variant +succeeds, a plausible ruFlo role would be "periodic background compaction +job that recomputes local structural boundaries on a schedule, decoupled +from the online write/read path" -- justified by this run's own finding that +even the *fast* backend (1.6ms at n=84, ~1s at n=400) is still too slow to +run inline on every compaction at larger corpus sizes. + +## Practical Applications + +Not applicable to a falsified candidate; see ADR-345's own list for the +general "protect structurally important agent memories" use case this line +of research is chasing, which remains open. + +## Long-Horizon Applications + +Same as ADR-345: self-healing agent memory graphs that never silently +fragment. This run narrows the open problem to "find a boundary-detection +signal that actually targets constructed semantic bridges, not just the +single globally weakest graph point" -- a more precise target for future +work than ADR-345 left it. + +## Evolution Results + +No Darwin loop available in-repo (see capability discovery above); the +backend swap explored here was a single, hand-selected hypothesis rather +than a population search. + +## Promotion Decision + +**REJECT.** Two of three pre-registered sub-claims (determinism, speed) +strongly confirmed; the third (survival benefit) falsified by both the +pre-registered seed and a 10-seed sensitivity sweep. Per this nightly +process's own rule, all sub-claims were required for acceptance. + +## Witness Evidence + +- Git commit at run start: see this branch's first commit on top of + `edaffffb3` (see PR). +- Exact reproduction commands: [Benchmark Methodology](#benchmark-methodology). +- Hardware/software: `rustc 1.94.1`, `cargo 1.94.1`, Linux x86_64, 4 vCPU + container, release profile. +- No cryptographic witness beyond `ruvector-agent-memory`'s own + `EvictionWitnessChain` (re-verified 20/20 in this run) was available or + applicable to the research process itself. + +## Production Path + +None. Retained as a reference implementation and as a validated fact about +`ruvector-mincut`'s `canonical` feature (correct, fast, deterministic at the +sizes tested) for any future crate that needs those properties. + +## Falsification Criteria + +Stated in advance in the [Hypothesis](#hypothesis); sub-claim (c) is the one +that failed: bridge-survival gap >= 15pp for both `Soft` and `Hard` cactus +variants. + +## Limitations + +- Only two `mincut_trials` configurations were tested in total (1 for the + main bench, none/1-implicit for cactus since it has no retry field); + ADR-345's default of 3 trials for the old backend was not re-verified here. +- The seed-sensitivity sweep used only the `Soft` variant, not `Hard`, to + keep the sweep's runtime bounded; `Hard`'s behavior is expected to + correlate closely with `Soft`'s (both consume the same boundary set) but + this was not independently measured across all 10 seeds. +- No comparison against `tree_packing::canonical_mincut_fast` or + `all-cut-queries` sparsest-cut primitives. + +## Next Research + +Community/local-cut boundary detection (per-cluster mincut, or +`ruvector-mincut`'s sparsest-cut query) as a more targeted structural signal +than one global cut — the concrete next step this run's evidence points to. + +## References + +- ADR-345, `docs/research/nightly/2026-09-05-mincut-gated-forgetting`. +- `crates/ruvector-mincut/src/canonical/mod.rs` (module-level doc comment + cites the cactus-graph literature this feature implements). +- Stoer, M. and Wagner, F., 1997. "A simple min-cut algorithm." *Journal of + the ACM*, 44(4). diff --git a/docs/research/nightly/2026-09-10-canonical-cactus-forgetting/gist.md b/docs/research/nightly/2026-09-10-canonical-cactus-forgetting/gist.md new file mode 100644 index 0000000000..914e602186 --- /dev/null +++ b/docs/research/nightly/2026-09-10-canonical-cactus-forgetting/gist.md @@ -0,0 +1,162 @@ +# Fixing a Rejected Experiment's Bottleneck Doesn't Always Save the Idea + +## Problem + +A prior experiment (ADR-345, in the same codebase) tried to make an +agent-memory compaction policy structure-aware: instead of scoring every +memory independently (recency, frequency, coherence), build a k-NN +similarity graph over the candidates and use a global minimum-cut to find +"bridge" memories — the sole semantic link between two otherwise-disjoint +topic clusters — so they aren't evicted just because they score low on +every scalar term. + +That experiment was rejected, but not because the idea was wrong on its +merits: the specific min-cut implementation it called +(`RuVectorGraphAnalyzer::partition()`, a general dynamic min-cut wrapper) +was measured to be non-deterministic (50% of repeated calls on identical +input returned an unusable empty result) and slow (1,800-2,700x a plain +scalar-sort baseline, even on an 84-vertex test graph). + +## Hypothesis + +The same codebase separately ships a `canonical` feature on its min-cut +crate, built for exactly the determinism problem: a cactus-graph +representation that runs dense Stoer-Wagner to enumerate every global +minimum cut of a graph and deterministically picks the lexicographically +smallest one. Nobody had tried it against the rejected experiment's own +criteria. The question: does swapping backends — same policy logic, same +test corpus, same acceptance thresholds — fix the two measured blockers, and +is that enough to make the underlying idea viable? + +## Technical Design + +`CactusGatedForgetting` is a line-for-line mirror of the rejected policy, +with one substitution in its boundary-detection step: + +```rust +// Before (rejected backend): +let mut analyzer = RuVectorGraphAnalyzer::from_knn(&neighbors); +let (side_a, side_b) = analyzer.partition().unwrap_or_default(); + +// After (this experiment): +let cactus = CactusGraph::build_from_graph(&graph); +let cut = cactus.canonical_cut(); +let (side_a, side_b) = cut.partition; +``` + +Everything downstream — turning a cut partition into a "boundary vertex" +set, then either adding a scalar bonus (`Soft` mode) or reserving eviction +budget (`Hard` mode) for boundary vertices — is untouched. + +## Actual Implementation + +One real bug surfaced during implementation, worth calling out because it's +a general trap: an early version only inserted a k-NN graph edge `(i, j)` +when `i < j`, on the assumption that if `j` is among `i`'s nearest +neighbors, the relationship is roughly symmetric. It isn't, for exactly the +vertices this policy cares about most: a low-degree "bridge" vertex can have +a well-connected "gateway" vertex in its own short candidate list, while the +gateway's own list is dominated by its many same-cluster neighbors, pushing +the more-distant bridge out of its top-`k`. The `i < j` guard silently +dropped precisely the bridging edges the whole policy exists to detect — +caught immediately by two failing unit tests, fixed by inserting the edge +unconditionally from both endpoints and letting the graph's own undirected +deduplication handle the redundancy. + +## Benchmark Evidence + +All numbers below are from `cargo run --release` against a fixed-seed +synthetic corpus (identical to the rejected experiment's own: 6 clusters x +12 memories, 12 bridge memories, 32 dimensions), on `rustc 1.94.1`. + +**Determinism** — 50 repeated calls on byte-identical input: + +| Backend | Empty/degenerate results | Distinct partitions returned | +|---|---|---| +| Rejected (dynamic wrapper) | 50% | not applicable (non-deterministic) | +| This experiment (cactus) | **0%** | **1** | + +**Speed** — same 84-vertex corpus, `Soft` policy: + +| Backend | Compaction wall-clock | +|---|---| +| Rejected (dynamic wrapper) | 151,802 microseconds | +| This experiment (cactus) | **1,632 microseconds** | + +That's a 93x speedup on top of full determinism. Both prior blockers: fixed. + +**But the underlying idea doesn't hold up.** At the pre-registered seed, +*neither* backend beat a plain scalar-scoring baseline on bridge-memory +survival (16.7% for the baseline and the old backend; 8.3%, actually worse, +for the new one). That single data point could have been an unlucky seed — +so a follow-up swept 10 more seeds: + +| Metric | Old backend | New (cactus) backend | +|---|---|---| +| Mean survival gap vs. baseline | -3.3 percentage points | -4.2 percentage points | +| Seeds meeting the pre-registered +15pp bar | 0 / 10 | 0 / 10 | + +Zero out of ten. The original experiment's one positive result looks, in +hindsight, like a favorable-seed artifact rather than a reproducible +property of "protect the global min-cut boundary." + +## Why This Happens + +A single global minimum cut of a many-cluster graph finds *one* structurally +weakest point in the *entire* graph — generically whichever vertex or small +group has the least total edge weight. In a corpus deliberately constructed +with 12 separate bridge memories across 6 clusters, there is no guarantee +that "the one globally weakest link" coincides with any particular one of +those 12 engineered bridges. Making the min-cut computation faster and +deterministic doesn't change what it's fundamentally computing. + +## Limitations + +- Only a global cut was tested; a per-cluster or local-cut variant (which + would more directly target "bridges between specific cluster pairs" + rather than "the single weakest point anywhere") is untested and is the + natural next experiment. +- Scaling: the cactus backend's dense Stoer-Wagner still grows roughly + cubically (25ms at 100 vertices to 8.2 seconds at 800), so while it's a + large constant-factor win, it doesn't reach the thousands-of-memories + scale the original experiment wanted to test at either. +- Only the `Soft` policy variant was included in the 10-seed sweep, to keep + its runtime bounded. + +## Production Relevance + +Two independently useful, validated facts survive a fully rejected +hypothesis: (1) the codebase's `canonical` cactus min-cut feature is now +proven correct, deterministic, and fast at small-to-medium graph sizes — +reusable by any future component that needs those properties without this +component's specific use case — and (2) "protect the global min-cut +boundary" is now a documented dead end for *this* eviction task, backed by +11 seeds of evidence rather than the 1 seed the original experiment had, so +a future engineer doesn't have to rediscover that the fast, correct version +of the same idea still doesn't work. + +## RuVector Ecosystem Implications + +This connects the min-cut crate, the agent-memory crate, and the existing +witness/provenance mechanism (re-verified, unchanged, 20/20 tamper +detections) — and demonstrates a useful pattern for this kind of iterative +research: when an experiment is rejected for an *implementation* reason +(slow, flaky) rather than a *design* reason, the right first move is +checking whether a fix already exists in-tree before either abandoning the +idea or reimplementing the fix from scratch. Here it did, and applying it +cleanly separated "was the implementation broken" (yes, now fixed) from "was +the idea correct" (no, now shown more convincingly than before). + +## Future Direction + +Community-aware or local minimum cuts — computed per topic cluster rather +than once globally, or via a sparsest-cut query if the min-cut crate's +`all-cut-queries` feature supports it at these graph sizes — are the +concrete next step this evidence points to, since they would target the +specific "bridge between these two clusters" structure the corpus actually +constructs, rather than one arbitrary global weak point. + +## References + +- Prior experiment and rejection: `docs/research/nightly/2026-09-05-mincut-gated-forgetting`. +- Stoer, M. and Wagner, F., 1997. "A simple min-cut algorithm." *Journal of the ACM*, 44(4).