From cd4d881de16c90647ab8a78708fc15b7a9a29aac Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 24 Aug 2026 07:36:34 +0000 Subject: [PATCH 1/3] feat(ruvector-structural-memory): structural-time clock for agent memory compaction Add a research crate that reuses emergent-time's StructuralProperTime (ADR-251) as the recency signal for memory-compaction retention scoring, in place of wall-clock step count. Includes a deterministic multi-seed synthetic session generator, compaction/oracle-recall scoring, and a benchmark binary sweeping 3 plateau lengths x 3 clocks x 10 seeds. Co-Authored-By: claude-flow Claude-Session: https://claude.ai/code/session_01TdYyZd166DoTxb5R4FWuJc --- Cargo.lock | 7 + Cargo.toml | 3 + crates/ruvector-structural-memory/Cargo.toml | 26 ++ .../ruvector-structural-memory/src/clocks.rs | 34 ++ .../src/compaction.rs | 140 ++++++++ crates/ruvector-structural-memory/src/lib.rs | 46 +++ crates/ruvector-structural-memory/src/main.rs | 336 ++++++++++++++++++ .../src/scenario.rs | 266 ++++++++++++++ 8 files changed, 858 insertions(+) create mode 100644 crates/ruvector-structural-memory/Cargo.toml create mode 100644 crates/ruvector-structural-memory/src/clocks.rs create mode 100644 crates/ruvector-structural-memory/src/compaction.rs create mode 100644 crates/ruvector-structural-memory/src/lib.rs create mode 100644 crates/ruvector-structural-memory/src/main.rs create mode 100644 crates/ruvector-structural-memory/src/scenario.rs diff --git a/Cargo.lock b/Cargo.lock index 2a7d216946..83a7bf4e27 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -10655,6 +10655,13 @@ dependencies = [ "rand_distr 0.4.3", ] +[[package]] +name = "ruvector-structural-memory" +version = "0.1.0" +dependencies = [ + "emergent-time", +] + [[package]] name = "ruvector-temporal-coherence" version = "0.1.0" diff --git a/Cargo.toml b/Cargo.toml index b4def6526d..64f03a68a5 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -295,6 +295,9 @@ members = [ # Calculus of emergent / relational time (Wheeler-DeWitt, Page-Wootters, # entropic, thermal) + Structural Proper Time for agentic systems. "crates/emergent-time", + # Structural-time agent memory decay: StructuralProperTime-based compaction + # retention scoring vs wall-clock recency (nightly 2026-08-24, ADR-340) + "crates/ruvector-structural-memory", # PhotonLayer: learned optical-frontend computing simulator (ADR-260) "crates/photonlayer-core", "crates/photonlayer-bench", diff --git a/crates/ruvector-structural-memory/Cargo.toml b/crates/ruvector-structural-memory/Cargo.toml new file mode 100644 index 0000000000..abb784ed67 --- /dev/null +++ b/crates/ruvector-structural-memory/Cargo.toml @@ -0,0 +1,26 @@ +[package] +name = "ruvector-structural-memory" +version = "0.1.0" +edition = "2021" +description = "Structural-time agent memory decay: replaces wall-clock recency with emergent-time's StructuralProperTime (embedding-arc-length + entropy internal clock) for compaction retention scoring" +authors = ["ruvnet", "claude-flow"] +license = "MIT OR Apache-2.0" +repository = "https://github.com/ruvnet/ruvector" +keywords = ["agent-memory", "emergent-time", "vector-search", "compaction", "ruvector"] +categories = ["algorithms", "data-structures"] + +[[bin]] +name = "benchmark" +path = "src/main.rs" + +[dependencies] +# ADR-251's calculus of emergent time: reused here (not reimplemented) for its +# `Clock` trait / `StructuralProperTime` arc-length clock and Shannon entropy +# helper, applied to a new domain (agent-memory compaction retention scoring). +emergent-time = { version = "2.2.4", path = "../emergent-time" } + +[dev-dependencies] + +# Research-tier crate: keep correctness lints denied, relax style churn. +[lints.rust] +dead_code = "allow" diff --git a/crates/ruvector-structural-memory/src/clocks.rs b/crates/ruvector-structural-memory/src/clocks.rs new file mode 100644 index 0000000000..f1e1c4b5bc --- /dev/null +++ b/crates/ruvector-structural-memory/src/clocks.rs @@ -0,0 +1,34 @@ +//! The three clocks under comparison. All are literal `emergent-time` types — +//! this module only fixes the [`StructuralMetric`] weights, it does not add +//! new clock math. + +use emergent_time::{StructuralMetric, StructuralProperTime}; + +/// Candidate A: internal time = accumulated embedding movement only (`Δv`). +/// Cheapest structural clock: one L2 distance per step, no other signal +/// required. +pub fn structural_embedding_clock() -> StructuralProperTime { + StructuralProperTime::new(StructuralMetric { + w_embedding: 1.0, + w_entropy: 0.0, + w_graph: 0.0, + w_coherence: 0.0, + w_pred_error: 0.0, + gate: 0.0, + }) +} + +/// Candidate B: internal time = embedding movement (`Δv`) plus genuine +/// topic-uncertainty entropy (`ΔS`, see [`crate::scenario::build_snapshots`]). +/// `ΔG` and `ΔE` stay at zero weight: this harness has no honest graph or +/// prediction-error signal to feed them. +pub fn structural_full_clock() -> StructuralProperTime { + StructuralProperTime::new(StructuralMetric { + w_embedding: 1.0, + w_entropy: 1.0, + w_graph: 0.0, + w_coherence: 0.0, + w_pred_error: 0.0, + gate: 0.0, + }) +} diff --git a/crates/ruvector-structural-memory/src/compaction.rs b/crates/ruvector-structural-memory/src/compaction.rs new file mode 100644 index 0000000000..f54e509bc5 --- /dev/null +++ b/crates/ruvector-structural-memory/src/compaction.rs @@ -0,0 +1,140 @@ +//! Compaction: score every memory once against the final context, keep the +//! top `budget`, and compare against an oracle nearest-neighbour set. + +use std::collections::HashSet; +use std::time::{Duration, Instant}; + +use emergent_time::{Clock, StateSnapshot}; + +use crate::scenario::{cosine, MemoryItem}; + +#[derive(Clone, Copy, Debug)] +pub struct CompactionWeights { + pub w_coherence: f64, + pub w_recency: f64, + /// Decay half-scale, as a fraction of the clock's *own* total elapsed + /// internal time over the session. Fixed identically across all clocks so + /// no clock gets a hand-tuned decay scale — see crate-level docs. + pub tau_fraction: f64, +} + +impl Default for CompactionWeights { + fn default() -> Self { + CompactionWeights { + w_coherence: 0.5, + w_recency: 0.5, + tau_fraction: 0.2, + } + } +} + +pub struct CompactionResult { + pub kept: HashSet, + /// Wall-clock time to build the clock's cumulative-time array and score + /// every memory. Excludes session/snapshot generation (shared setup cost, + /// identical for all clocks). + pub elapsed: Duration, +} + +/// Score every memory against `final_context` using `clock`'s notion of age, +/// keep the top `budget` by score. +pub fn compact( + clock: &C, + snapshots: &[StateSnapshot], + memories: &[MemoryItem], + final_context: &[f64], + budget: usize, + weights: CompactionWeights, +) -> CompactionResult { + let start = Instant::now(); + let cumulative = clock.cumulative(snapshots); + let total_time = *cumulative.last().unwrap_or(&0.0); + let tau = (weights.tau_fraction * total_time).max(1e-9); + let final_time = *cumulative.last().unwrap_or(&0.0); + + let mut scored: Vec<(usize, f64)> = memories + .iter() + .map(|m| { + let age = (final_time - cumulative[m.write_step]).max(0.0); + let coh = cosine(&m.embedding, final_context); + let rec = (-age / tau).exp(); + let score = weights.w_coherence * coh + weights.w_recency * rec; + (m.id, score) + }) + .collect(); + scored.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap()); + let kept: HashSet = scored.into_iter().take(budget).map(|(id, _)| id).collect(); + let elapsed = start.elapsed(); + CompactionResult { kept, elapsed } +} + +/// True top-`k` memories by raw cosine similarity to `final_context` — what +/// an unlimited-memory oracle would return for the final query. +pub fn oracle_top_k(memories: &[MemoryItem], final_context: &[f64], k: usize) -> HashSet { + let mut scored: Vec<(usize, f64)> = memories + .iter() + .map(|m| (m.id, cosine(&m.embedding, final_context))) + .collect(); + scored.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap()); + scored.into_iter().take(k).map(|(id, _)| id).collect() +} + +/// Fraction of the oracle top-k that survived compaction. +pub fn recall_at_k(kept: &HashSet, oracle: &HashSet) -> f64 { + if oracle.is_empty() { + return 1.0; + } + let hit = oracle.iter().filter(|id| kept.contains(*id)).count(); + hit as f64 / oracle.len() as f64 +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::clocks::structural_embedding_clock; + use crate::scenario::{generate_session, ScenarioConfig}; + use emergent_time::WallClock; + + #[test] + fn kept_set_never_exceeds_budget() { + let cfg = ScenarioConfig::default(); + let session = generate_session(&cfg); + let final_context = session.contexts.last().unwrap().clone(); + let budget = 10; + let res = compact( + &WallClock, + &session.snapshots, + &session.memories, + &final_context, + budget, + CompactionWeights::default(), + ); + assert!(res.kept.len() <= budget); + } + + #[test] + fn oracle_recall_of_itself_is_one() { + let cfg = ScenarioConfig::default(); + let session = generate_session(&cfg); + let final_context = session.contexts.last().unwrap().clone(); + let oracle = oracle_top_k(&session.memories, &final_context, 15); + assert!((recall_at_k(&oracle, &oracle) - 1.0).abs() < 1e-12); + } + + #[test] + fn structural_clock_runs_end_to_end() { + let cfg = ScenarioConfig::default(); + let session = generate_session(&cfg); + let final_context = session.contexts.last().unwrap().clone(); + let clock = structural_embedding_clock(); + let res = compact( + &clock, + &session.snapshots, + &session.memories, + &final_context, + 20, + CompactionWeights::default(), + ); + assert!(!res.kept.is_empty()); + } +} diff --git a/crates/ruvector-structural-memory/src/lib.rs b/crates/ruvector-structural-memory/src/lib.rs new file mode 100644 index 0000000000..2811e5af51 --- /dev/null +++ b/crates/ruvector-structural-memory/src/lib.rs @@ -0,0 +1,46 @@ +//! Structural-time agent memory decay. +//! +//! Agent memory compaction (e.g. `ruvector-agent-memory`, nightly 2026-06-14) +//! scores a stored memory's "recency" against **wall-clock time**: the number +//! of turns/steps since it was written. This crate isolates that one variable +//! and asks whether `emergent-time`'s [`emergent_time::StructuralProperTime`] +//! — internal time defined as accumulated *embedding-arc-length* (and, +//! optionally, entropy) rather than step count — makes a better recency clock +//! for compaction retention scoring. +//! +//! The mechanism is simple: during a long, low-drift stretch of a session +//! (the agent is heads-down on one topic), a structural clock accumulates +//! almost no internal time, so memories written early and late in that +//! stretch end up at nearly the same structural age even though many wall +//! steps separate them. A wall clock cannot make that distinction — it ages +//! every memory at a constant rate regardless of whether anything actually +//! changed. See `src/main.rs` for the benchmark that measures the +//! consequence: compaction recall against an oracle nearest-neighbour set. +//! +//! Three clocks are compared, all literal instances of `emergent-time` +//! types — no new clock math is introduced by this crate: +//! +//! 1. [`emergent_time::WallClock`] — the baseline (today's production +//! convention). +//! 2. `StructuralProperTime` with only the embedding channel weighted +//! ([`clocks::structural_embedding_clock`]) — pure accumulated context +//! drift. +//! 3. `StructuralProperTime` with embedding + entropy channels weighted +//! ([`clocks::structural_full_clock`]) — drift plus a genuine derived +//! "topic uncertainty" signal (Shannon entropy of the softmax over +//! cosine similarities to the session's topic centroids, via +//! [`emergent_time::entropy::entropy_from_spectrum`]). +//! +//! The graph and prediction-error channels of `StructuralProperTime` are left +//! at zero weight throughout: this harness has no honest signal source for +//! them (no dependency graph, no forward model). Wiring those channels to +//! real RuVector primitives (`ruvector-mincut` for `ΔG`, a task-success +//! predictor for `ΔE`) is noted as future work, not simulated here. + +pub mod clocks; +pub mod compaction; +pub mod scenario; + +pub use clocks::{structural_embedding_clock, structural_full_clock}; +pub use compaction::{compact, oracle_top_k, recall_at_k, CompactionWeights}; +pub use scenario::{generate_session, ScenarioConfig, Session}; diff --git a/crates/ruvector-structural-memory/src/main.rs b/crates/ruvector-structural-memory/src/main.rs new file mode 100644 index 0000000000..be7d2e9d90 --- /dev/null +++ b/crates/ruvector-structural-memory/src/main.rs @@ -0,0 +1,336 @@ +//! Benchmark: WallClock vs StructuralEmbeddingClock vs StructuralFullClock +//! for agent-memory compaction retention scoring. +//! +//! Usage: `cargo run --release -p ruvector-structural-memory --bin benchmark` +//! +//! Hypothesis (fixed before this binary was run in its final form; see +//! docs/research/nightly/2026-08-24-structural-time-memory-decay/README.md +//! for the full methodology note, including why the run was redone as a +//! multi-seed sweep rather than a single seed): +//! +//! Given synthetic agent sessions of topic plateaus separated by sharp +//! switches, when compaction retention score uses StructuralEmbeddingClock's +//! accumulated context drift instead of WallClock step count as the age +//! signal, then mean recall@15 of the oracle nearest-neighbour set — averaged +//! over `N_SEEDS` independent sessions — after compacting to a fixed budget +//! of 25 memories (deliberately smaller than a long plateau's own topic +//! pool, so compaction must choose *within* the current topic rather than +//! only discard other topics) improves by >= 5 percentage points in the +//! long-plateau (150 steps/topic) configuration, without regressing by more +//! than 2 percentage points in the short-plateau (20 steps/topic) +//! configuration, subject to compaction compute time staying within 5x +//! WallClock's, and causal order (monotone cumulative time) being preserved +//! by every clock on every seed. +//! +//! The budget is fixed in absolute terms (not a fraction of corpus size) on +//! purpose: a long plateau's own topic accumulates far more members than a +//! short plateau's, so a fixed budget creates real within-topic competition +//! for the long-plateau case (where the effect under test should appear) +//! while the short-plateau case stays close to a trivial keep-everything +//! regime (where no clock should have an edge) — this is the asymmetry the +//! hypothesis's two clauses are built to detect. +//! +//! Seeds are averaged, not cherry-picked: an early single-seed run (0xC0FFEE) +//! showed a +6.67pp lead, but three more ad hoc seeds tried while debugging +//! the noise-scale parameter showed the lead is not reliable per-seed — two +//! of four ties the wall clock exactly. Reporting only the seed that passed +//! would be exactly the "cherry picked seeds" reward-hacking pattern this +//! harness is required to avoid, so the acceptance decision below is gated +//! on the mean over `N_SEEDS` deterministically-generated seeds, not any +//! single one. + +use std::collections::HashSet; +use std::time::Duration; + +use emergent_time::{Clock, WallClock}; +use ruvector_structural_memory::clocks::{structural_embedding_clock, structural_full_clock}; +use ruvector_structural_memory::compaction::{ + compact, oracle_top_k, recall_at_k, CompactionWeights, +}; +use ruvector_structural_memory::scenario::{generate_session, ScenarioConfig}; + +const N_TOPICS: usize = 4; +const DIM: usize = 32; +const ORACLE_K: usize = 15; +/// Fixed absolute compaction budget (not a fraction of corpus size) — see +/// module docs for why this must be fixed rather than scaled with corpus +/// size for the hypothesis to be testable. +const BUDGET: usize = 25; +const TIMING_REPS: u32 = 25; +/// Number of independent sessions averaged per (plateau_len, clock) cell. +/// Seeds are generated deterministically from a fixed base, not chosen after +/// looking at outcomes (see module docs). +const N_SEEDS: u64 = 10; +const SEED_BASE: u64 = 0xC0FFEE; +const SEED_STRIDE: u64 = 0x9E37_79B9; + +const LONG_LEAD_THRESHOLD_PP: f64 = 5.0; +const SHORT_REGRESSION_TOLERANCE_PP: f64 = 2.0; +const MAX_OVERHEAD_RATIO: f64 = 5.0; + +fn is_monotone(xs: &[f64]) -> bool { + xs.windows(2).all(|w| w[1] + 1e-12 >= w[0]) +} + +fn mean(xs: &[f64]) -> f64 { + xs.iter().sum::() / xs.len() as f64 +} + +fn stddev(xs: &[f64], m: f64) -> f64 { + (xs.iter().map(|x| (x - m).powi(2)).sum::() / xs.len() as f64).sqrt() +} + +struct Cell { + plateau_len: usize, + clock_name: &'static str, + total_steps: usize, + budget: usize, + recalls: Vec, + mean_elapsed: Duration, + causal_order_ok: bool, +} + +/// Run one clock over one (plateau_len, seed) session; returns +/// (recall@ORACLE_K, mean compaction elapsed time, causal-order-ok). +fn run_one(clock: &C, cfg: &ScenarioConfig) -> (f64, Duration, bool) { + let session = generate_session(cfg); + let final_context = session.contexts.last().unwrap().clone(); + let oracle = oracle_top_k(&session.memories, &final_context, ORACLE_K); + let weights = CompactionWeights::default(); + + let cum = clock.cumulative(&session.snapshots); + let causal_order_ok = is_monotone(&cum); + + let mut total = Duration::ZERO; + let mut kept: HashSet = HashSet::new(); + for _ in 0..TIMING_REPS { + let res = compact( + clock, + &session.snapshots, + &session.memories, + &final_context, + BUDGET, + weights, + ); + total += res.elapsed; + kept = res.kept; + } + ( + recall_at_k(&kept, &oracle), + total / TIMING_REPS, + causal_order_ok, + ) +} + +fn main() { + let seeds: Vec = (0..N_SEEDS) + .map(|i| SEED_BASE.wrapping_add(i.wrapping_mul(SEED_STRIDE))) + .collect(); + + println!("ruvector-structural-memory benchmark"); + println!( + "config: n_topics={N_TOPICS} dim={DIM} oracle_k={ORACLE_K} budget={BUDGET} timing_reps={TIMING_REPS} n_seeds={N_SEEDS}" + ); + println!( + "hardware: {}-{}, rustc build={}", + std::env::consts::ARCH, + std::env::consts::OS, + if cfg!(debug_assertions) { + "debug" + } else { + "release" + } + ); + println!("seeds: {seeds:?}"); + println!(); + + let plateau_lens = [20usize, 60, 150]; + let mut cells: Vec = Vec::new(); + + for &plateau_len in &plateau_lens { + let mut wall_recalls = Vec::new(); + let mut emb_recalls = Vec::new(); + let mut full_recalls = Vec::new(); + let mut wall_time = Duration::ZERO; + let mut emb_time = Duration::ZERO; + let mut full_time = Duration::ZERO; + let mut wall_causal = true; + let mut emb_causal = true; + let mut full_causal = true; + let mut total_steps = 0usize; + + for &seed in &seeds { + let cfg = ScenarioConfig { + dim: DIM, + n_topics: N_TOPICS, + plateau_len, + switch_width: 3, + context_noise: 0.001, + memory_noise: 0.08, + entropy_temp: 0.25, + seed, + }; + total_steps = cfg.n_topics * cfg.plateau_len; + + let (r, t, ok) = run_one(&WallClock, &cfg); + wall_recalls.push(r); + wall_time += t; + wall_causal &= ok; + + let emb_clock = structural_embedding_clock(); + let (r, t, ok) = run_one(&emb_clock, &cfg); + emb_recalls.push(r); + emb_time += t; + emb_causal &= ok; + + let full_clock = structural_full_clock(); + let (r, t, ok) = run_one(&full_clock, &cfg); + full_recalls.push(r); + full_time += t; + full_causal &= ok; + } + + let n = seeds.len() as u32; + cells.push(Cell { + plateau_len, + clock_name: "WallClock", + total_steps, + budget: BUDGET, + recalls: wall_recalls, + mean_elapsed: wall_time / n, + causal_order_ok: wall_causal, + }); + cells.push(Cell { + plateau_len, + clock_name: "StructuralEmbedding", + total_steps, + budget: BUDGET, + recalls: emb_recalls, + mean_elapsed: emb_time / n, + causal_order_ok: emb_causal, + }); + cells.push(Cell { + plateau_len, + clock_name: "StructuralFull", + total_steps, + budget: BUDGET, + recalls: full_recalls, + mean_elapsed: full_time / n, + causal_order_ok: full_causal, + }); + } + + println!( + "{:<12} {:<20} {:>11} {:>7} {:>16} {:>14} {:>12}", + "plateau_len", + "clock", + "total_steps", + "budget", + "recall@15(mean±sd)", + "mean_time_ns", + "causal_ok" + ); + for c in &cells { + let m = mean(&c.recalls); + let sd = stddev(&c.recalls, m); + println!( + "{:<12} {:<20} {:>11} {:>7} {:>9.4}±{:<5.4} {:>14} {:>12}", + c.plateau_len, + c.clock_name, + c.total_steps, + c.budget, + m, + sd, + c.mean_elapsed.as_nanos(), + c.causal_order_ok + ); + } + println!(); + + // ---- Acceptance evaluation (thresholds fixed before this binary's + // final multi-seed form ran) ---- + let get = |plateau_len: usize, name: &str| -> &Cell { + cells + .iter() + .find(|c| c.plateau_len == plateau_len && c.clock_name == name) + .unwrap() + }; + + let long_wall = get(150, "WallClock"); + let long_struct = get(150, "StructuralEmbedding"); + let short_wall = get(20, "WallClock"); + let short_struct = get(20, "StructuralEmbedding"); + + let long_lead_pp = (mean(&long_struct.recalls) - mean(&long_wall.recalls)) * 100.0; + let short_delta_pp = (mean(&short_struct.recalls) - mean(&short_wall.recalls)) * 100.0; + + let mut wall_time_total = Duration::ZERO; + let mut struct_time_total = Duration::ZERO; + for &plateau_len in &plateau_lens { + wall_time_total += get(plateau_len, "WallClock").mean_elapsed; + struct_time_total += get(plateau_len, "StructuralEmbedding").mean_elapsed; + } + let overhead_ratio = struct_time_total.as_secs_f64() / wall_time_total.as_secs_f64().max(1e-12); + + let causal_ok = cells.iter().all(|c| c.causal_order_ok); + + let clause_a = long_lead_pp >= LONG_LEAD_THRESHOLD_PP; + let clause_b = short_delta_pp >= -SHORT_REGRESSION_TOLERANCE_PP; + let clause_c = overhead_ratio <= MAX_OVERHEAD_RATIO; + let clause_d = causal_ok; + + println!("acceptance clauses (thresholds fixed before this run; means over {N_SEEDS} seeds):"); + println!( + " (a) mean long-plateau lead >= {LONG_LEAD_THRESHOLD_PP}pp: measured {long_lead_pp:.2}pp -> {}", + if clause_a { "PASS" } else { "FAIL" } + ); + println!( + " (b) mean short-plateau regression <= {SHORT_REGRESSION_TOLERANCE_PP}pp: measured {short_delta_pp:.2}pp delta -> {}", + if clause_b { "PASS" } else { "FAIL" } + ); + println!( + " (c) compute overhead ratio <= {MAX_OVERHEAD_RATIO}x: measured {overhead_ratio:.2}x -> {}", + if clause_c { "PASS" } else { "FAIL" } + ); + println!( + " (d) causal order preserved for every clock/config/seed: -> {}", + if clause_d { "PASS" } else { "FAIL" } + ); + + let accept = clause_a && clause_b && clause_c && clause_d; + println!(); + println!( + "ACCEPTANCE RESULT: {}", + if accept { "ACCEPT" } else { "REJECT" } + ); + + // Per-seed detail for the long-plateau cell, since that is the clause + // that determines the result: shows whether the effect is consistent + // across seeds or seed-dependent. + println!(); + println!("per-seed detail, plateau_len=150 (the deciding cell):"); + println!(" seed WallClock StructuralEmbedding StructuralFull"); + for (i, &seed) in seeds.iter().enumerate() { + println!( + " {seed:#018x} {:>9.4} {:>19.4} {:>14.4}", + long_wall.recalls[i], + long_struct.recalls[i], + get(150, "StructuralFull").recalls[i] + ); + } + + // Exploratory: does adding the entropy channel (StructuralFull) help + // beyond the pure embedding-arc clock? Reported, not gating. + println!(); + println!("exploratory (not gating): StructuralFull vs StructuralEmbedding mean recall delta"); + for &plateau_len in &plateau_lens { + let full = get(plateau_len, "StructuralFull"); + let emb = get(plateau_len, "StructuralEmbedding"); + println!( + " plateau_len={plateau_len}: StructuralFull={:.4} StructuralEmbedding={:.4} delta={:.4}pp", + mean(&full.recalls), + mean(&emb.recalls), + (mean(&full.recalls) - mean(&emb.recalls)) * 100.0 + ); + } +} diff --git a/crates/ruvector-structural-memory/src/scenario.rs b/crates/ruvector-structural-memory/src/scenario.rs new file mode 100644 index 0000000000..667e59d2d4 --- /dev/null +++ b/crates/ruvector-structural-memory/src/scenario.rs @@ -0,0 +1,266 @@ +//! Deterministic synthetic agent session: a sequence of topic "plateaus" +//! (long stretches where the context barely moves) separated by short, +//! sharp topic-switch transitions. One memory is written per step, embedded +//! near that step's context. + +use emergent_time::entropy::entropy_from_spectrum; +use emergent_time::StateSnapshot; + +/// Deterministic xorshift64* PRNG (no external RNG dependency), mirroring the +/// private `Rng` already used in `emergent_time::structural_clock`'s own test +/// scenario generator. +pub struct Rng(u64); + +impl Rng { + pub fn new(seed: u64) -> Self { + Rng(seed | 1) + } + + /// Next value in `[-1, 1)`. + pub fn next_f64(&mut self) -> f64 { + let mut x = self.0; + x ^= x >> 12; + x ^= x << 25; + x ^= x >> 27; + self.0 = x; + let v = x.wrapping_mul(0x2545_F491_4F6C_DD1D); + ((v >> 11) as f64 / (1u64 << 53) as f64) * 2.0 - 1.0 + } + + pub fn next_vec(&mut self, dim: usize) -> Vec { + (0..dim).map(|_| self.next_f64()).collect() + } +} + +pub fn cosine(a: &[f64], b: &[f64]) -> f64 { + let dot: f64 = a.iter().zip(b).map(|(x, y)| x * y).sum(); + let na = a.iter().map(|x| x * x).sum::().sqrt(); + let nb = b.iter().map(|x| x * x).sum::().sqrt(); + if na < 1e-12 || nb < 1e-12 { + 0.0 + } else { + (dot / (na * nb)).clamp(-1.0, 1.0) + } +} + +fn normalize(v: &mut [f64]) { + let n = v.iter().map(|x| x * x).sum::().sqrt(); + if n > 1e-12 { + for x in v.iter_mut() { + *x /= n; + } + } +} + +fn lerp_vec(a: &[f64], b: &[f64], t: f64) -> Vec { + a.iter().zip(b).map(|(x, y)| x + t * (y - x)).collect() +} + +fn softmax(xs: &[f64], temp: f64) -> Vec { + let m = xs.iter().cloned().fold(f64::NEG_INFINITY, f64::max); + let exps: Vec = xs.iter().map(|x| ((x - m) / temp).exp()).collect(); + let s: f64 = exps.iter().sum(); + exps.iter().map(|e| e / s).collect() +} + +#[derive(Clone, Copy, Debug)] +pub struct ScenarioConfig { + pub dim: usize, + pub n_topics: usize, + /// Steps spent on each topic before the next switch. + pub plateau_len: usize, + /// Steps over which a topic switch is ramped (linear interpolation). + pub switch_width: usize, + pub context_noise: f64, + pub memory_noise: f64, + /// Softmax temperature for the entropy channel. + pub entropy_temp: f64, + pub seed: u64, +} + +impl Default for ScenarioConfig { + fn default() -> Self { + ScenarioConfig { + dim: 32, + n_topics: 4, + plateau_len: 60, + switch_width: 3, + // Small relative to a topic-switch jump (~sqrt(2) between two + // near-orthogonal unit centroids at dim=32) so a quiet plateau's + // accumulated embedding movement stays well below one switch's, + // even summed over a long (150-step) plateau. This is what makes + // the structural clock actually behave differently from a + // reparametrized wall clock — see crate docs. + context_noise: 0.001, + memory_noise: 0.08, + entropy_temp: 0.25, + seed: 0xC0FFEE, + } + } +} + +#[derive(Clone, Debug)] +pub struct MemoryItem { + pub id: usize, + pub embedding: Vec, + pub write_step: usize, + pub topic: usize, +} + +#[derive(Clone, Debug)] +pub struct Session { + pub contexts: Vec>, + pub topics: Vec>, + pub memories: Vec, + pub snapshots: Vec, + pub topic_of_step: Vec, +} + +impl Session { + pub fn total_steps(&self) -> usize { + self.contexts.len() + } +} + +/// Build one deterministic session from `cfg`. Topic centroids are random +/// unit vectors (no explicit separation construction: at `dim >= 16` random +/// vectors are already near-orthogonal in expectation). Topics are visited in +/// a fixed order `0, 1, ..., n_topics-1`, each held for `plateau_len` steps. +pub fn generate_session(cfg: &ScenarioConfig) -> Session { + let mut rng = Rng::new(cfg.seed); + let topics: Vec> = (0..cfg.n_topics) + .map(|_| { + let mut v = rng.next_vec(cfg.dim); + normalize(&mut v); + v + }) + .collect(); + + let total_steps = cfg.n_topics * cfg.plateau_len; + let mut contexts = Vec::with_capacity(total_steps); + let mut topic_of_step = Vec::with_capacity(total_steps); + + for i in 0..total_steps { + let b = (i / cfg.plateau_len).min(cfg.n_topics - 1); + let lp = i % cfg.plateau_len; + let target = if b == 0 || lp >= cfg.switch_width { + topics[b].clone() + } else { + let frac = (lp + 1) as f64 / cfg.switch_width as f64; + lerp_vec(&topics[b - 1], &topics[b], frac) + }; + let noise = rng.next_vec(cfg.dim); + let embedding: Vec = target + .iter() + .zip(&noise) + .map(|(t, n)| t + cfg.context_noise * n) + .collect(); + contexts.push(embedding); + topic_of_step.push(b); + } + + let memories: Vec = (0..total_steps) + .map(|i| { + let noise = rng.next_vec(cfg.dim); + let embedding: Vec = contexts[i] + .iter() + .zip(&noise) + .map(|(c, n)| c + cfg.memory_noise * n) + .collect(); + MemoryItem { + id: i, + embedding, + write_step: i, + topic: topic_of_step[i], + } + }) + .collect(); + + let snapshots = build_snapshots(&contexts, &topics, cfg.entropy_temp); + + Session { + contexts, + topics, + memories, + snapshots, + topic_of_step, + } +} + +/// Derive each step's `StateSnapshot`: `embedding` is the raw context vector +/// (`Δv` channel); `entropy` is the Shannon entropy in nats of the softmax +/// over cosine similarities from the context to every topic centroid (`ΔS` +/// channel) — high when the context sits between topics (a switch), low when +/// it sits close to a single topic (mid-plateau). This is a genuine derived +/// quantity from the actual trajectory (analogous to a topic classifier's +/// confidence), not a fabricated curve. `coherence`/`graph`/`pred_error` are +/// left at `0.0`: every clock instantiated in this crate weights those +/// channels at zero, so their value is inert here — no honest signal for them +/// exists in this harness (see crate docs). +pub fn build_snapshots( + contexts: &[Vec], + topics: &[Vec], + entropy_temp: f64, +) -> Vec { + contexts + .iter() + .map(|c| { + let sims: Vec = topics.iter().map(|t| cosine(c, t)).collect(); + let probs = softmax(&sims, entropy_temp); + let entropy = entropy_from_spectrum(&probs); + StateSnapshot::new(c.clone(), entropy, 0.0) + }) + .collect() +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn topics_are_unit_length() { + let cfg = ScenarioConfig::default(); + let session = generate_session(&cfg); + for t in &session.topics { + let n: f64 = t.iter().map(|x| x * x).sum::().sqrt(); + assert!((n - 1.0).abs() < 1e-9, "topic norm {n}"); + } + } + + #[test] + fn session_has_one_memory_per_step() { + let cfg = ScenarioConfig::default(); + let session = generate_session(&cfg); + assert_eq!(session.memories.len(), session.total_steps()); + assert_eq!(session.total_steps(), cfg.n_topics * cfg.plateau_len); + } + + #[test] + fn entropy_spikes_at_switch_and_settles_mid_plateau() { + // At a topic switch, the context sits between two topic centroids so + // similarity is split -> higher entropy. Mid-plateau it is close to + // one centroid -> lower entropy. This is the discriminating property + // the entropy channel is supposed to have; if it didn't hold, using + // it as a `ΔS` signal would be pointless. + let cfg = ScenarioConfig { + plateau_len: 40, + switch_width: 3, + ..ScenarioConfig::default() + }; + let session = generate_session(&cfg); + let switch_step = cfg.plateau_len + 1; // inside the first switch ramp + let mid_plateau_step = cfg.plateau_len + 20; // deep into topic 1's plateau + assert!( + session.snapshots[switch_step].entropy > session.snapshots[mid_plateau_step].entropy, + "switch entropy {} should exceed mid-plateau entropy {}", + session.snapshots[switch_step].entropy, + session.snapshots[mid_plateau_step].entropy + ); + } + + #[test] + fn cosine_identical_is_one() { + let v = vec![1.0, 2.0, 3.0]; + assert!((cosine(&v, &v) - 1.0).abs() < 1e-9); + } +} From 22eec751802ea7807b2224ef0a41c8bb592a9318 Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 24 Aug 2026 07:36:39 +0000 Subject: [PATCH 2/3] =?UTF-8?q?docs(adr):=20ADR-340=20=E2=80=94=20structur?= =?UTF-8?q?al-time=20memory=20decay,=20evaluated=20and=20rejected?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Records the nightly's REJECT outcome: a 10-seed averaged benchmark shows StructuralProperTime-based compaction retention never regresses recall vs wall-clock, but its mean long-plateau lead (2.00pp) misses the pre-registered 5pp acceptance bar. Not promoted to ruvector-agent-memory. Co-Authored-By: claude-flow Claude-Session: https://claude.ai/code/session_01TdYyZd166DoTxb5R4FWuJc --- .../ADR-340-structural-time-memory-decay.md | 215 ++++++ docs/adr/INDEX.md | 703 +++++++++--------- 2 files changed, 567 insertions(+), 351 deletions(-) create mode 100644 docs/adr/ADR-340-structural-time-memory-decay.md diff --git a/docs/adr/ADR-340-structural-time-memory-decay.md b/docs/adr/ADR-340-structural-time-memory-decay.md new file mode 100644 index 0000000000..390ad4fcaa --- /dev/null +++ b/docs/adr/ADR-340-structural-time-memory-decay.md @@ -0,0 +1,215 @@ +# ADR-340: Structural-Time Memory Decay — Evaluated, Not Promoted + +## Status + +**Rejected** (of the pre-registered acceptance threshold). Experimental +crate `crates/ruvector-structural-memory` retained in the workspace as +evidence and as a reusable benchmark harness; not wired into +`ruvector-agent-memory` or any production compaction path. + +## Context + +`ruvector-agent-memory` (nightly 2026-06-14) scores stored-memory retention +using, among other signals, a wall-clock recency term: a memory's +"freshness" decays as a function of turns/steps elapsed since it was written +or last accessed. `emergent-time` (ADR-251) is a mature, already-merged +crate implementing several internal-time formalisms, including +`StructuralProperTime` — internal time defined as accumulated, +metric-weighted arc length through a system's own state manifold, rather +than external step count. As of this ADR, `StructuralProperTime` had only +been benchmarked on generic anomaly-early-warning and trajectory-compression +tasks (its own module's test suite); it had not been applied to agent memory +retention scoring, despite memory decay being an obvious candidate use case +(the whole point of the formalism is distinguishing "much wall-clock time +passed" from "much actually changed"). + +This ADR records the outcome of testing that specific application. + +## Hypothesis + +```text +Given synthetic agent sessions of 4 topic plateaus separated by sharp +switches (plateau lengths 20, 60, or 150 steps; one memory written per +step, embedding dim 32), + +when compaction retention score uses StructuralEmbeddingClock's +accumulated context drift (emergent_time::StructuralProperTime, embedding +channel only) instead of WallClock step count as the age signal, + +then mean recall@15 of the oracle nearest-neighbour set — averaged over 10 +independent seeds — after compacting to a fixed budget of 25 memories +improves by >= 5 percentage points in the long-plateau (150 steps/topic) +configuration, without regressing by more than 2 percentage points in the +short-plateau (20 steps/topic) configuration, + +subject to compaction compute time staying within 5x WallClock's, and +causal order being preserved by every clock on every seed. +``` + +## Decision + +**Do not promote structural-time decay to `ruvector-agent-memory` or any +production path at this time.** The mandatory acceptance clause on +long-plateau recall lead (measured +2.00pp against a fixed +5.00pp bar, +averaged over 10 non-cherry-picked seeds) failed. Retain +`crates/ruvector-structural-memory` in the workspace: its benchmark harness +(deterministic multi-seed scenario generator, oracle-recall methodology, +compute-overhead measurement) is directly reusable for a follow-up attempt +with a revised scenario (see Consequences), and the negative result itself +is evidence future nightlies should not blindly rediscover by re-testing the +same configuration. + +## Evidence + +10-seed mean recall@15 after compaction to a fixed 25-memory budget (full +raw benchmark output in the nightly README): + +| plateau_len | WallClock | StructuralEmbedding | StructuralFull | lead (pp) | +|---|---|---|---|---| +| 20 | 1.0000 ± 0.0000 | 1.0000 ± 0.0000 | 1.0000 ± 0.0000 | 0.00 | +| 60 | 0.3867 ± 0.1147 | 0.4000 ± 0.1075 | 0.4133 ± 0.1024 | 1.33 | +| 150 | 0.1600 ± 0.0442 | 0.1800 ± 0.0600 | 0.1800 ± 0.0600 | 2.00 | + +Compute overhead: `StructuralEmbedding` compaction took 1.30x `WallClock`'s +wall-clock time, summed across all three plateau-length configurations +(well under the 5x acceptance bound). + +Per-seed detail at the deciding (150) configuration: 3/10 seeds show +`StructuralEmbedding` beating `WallClock` by exactly +6.67pp; 7/10 tie +exactly; 0/10 show a regression. See the nightly README's +[Why the Effect Is Real But Small](../research/nightly/2026-08-24-structural-time-memory-decay/README.md#why-the-effect-is-real-but-small) +section for the mechanism this pattern is consistent with. + +Acceptance clauses: + +| Clause | Threshold | Measured | Result | +|---|---|---|---| +| (a) long-plateau mean lead | ≥ 5.00pp | 2.00pp | **FAIL** | +| (b) short-plateau mean regression | ≥ -2.00pp | 0.00pp | PASS | +| (c) compute overhead ratio | ≤ 5.00x | 1.30x | PASS | +| (d) causal order preserved | all cells | all cells | PASS | + +Reproducible via `cargo run --release -p ruvector-structural-memory --bin +benchmark`; deterministic given the fixed seed-generation formula +(`0xC0FFEE + i * 0x9E3779B9`). + +## Consequences + +**What this ADR does NOT claim:** that `StructuralProperTime` is unsuitable +for agent memory decay in general. The measured effect is directionally +consistent (never a regression across 30 seed×plateau_len cells) but too +small and too seed-dependent, at this specific scenario configuration, to +clear the bar set before benchmarking. Two concrete, unexplored variables +could change that: (1) the ratio of within-plateau embedding noise to +topic-switch jump size was fixed at one value (≈1:700 over the longest +plateau) rather than swept — a real embedding source might sit at a +materially different point on that ratio; (2) `StructuralFull`'s entropy +channel added no benefit here, but its `ΔC`/`ΔG` channels were left +unweighted for lack of an honest signal source in this synthetic harness — +a real coherence signal (e.g. from `ruvector-coherence`) is untested. + +**What does NOT become stable API:** nothing. No public interface in +`ruvector-agent-memory` changes. `ruvector-structural-memory`'s own types +(`ScenarioConfig`, `MemoryItem`, `Session`, `CompactionWeights`) are +research-tier and may change freely in a follow-up. + +**What remains experimental:** the entire `ruvector-structural-memory` +crate, including its benchmark methodology, which is the actual reusable +asset from this nightly. + +## Alternatives Considered + +1. **Fractional compaction budget** (30% of corpus size) — tried first; + made the experiment trivial (recall@15 = 1.0000 for every clock, + uninformative) because the budget always comfortably contained an entire + topic's memory pool. Rejected as a methodology bug, not as a result. +2. **Single-seed evaluation** — the first fixed-budget run (seed + `0xC0FFEE`) showed a comfortable +6.67pp lead that would, reported alone, + have read as an unambiguous ACCEPT. Rejected per this repository's + explicit prohibition on cherry-picked seeds; replaced with the 10-seed + mean gating this ADR's decision. +3. **Lowering the acceptance threshold post-hoc** to convert the 2.00pp + measured lead into a pass — not done. The 5pp bar was fixed alongside the + budget and noise parameters before the first benchmark run and is + reported as failed, per this repository's rule against weakening + acceptance criteria to force a pass. + +## Implementation Plan + +None at this time — no production change is being made. A follow-up +implementation plan, contingent on a future ACCEPT, would extend +`ruvector-agent-memory`'s existing scoring path with a `Clock` type +parameter defaulting to today's wall-clock behavior (additive, not +breaking). + +## API Shape + +N/A — `ruvector-structural-memory` is a standalone research crate with no +production consumer. Its public surface (`clocks`, `scenario`, `compaction` +modules) is documented in `src/lib.rs` and may change without a deprecation +cycle. + +## Feature Flags + +None. No production crate depends on this one. + +## Benchmark Evidence + +See [Evidence](#evidence) above and the full raw output in +`docs/research/nightly/2026-08-24-structural-time-memory-decay/README.md`. + +## Security + +No new attack surface introduced (synthetic, in-process, no I/O). The +security-relevant risk for a *future* production integration — an agent or +injected tool result that keeps its reported context embedding artificially +static to make a structural clock under-forget stale/compromised memories — +is identified but out of scope for this synthetic benchmark; flagged as a +required precondition for any future promotion. + +## Governance + +REJECT outcomes are retained, not deleted, per this repository's nightly +research process: the crate, its tests, and this ADR stand as the record +that this specific configuration was tried and did not clear its +pre-registered bar, so a future nightly does not have to rediscover that +independently. + +## Failure Modes + +See the nightly README's +[Failure Modes](../research/nightly/2026-08-24-structural-time-memory-decay/README.md#failure-modes-and-things-that-almost-made-this-look-better-than-it-is) +section for the three methodology issues found and fixed during this +nightly (trivial fractional budget, noise-scale collapse, single-seed +cherry-picking risk) before the final result was gated. + +## Migration + +N/A — no production code changes. + +## Rollback + +N/A — nothing was promoted to roll back. Reverting this ADR means removing +`crates/ruvector-structural-memory` from the workspace; not recommended, as +the benchmark harness is reusable evidence for the follow-up work listed +below. + +## Rejection Criteria + +Already applied: this ADR's own hypothesis was rejected by its own +pre-registered clause (a). Documented here rather than silently discarded, +per this repository's rule that a falsified hypothesis with good evidence is +a valid nightly outcome. + +## Open Questions + +1. Does a real (non-synthetic) embedding source sit at a noise-to-drift + ratio where the effect reliably clears 5pp, or is 2pp closer to the + mechanism's true ceiling? +2. Would wiring a genuine coherence signal (`ruvector-coherence`) into + `StructuralFull`'s `ΔC` channel — untested here — change the exploratory + comparison's null result? +3. Is a fixed-budget compaction regime (used here to force within-topic + competition) representative of how `ruvector-agent-memory` actually + triggers compaction in production, or does that differ enough to warrant + a different benchmark design entirely? diff --git a/docs/adr/INDEX.md b/docs/adr/INDEX.md index d9d2fdf623..5cc305fd8b 100644 --- a/docs/adr/INDEX.md +++ b/docs/adr/INDEX.md @@ -1,6 +1,6 @@ # ADR Index -**Next available ADR number: 340** +**Next available ADR number: 341** > Generated by `node scripts/adr-index.mjs` — do not edit by hand. > This file is the canonical allocation counter for new ADR numbers @@ -8,313 +8,313 @@ > historical artifacts and are cited as `ADR-NNN (slug)`. > CI gate: `node scripts/adr-index.mjs --check`. -- ADR files indexed: **370** (323 on the canonical counter, 47 in namespaced families) -- Highest allocated number: **ADR-339** +- ADR files indexed: **371** (324 on the canonical counter, 47 in namespaced families) +- Highest allocated number: **ADR-340** - 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-07-27 | Proposed | | -| ADR-002 | ADR-002: RuvLLM Integration with Ruvector | [`ADR-002-ruvllm-integration.md`](./ADR-002-ruvllm-integration.md) | 2026-07-27 | 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-07-27 | ✅ 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-07-27 | Proposed | | -| ADR-005 | ADR-005: WASM Runtime Integration | [`ADR-005-wasm-runtime-integration.md`](./ADR-005-wasm-runtime-integration.md) | 2026-07-27 | | | -| ADR-006 | ADR-006: Unified Memory Pool and Paging Strategy | [`ADR-006-memory-management.md`](./ADR-006-memory-management.md) | 2026-07-27 | | | -| ADR-007 | ADR-007: Security Review & Technical Debt Remediation | [`ADR-007-security-review-technical-debt.md`](./ADR-007-security-review-technical-debt.md) | 2026-07-27 | 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-07-27 | Proposed | | -| ADR-009 | ADR-009: Structured Output / JSON Mode for Reliable Agentic Workflows | [`ADR-009-structured-output.md`](./ADR-009-structured-output.md) | 2026-07-27 | Proposed | | -| ADR-010 | ADR-010: Function Calling / Tool Use in RuvLLM | [`ADR-010-function-calling.md`](./ADR-010-function-calling.md) | 2026-07-27 | 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-07-27 | Proposed | | -| ADR-012 | ADR-012: Security Remediation and Hardening | [`ADR-012-security-remediation.md`](./ADR-012-security-remediation.md) | 2026-07-27 | Accepted | | -| ADR-013 | ADR-013: HuggingFace Model Publishing Strategy | [`ADR-013-huggingface-publishing.md`](./ADR-013-huggingface-publishing.md) | 2026-07-27 | **Accepted** - 2026-01-20 | | -| ADR-014 | ADR-014: Coherence Engine Architecture | [`ADR-014-coherence-engine.md`](./ADR-014-coherence-engine.md) | 2026-07-27 | Proposed | | -| ADR-015 | ADR-015: Coherence-Gated Transformer (Sheaf Attention) | [`ADR-015-coherence-gated-transformer.md`](./ADR-015-coherence-gated-transformer.md) | 2026-07-27 | 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-07-27 | Proposed | | -| ADR-017 | ADR-017: Temporal Tensor Compression with Tiered Quantization | [`ADR-017-temporal-tensor-compression.md`](./ADR-017-temporal-tensor-compression.md) | 2026-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | | | -| 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-07-27 | **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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | Implemented | | -| ADR-035 | ADR-035: Capability Report — Witness Bundles, Scorecards, and Governance | [`ADR-035-capability-report.md`](./ADR-035-capability-report.md) | 2026-07-27 | 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-07-27 | 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-07-27 | | | -| 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-07-27 | | | -| 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-07-27 | | | -| 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-07-27 | Proposed | | -| ADR-040a | ADR-040a: Causal Atlas Dashboard Specification | [`ADR-040a-planet-detection-dashboard.md`](./ADR-040a-planet-detection-dashboard.md) | 2026-07-27 | 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-07-27 | 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-07-27 | | | -| ADR-043 | ADR-043: External Intelligence Providers for SONA Learning | [`ADR-043-external-intelligence-providers.md`](./ADR-043-external-intelligence-providers.md) | 2026-07-27 | | | -| 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-07-27 | 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-07-27 | Proposed | | -| ADR-046 | ADR-046: Graph Transformer Unified Architecture | [`ADR-046-graph-transformer-architecture.md`](./ADR-046-graph-transformer-architecture.md) | 2026-07-27 | Accepted | | -| ADR-047 | ADR-047: Proof-Gated Mutation Protocol | [`ADR-047-proof-gated-mutation-protocol.md`](./ADR-047-proof-gated-mutation-protocol.md) | 2026-07-27 | Accepted | | -| ADR-048 | ADR-048: Sublinear Graph Attention | [`ADR-048-sublinear-graph-attention.md`](./ADR-048-sublinear-graph-attention.md) | 2026-07-27 | Accepted | | -| ADR-049 | ADR-049: Verified Training Pipeline | [`ADR-049-verified-training-pipeline.md`](./ADR-049-verified-training-pipeline.md) | 2026-07-27 | 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-07-27 | 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-07-27 | Accepted | | -| ADR-052 | ADR-052: Biological Graph Transformer Layers | [`ADR-052-biological-graph-layers.md`](./ADR-052-biological-graph-layers.md) | 2026-07-27 | 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-07-27 | Accepted | | -| ADR-054 | ADR-054: Economic Graph Transformer Layers | [`ADR-054-economic-graph-layers.md`](./ADR-054-economic-graph-layers.md) | 2026-07-27 | Accepted | | -| ADR-055 | ADR-055: Manifold-Aware Graph Transformer Layers | [`ADR-055-manifold-graph-layers.md`](./ADR-055-manifold-graph-layers.md) | 2026-07-27 | Accepted | | -| ADR-056 | ADR-056: RVF Knowledge Export for Developer Onboarding | [`ADR-056-rvf-knowledge-export.md`](./ADR-056-rvf-knowledge-export.md) | 2026-07-27 | 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-07-27 | Proposed | | -| ADR-058 | ADR-058: RVF Hash Security Hardening and Optimization | [`ADR-058-hash-security-optimization.md`](./ADR-058-hash-security-optimization.md) | 2026-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | Accepted | | -| ADR-062 | ADR-062: Brainpedia — Structured Knowledge Encyclopedia with Delta-Based Editing | [`ADR-062-brainpedia-architecture.md`](./ADR-062-brainpedia-architecture.md) | 2026-07-27 | 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-07-27 | Accepted | | -| ADR-064 | ADR-064: Pi Brain Infrastructure & Landing Page | [`ADR-064-pi-brain-infrastructure.md`](./ADR-064-pi-brain-infrastructure.md) | 2026-07-27 | Accepted, Deployed | | -| ADR-065 | ADR-065: npm Publishing Strategy | [`ADR-065-npm-publishing-strategy.md`](./ADR-065-npm-publishing-strategy.md) | 2026-07-27 | Accepted | | -| ADR-066 | ADR-066: SSE MCP Transport | [`ADR-066-sse-mcp-transport.md`](./ADR-066-sse-mcp-transport.md) | 2026-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | Proposed | | -| ADR-070 | ADR-070: npx ruvector Unified Integration | [`ADR-070-npx-ruvector-unified-integration.md`](./ADR-070-npx-ruvector-unified-integration.md) | 2026-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | Accepted | | -| ADR-074 | ADR-074: RuvLLM Neural Embedding Integration | [`ADR-074-ruvllm-neural-embeddings.md`](./ADR-074-ruvllm-neural-embeddings.md) | 2026-07-27 | 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-07-27 | Implemented | | -| ADR-076 | ADR-076: AGI Capability Wiring Architecture | [`ADR-076-agi-capability-wiring-architecture.md`](./ADR-076-agi-capability-wiring-architecture.md) | 2026-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | Accepted | | -| ADR-084 | ADR-084: ruvllm-wasm — First Functional npm Publish | [`ADR-084-ruvllm-wasm-publish.md`](./ADR-084-ruvllm-wasm-publish.md) | 2026-07-27 | 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-07-27 | Proposed | | -| ADR-086 | ADR-086: Neural Trader WASM Bindings | [`ADR-086-neural-trader-wasm.md`](./ADR-086-neural-trader-wasm.md) | 2026-07-27 | 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-07-27 | **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-07-27 | **Proposed** | | -| ADR-089 | ADR-089: CNN Browser Demo for GitHub Pages | [`ADR-089-cnn-browser-demo.md`](./ADR-089-cnn-browser-demo.md) | 2026-07-27 | Accepted | | -| ADR-090 | ADR-090 Implementation Checklist: Ultra-Low-Bit QAT & Pi-Quantization | [`ADR-090-implementation-checklist.md`](./ADR-090-implementation-checklist.md) | 2026-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | | 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-07-27 | | 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-07-27 | 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-07-27 | | 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-07-27 | 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-07-27 | 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-07-27 | | 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-07-27 | | | -| ADR-098 | ADR-098: Memory, Skills & Summarization Middleware | [`ADR-098-deepagents-memory-skills-summarization.md`](./ADR-098-deepagents-memory-skills-summarization.md) | 2026-07-27 | | | -| ADR-099 | ADR-099: CLI & ACP Server Conversion | [`ADR-099-deepagents-cli-acp-server.md`](./ADR-099-deepagents-cli-acp-server.md) | 2026-07-27 | | | -| 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-07-27 | | | -| ADR-101 | ADR-101: Testing Strategy & Fidelity Verification | [`ADR-101-deepagents-testing-strategy.md`](./ADR-101-deepagents-testing-strategy.md) | 2026-07-27 | | | -| ADR-102 | ADR-102: Implementation Roadmap & Phasing | [`ADR-102-deepagents-implementation-roadmap.md`](./ADR-102-deepagents-implementation-roadmap.md) | 2026-07-27 | | | -| ADR-103 | ADR-103: Review Amendments — Performance, RVF Integration & Security Hardening | [`ADR-103-deepagents-review-amendments.md`](./ADR-103-deepagents-review-amendments.md) | 2026-07-27 | | | -| 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-07-27 | | | -| 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-07-27 | | | -| ADR-106 | ADR-106: RuVix Kernel Integration with RVF | [`ADR-106-ruvix-kernel-rvf-integration.md`](./ADR-106-ruvix-kernel-rvf-integration.md) | 2026-07-27 | | | -| 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-07-27 | | | -| ADR-108 | ADR-108: rvAgent–ruvbot Integration Architecture | [`ADR-108-rvagent-ruvbot-integration.md`](./ADR-108-rvagent-ruvbot-integration.md) | 2026-07-27 | | | -| ADR-109 | ADR-109: Backup and Disaster Recovery Strategy | [`ADR-109-backup-disaster-recovery.md`](./ADR-109-backup-disaster-recovery.md) | 2026-07-27 | 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-07-27 | 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-07-27 | | | -| 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-07-27 | | | -| 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-07-27 | | | -| ADR-114 | ADR-114: Ruvector-Core Hash Placeholder Embeddings | [`ADR-114-ruvector-core-hash-placeholders.md`](./ADR-114-ruvector-core-hash-placeholders.md) | 2026-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | Approved with Revisions | | -| ADR-123 | ADR-123: Pi Brain Cognitive Enrichment | [`ADR-123-brain-cognitive-enrichment.md`](./ADR-123-brain-cognitive-enrichment.md) | 2026-07-27 | Accepted | | -| ADR-124 | ADR-124: Dynamic MinCut with Partition Cache | [`ADR-124-dynamic-partition-cache.md`](./ADR-124-dynamic-partition-cache.md) | 2026-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | **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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | Accepted | | -| ADR-146 | ADR-144: DiskANN/Vamana Implementation | [`ADR-146-diskann-vamana-implementation.md`](./ADR-146-diskann-vamana-implementation.md) | 2026-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | **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-07-27 | **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-07-27 | **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-07-27 | **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-07-27 | **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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | Accepted | | -| ADR-170 | ADR-170 — Tracing correlation | [`ADR-170-ruvector-hailo-cluster-tracing-correlation.md`](./ADR-170-ruvector-hailo-cluster-tracing-correlation.md) | 2026-07-27 | 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-07-27 | Proposed | | -| ADR-172 | ADR-172 — Deep security review | [`ADR-172-ruvector-hailo-security-review.md`](./ADR-172-ruvector-hailo-security-review.md) | 2026-07-27 | 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-07-27 | Proposed | | -| ADR-174 | ADR-174 — ruOS thermal optimizer | [`ADR-174-ruos-thermal-overclock-pi5.md`](./ADR-174-ruos-thermal-overclock-pi5.md) | 2026-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | accepted | | -| ADR-194 | ADR-194 — GNN-Enhanced Candidate Reranking for Approximate ANN | [`ADR-194-gnn-rerank.md`](./ADR-194-gnn-rerank.md) | 2026-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | proposed | | -| ADR-196 | ADR-196 — Structure-Preserving Graph Condensation | [`ADR-196-structure-preserving-graph-condensation.md`](./ADR-196-structure-preserving-graph-condensation.md) | 2026-07-27 | 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-07-27 | accepted | | -| ADR-198 | ADR-198 — Physical Perception Substrate | [`ADR-198-physical-perception-substrate.md`](./ADR-198-physical-perception-substrate.md) | 2026-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | accepted | | -| ADR-251 | ADR-251: Agentic Time as a First-Class Runtime Primitive | [`ADR-251-agentic-time.md`](./ADR-251-agentic-time.md) | 2026-07-27 | proposed | | -| ADR-252 | ADR-252: Coherence-Weighted Agent Memory Compaction | [`ADR-252-agent-memory-compaction.md`](./ADR-252-agent-memory-compaction.md) | 2026-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | proposed | | -| ADR-254 | ADR-254 — Coherence-Gated HNSW Search | [`ADR-254-coherence-hnsw-search.md`](./ADR-254-coherence-hnsw-search.md) | 2026-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-19 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | Proposed | | -| ADR-263 | ADR-263 — PhotonLayer FiberGate | [`ADR-263-photonlayer-fibergate-transmission-matrix.md`](./ADR-263-photonlayer-fibergate-transmission-matrix.md) | 2026-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | Accepted | | -| ADR-268 | ADR-268: Capability-Gated ANN Search | [`ADR-268-capability-gated-ann.md`](./ADR-268-capability-gated-ann.md) | 2026-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-02 | 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-02 | 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-02 | 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-02 | 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-02 | 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-02 | 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-02 | 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-03 | 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-03 | 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-03 | 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-04 | 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-04 | 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-04 | 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-04 | 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-04 | 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-04 | 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-04 | 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-04 | 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-04 | Implemented | | -| ADR-292 | ADR-292: Native Acceleration Isolation | [`ADR-292-native-acceleration-isolation.md`](./ADR-292-native-acceleration-isolation.md) | 2026-08-04 | 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-04 | 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-04 | 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-04 | 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-06 | 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-06 | 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-12 | 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-12 | Proposed | | -| ADR-301 | ADR-301: Semantic Query Cache for ANN | [`ADR-301-semantic-query-cache.md`](./ADR-301-semantic-query-cache.md) | 2026-08-12 | Proposed | | -| ADR-302 | ADR-302: Streaming Quantized Neighbourhood Graphs (QNG-Stream) | [`ADR-302-streaming-qng.md`](./ADR-302-streaming-qng.md) | 2026-08-12 | 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-13 | 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-13 | 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-19 | 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-19 | 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-19 | 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-19 | 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-19 | 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-19 | 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-19 | 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-19 | 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-19 | 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-19 | 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-19 | 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-19 | Proposed | | +| 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 | | @@ -337,50 +337,51 @@ | 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-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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | 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-07-27 | Accepted | | +| ADR-340 | ADR-340: Structural-Time Memory Decay — Evaluated, Not Promoted | [`ADR-340-structural-time-memory-decay.md`](./ADR-340-structural-time-memory-decay.md) | | **Rejected** (of the pre-registered acceptance threshold). Experimental | | +| 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 | | From d1c89a92175f41f7fd3c213a5e963dac6762e935 Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 24 Aug 2026 07:36:43 +0000 Subject: [PATCH 3/3] =?UTF-8?q?docs(research):=20nightly=202026-08-24=20?= =?UTF-8?q?=E2=80=94=20structural-time=20memory=20decay?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Full research report and standalone gist for the structural-time agent memory compaction experiment: hypothesis, architecture, raw benchmark output (10 seeds, 3 plateau lengths, 3 clocks), acceptance-clause table, honest account of the single-seed cherry-picking risk found and fixed during the run, limitations, and next-research directions. Co-Authored-By: claude-flow Claude-Session: https://claude.ai/code/session_01TdYyZd166DoTxb5R4FWuJc --- .../README.md | 591 ++++++++++++++++++ .../gist.md | 150 +++++ 2 files changed, 741 insertions(+) create mode 100644 docs/research/nightly/2026-08-24-structural-time-memory-decay/README.md create mode 100644 docs/research/nightly/2026-08-24-structural-time-memory-decay/gist.md diff --git a/docs/research/nightly/2026-08-24-structural-time-memory-decay/README.md b/docs/research/nightly/2026-08-24-structural-time-memory-decay/README.md new file mode 100644 index 0000000000..9ad9ae717c --- /dev/null +++ b/docs/research/nightly/2026-08-24-structural-time-memory-decay/README.md @@ -0,0 +1,591 @@ +# Structural-Time Memory Decay: Does `emergent-time`'s Structural Clock Beat Wall-Clock Recency for Agent Memory Compaction? + +**150-char summary:** Swapped wall-clock recency for `emergent-time`'s embedding-arc-length clock in memory compaction — directionally correct, never worse, but a 10-seed average misses the pre-registered bar. + +**Date:** 2026-08-24 +**Crate:** `crates/ruvector-structural-memory` +**ADR:** [ADR-340](../../../adr/ADR-340-structural-time-memory-decay.md) +**Acceptance result: REJECT** (of the pre-registered ACCEPT threshold — see [Acceptance Result](#acceptance-result)) + +--- + +## Abstract + +Agent memory compaction (`ruvector-agent-memory`, nightly 2026-06-14) scores a +stored memory's "recency" against wall-clock time: the count of turns/steps +since it was written. This nightly isolates that one variable and asks +whether `emergent-time`'s (ADR-251) `StructuralProperTime` — internal time +defined as accumulated *embedding-arc-length* rather than step count — is a +better clock for that recency term. + +The mechanism under test: during a long, low-drift stretch of a session (an +agent heads-down on one topic), a structural clock accumulates almost no +internal time, so memories written early and late in that stretch end up at +nearly the same structural age even though many wall-clock steps separate +them. A wall clock cannot make that distinction. Three clocks — all literal +`emergent-time` types, no new clock math — were compared on a synthetic +agent-session benchmark (topic plateaus separated by sharp switches), +compacting to a fixed 25-memory budget and measuring recall@15 against an +oracle nearest-neighbour set, averaged over 10 deterministically-generated +seeds: + +| Clock | Mechanism | Mean recall@15, plateau_len=150 (long) | Mean recall@15, plateau_len=20 (short) | +|---|---|---|---| +| `WallClock` (baseline) | age = step count | 0.1600 ± 0.0442 | 1.0000 ± 0.0000 | +| `StructuralEmbedding` (candidate) | age = accumulated `Δv` (`StructuralProperTime`, embedding channel only) | **0.1800 ± 0.0600** | 1.0000 ± 0.0000 | +| `StructuralFull` (exploratory) | age = `Δv` + real entropy signal | 0.1800 ± 0.0600 | 1.0000 ± 0.0000 | + +**Key measured result:** the structural clock's mean long-plateau lead is +**+2.00 percentage points** (0.1800 vs 0.1600), below the **+5pp** threshold +fixed before this benchmark's final multi-seed form ran. Per-seed detail (10 +seeds) shows the structural clock **never underperforms** WallClock — it +ties in 7/10 seeds and wins by exactly +6.67pp in 3/10 — but the win doesn't +happen reliably enough, or by enough margin per seed, for the pre-registered +mean-lead clause to pass. **Acceptance result: REJECT.** Compute overhead +(1.30x WallClock) and the no-regression clause at the short-plateau +configuration both passed. All numbers are from `cargo run --release -p +ruvector-structural-memory --bin benchmark` on the hardware below; raw +output is reproduced verbatim in [Benchmark Results](#benchmark-results). + +**Hardware:** x86-64, 4 logical CPUs, Linux 6.18.44, `rustc 1.94.1`, release +build. + +**A note on how this REJECT was reached, because it matters for trusting +it:** the very first run of this benchmark, on a single seed (`0xC0FFEE`), +showed a +6.67pp lead — comfortably over the 5pp bar. Three more seeds tried +while debugging an unrelated parameter (the context-noise scale; see +[Failure Modes](#failure-modes-and-things-that-almost-made-this-look-better-than-it-is)) +showed two exact ties and one more +6.67pp win. Reporting the first seed +alone would have been exactly the "cherry picked seeds" pattern this +harness's rules explicitly forbid. The benchmark was rewritten to average +over 10 deterministically-generated seeds (`0xC0FFEE + i * 0x9E3779B9` for +`i in 0..10`, fixed before the final run, not chosen after seeing outcomes) +and gated on the mean. That honest aggregate is what REJECTs. This is the +nightly harness's "failed hypothesis with good evidence" case, not an +absence of a result. + +--- + +## Hypothesis + +```text +Given synthetic agent sessions of 4 topic plateaus separated by sharp +switches (plateau lengths 20, 60, or 150 steps; one memory written per +step, embedding dim 32), + +when compaction retention score uses StructuralEmbeddingClock's +accumulated context drift (emergent_time::StructuralProperTime, embedding +channel only) instead of WallClock step count as the age signal, + +then mean recall@15 of the oracle nearest-neighbour set — averaged over 10 +independent seeds — after compacting to a fixed budget of 25 memories +improves by >= 5 percentage points in the long-plateau (150 steps/topic) +configuration, without regressing by more than 2 percentage points in the +short-plateau (20 steps/topic) configuration, + +subject to compaction compute time staying within 5x WallClock's, and +causal order (monotone cumulative time) being preserved by every clock on +every seed. +``` + +**Result: REJECT.** Clause (a) — the long-plateau lead — measured 2.00pp +against a 5pp bar. Clauses (b), (c), (d) all passed. See +[Acceptance Result](#acceptance-result). + +**What this does NOT claim:** that structural time is *worse* than wall +time — it never underperformed across 30 seed×plateau_len cells measured +(10 seeds × 3 plateau lengths). It claims only that the effect, as measured +here, is not reliably large enough to clear the bar set before benchmarking +began. See [Why the Effect Is Real But Small](#why-the-effect-is-real-but-small) +for the mechanism. + +--- + +## Why This Matters for RuVector + +RuVector positions itself as more than a vector database — a substrate for +agent memory, temporal reasoning, and long-running autonomous systems. +`emergent-time` (ADR-251) is a mature, 5,000-line, dependency-free crate +implementing several formalisms of internal/relational time (Wheeler-DeWitt, +Page-Wootters, entropic, thermal, structural proper time), but as of this +nightly it had never been wired into a concrete RuVector *use case* — its +existing benchmarks (early-warning lead, history compression) are generic +trajectory-monitoring demonstrations, not applied to a production surface. +This nightly is the first attempt to connect it to one. + +Connects five RuVector ecosystem capabilities: + +1. **Agent memory** (`ruvector-agent-memory`, 2026-06-14) — the production + surface this experiment's clock-swap targets; not modified by this + nightly, but directly comparable in methodology (same recall@k-after- + compaction measurement). +2. **`emergent-time`** (ADR-251) — reused, not reimplemented: `Clock`, + `StructuralProperTime`, `StructuralMetric`, `StateSnapshot`, `WallClock`, + and `entropy::entropy_from_spectrum` are all called directly from + `crates/emergent-time` via a path dependency. +3. **Vector search** — cosine similarity over synthetic memory embeddings is + the retrieval mechanism the oracle and compaction both use. +4. **Witness/provenance** — `emergent_time::witness` already ships a + hash-linked ledger for training-run provenance; a compaction event log + sealed the same way is a natural extension (see + [MCP Implications](#mcp-implications)), not implemented here. +5. **RVF** — a session's `Session { contexts, topics, memories, snapshots }` + is a direct candidate for a portable, replayable RVF artifact (see + [RVF Implications](#rvf-implications)). + +--- + +## 2026 State of the Art + +Agent-memory decay literature (Park et al. 2023 Generative Agents, +MemoryBank's Ebbinghaus curve, Mem0 2025, Xu 2026's five-stage lifecycle, +Karhade 2026's velocity/volatility decay — all surveyed in the 2026-06-14 +nightly) uniformly measures "age" in wall-clock time or turn count. None of +the systems inspected for that prior nightly, nor any found for this one, +define memory age as a function of *how much the agent's own state has +changed* rather than how many turns have elapsed. `emergent-time`'s +structural-proper-time formalism (arc length of a system's worldline through +its own state manifold) is the direct mathematical tool for that +reparametrization, but its existing use in this repository was limited to +anomaly early-warning and trajectory compression (`structural_clock.rs`'s +own benchmark suite), not retention scoring. This nightly is a new +composition of an existing formalism against a use case it had not been +tried on — the novelty is the application, not the clock math itself, which +this crate deliberately does not modify. + +--- + +## Architecture + +```mermaid +flowchart LR + subgraph Session["Synthetic session (ruvector-structural-memory::scenario)"] + T[N topic centroids\nrandom unit vectors] --> C["Context trajectory\n(piecewise-constant + ramped switches)"] + C --> M["One MemoryItem per step\n(context + independent noise)"] + C --> E["StateSnapshot per step\nembedding = context\nentropy = H(softmax(cos-sim to topics))"] + end + + subgraph Clocks["emergent-time (reused, not reimplemented)"] + WC[WallClock\nage = step count] + SE["StructuralProperTime\nw_embedding=1, rest=0\n(StructuralEmbedding)"] + SF["StructuralProperTime\nw_embedding=1, w_entropy=1\n(StructuralFull)"] + end + + E --> WC + E --> SE + E --> SF + + subgraph Compaction["ruvector-structural-memory::compaction"] + SC["score(m) = w_coh*cos(m, final_context)\n+ w_recency*exp(-age_clock(m)/tau)"] + K["keep top-25 by score"] + end + + WC --> SC + SE --> SC + SF --> SC + M --> SC + SC --> K + + O["Oracle top-15\n(true cosine similarity\nto final context)"] --> R[recall@15] + K --> R + + style Session fill:#1f6feb22,stroke:#1f6feb + style Clocks fill:#8957e522,stroke:#8957e5 + style Compaction fill:#2ea04422,stroke:#2ea044 +``` + +--- + +## Implementation + +`crates/ruvector-structural-memory`: + +- `src/clocks.rs` — fixes two `StructuralMetric` weight configurations on + top of `emergent_time::StructuralProperTime`. No new clock math. +- `src/scenario.rs` — deterministic session generator (xorshift64* PRNG, + same style as `emergent_time::structural_clock`'s own test generator): `N` + topic centroids (random unit vectors), visited in sequence, each held for + `plateau_len` steps with a `switch_width`-step linear ramp between them. + One `MemoryItem` is written per step, embedded near that step's context + plus independent noise. `build_snapshots` derives each step's + `StateSnapshot`: `embedding` is the raw context; `entropy` is the Shannon + entropy (via `emergent_time::entropy::entropy_from_spectrum`) of the + softmax over cosine similarities from the context to every topic centroid + — a genuine derived signal (peaks at a switch, near-zero mid-plateau; see + `entropy_spikes_at_switch_and_settles_mid_plateau` test), not a fabricated + curve. `coherence`/`graph`/`pred_error` are fixed at `0.0`: every clock + instantiated here weights those channels at zero, so their value is inert + — this crate has no honest signal source for them. +- `src/compaction.rs` — scores every memory once against the final context + under a given clock's notion of age (`w_coherence * cos_sim + w_recency * + exp(-age/tau)`, `tau` = a fixed fraction of that clock's *own* total + elapsed time — see [Benchmark Hygiene](#benchmark-hygiene-and-methodology-notes)), + keeps the top-`budget`, and separately computes the true top-k oracle set + and recall. +- `src/main.rs` (`benchmark` binary) — the full sweep: 3 plateau lengths × 3 + clocks × 10 seeds, with 25 timing repetitions per cell, printing the + aggregate table, acceptance clauses, per-seed detail for the deciding + cell, and the exploratory `StructuralFull` comparison. +- `tests/` (inline `#[cfg(test)]` modules) — 7 unit/integration tests: + topic-vector unit-length, one-memory-per-step invariant, the entropy + discriminating property, budget-respecting compaction, oracle + self-recall = 1.0, and an end-to-end structural-clock run. + +No dependency beyond `emergent-time` (path dependency) and the Rust +standard library. + +--- + +## Benchmark Hygiene and Methodology Notes + +- **Release build**, `cargo run --release`. +- **25 timing repetitions** per (plateau_len, clock, seed) cell for the + compute-overhead measurement; recall is deterministic given a seed (no + repetition needed for it), but the *seed itself* is repeated 10x — see + below. +- **10 seeds, generated deterministically before the final run** + (`0xC0FFEE + i * 0x9E3779B9`), not chosen after looking at outcomes. This + replaced an earlier ad hoc 1-seed, then 4-seed, exploration once it became + clear the effect was seed-sensitive — see + [Failure Modes](#failure-modes-and-things-that-almost-made-this-look-better-than-it-is). +- **Fixed absolute compaction budget (25)**, not a fraction of corpus size: + a fractional budget (tried first, at 30%) made the experiment trivial — + the budget comfortably contained the entire current-topic pool regardless + of clock, so recall@15 was 1.0000 for every cell and the hypothesis was + untestable. A budget fixed below a long plateau's own topic-pool size + forces genuine within-topic competition, which is where the clock choice + can matter. +- **Context noise fixed at 0.001** (small relative to a topic-switch jump, + ≈√2 between two near-orthogonal unit centroids at dim=32): the first + implementation used the same noise scale (0.05) later used for memory + embeddings, which made per-step context movement during a "quiet" plateau + comparable in magnitude to a topic switch — defeating the entire premise + (a structural clock is only informative if quiet periods are actually + quiet). See [Failure Modes](#failure-modes-and-things-that-almost-made-this-look-better-than-it-is). +- **Compute-overhead ratio** computed from mean wall-clock time (`Instant`) + summed across all three plateau_len configurations for `WallClock` vs + `StructuralEmbedding`. +- **Causal order** (`emergent_time::Clock::cumulative` is monotone + non-decreasing) checked directly on every clock/config/seed combination, + not merely assumed from the trait's non-negative-tick guarantee. + +--- + +## Benchmark Results + +Raw output from `cargo run --release -p ruvector-structural-memory --bin +benchmark`: + +```text +ruvector-structural-memory benchmark +config: n_topics=4 dim=32 oracle_k=15 budget=25 timing_reps=25 n_seeds=10 +hardware: x86_64-linux, rustc build=release +seeds: [12648430, 2667084199, 5321519968, 7975955737, 10630391506, 13284827275, 15939263044, 18593698813, 21248134582, 23902570351] + +plateau_len clock total_steps budget recall@15(mean±sd) mean_time_ns causal_ok +20 WallClock 80 25 1.0000±0.0000 5975 true +20 StructuralEmbedding 80 25 1.0000±0.0000 7823 true +20 StructuralFull 80 25 1.0000±0.0000 7609 true +60 WallClock 240 25 0.3867±0.1147 15180 true +60 StructuralEmbedding 240 25 0.4000±0.1075 19102 true +60 StructuralFull 240 25 0.4133±0.1024 19141 true +150 WallClock 600 25 0.1600±0.0442 39362 true +150 StructuralEmbedding 600 25 0.1800±0.0600 51889 true +150 StructuralFull 600 25 0.1800±0.0600 51484 true + +acceptance clauses (thresholds fixed before this run; means over 10 seeds): + (a) mean long-plateau lead >= 5pp: measured 2.00pp -> FAIL + (b) mean short-plateau regression <= 2pp: measured 0.00pp delta -> PASS + (c) compute overhead ratio <= 5x: measured 1.30x -> PASS + (d) causal order preserved for every clock/config/seed: -> PASS + +ACCEPTANCE RESULT: REJECT + +per-seed detail, plateau_len=150 (the deciding cell): + seed WallClock StructuralEmbedding StructuralFull + 0x0000000000c0ffee 0.2000 0.2667 0.2667 + 0x000000009ef879a7 0.1333 0.1333 0.1333 + 0x000000013d2ff360 0.2000 0.2000 0.2000 + 0x00000001db676d19 0.2000 0.2000 0.2000 + 0x00000002799ee6d2 0.1333 0.1333 0.1333 + 0x0000000317d6608b 0.2000 0.2667 0.2667 + 0x00000003b60dda44 0.1333 0.1333 0.1333 + 0x00000004544553fd 0.1333 0.2000 0.2000 + 0x00000004f27ccdb6 0.2000 0.2000 0.2000 + 0x0000000590b4476f 0.0667 0.0667 0.0667 + +exploratory (not gating): StructuralFull vs StructuralEmbedding mean recall delta + plateau_len=20: StructuralFull=1.0000 StructuralEmbedding=1.0000 delta=0.0000pp + plateau_len=60: StructuralFull=0.4133 StructuralEmbedding=0.4000 delta=1.3333pp + plateau_len=150: StructuralFull=0.1800 StructuralEmbedding=0.1800 delta=0.0000pp +``` + +Reproduce with: `cargo build --release -p ruvector-structural-memory && cargo +run --release -p ruvector-structural-memory --bin benchmark`. + +--- + +## Acceptance Result + +| Clause | Threshold | Measured | Result | +|---|---|---|---| +| (a) long-plateau mean lead | ≥ 5.00pp | 2.00pp | **FAIL** | +| (b) short-plateau mean regression | ≥ -2.00pp | 0.00pp | PASS | +| (c) compute overhead ratio | ≤ 5.00x | 1.30x | PASS | +| (d) causal order preserved | all cells | all cells | PASS | + +One mandatory clause fails → **REJECT**, per the pre-registered "all clauses +must pass" rule. The thresholds were fixed alongside the budget/noise +parameters before the first benchmark run of this experiment and were not +loosened after seeing this result. + +--- + +## Why the Effect Is Real But Small + +The per-seed detail table shows the mechanism working exactly as designed +when it fires: 3 of 10 seeds show `StructuralEmbedding` beating `WallClock` +by exactly +6.67pp (one extra correct memory out of 15, at a 25-item +budget), and it never loses. The remaining 7 seeds tie exactly. This +discrete, seed-dependent pattern is consistent with a genuine but *boundary* +effect: within a stable plateau, `StructuralEmbeddingClock` assigns nearly +identical age to every memory in that plateau (since the plateau contributes +almost zero accumulated arc length), so ranking within the plateau falls +back almost entirely to the coherence term — closely tracking the oracle's +true-cosine ranking. `WallClock`, by contrast, imposes an artificial +recency bias across the plateau that the oracle ranking does not share. But +that bias only *changes which items land inside vs. outside the fixed +25-item budget* when the true-cosine ranking and the wall-clock-biased +ranking disagree specifically near the budget cutoff boundary — and with +only 4 near-orthogonal random topic centroids per session, whether that +boundary disagreement actually occurs is itself a matter of which +particular noise draw the session got. This is a plausible, structurally +motivated explanation for the observed distribution, not a rescued +retroactive justification for the REJECT threshold: the threshold was fixed +before any of this per-seed data was collected. + +--- + +## Failure Modes (and Things That Almost Made This Look Better Than It Is) + +1. **Fractional budget made the first version of this experiment trivial.** + At 30% of corpus size, the budget always comfortably contained an entire + plateau's memory pool, so recall@15 was 1.0000 for every clock — a + methodology bug, not evidence of "no difference." Fixed by switching to + a fixed absolute budget (25) smaller than a long plateau's own pool. +2. **Context noise too large relative to the switch-jump size initially + made `StructuralEmbeddingClock` behave as a near-linear reparametrization + of `WallClock`** (same recall numbers for both, seed after seed) — because + independent per-step noise accumulates roughly linearly in step count, + the same shape as wall-clock aging, just with a different constant. + Reduced context noise ~50x (0.05 → 0.001) relative to the topic-switch + jump size to make "quiet" plateaus genuinely quiet in embedding-arc terms. +3. **Single-seed cherry-picking risk.** The first fixed-budget, + fixed-noise run (seed `0xC0FFEE`) happened to show a comfortable + +6.67pp lead — a result that, reported alone, would have looked like an + unambiguous ACCEPT. Three more manually-tried seeds while validating the + noise fix showed the lead is not consistent per-seed. Per this harness's + explicit prohibition on cherry-picked seeds, the benchmark was rewritten + to average over 10 seeds fixed by a deterministic formula before the + final run, and gated on that mean. That is the number reported as this + nightly's result. +4. **The entropy channel (`StructuralFull`) added no measurable benefit** + over the pure embedding-arc clock at the deciding (150) configuration, + and only a marginal +1.33pp at the 60-step configuration — reported + honestly as a null/marginal exploratory result, not suppressed. + +--- + +## Security + +No new attack surface: this crate reads a synthetic in-memory corpus and +performs no I/O, network access, or untrusted deserialization. It does not +touch `ruvector-agent-memory`'s ledger, proof-gate, or capability-token +paths. If a structural-time compaction policy were ever wired into a +production memory store, the risk to evaluate would be adversarial context +manipulation: an agent (or a prompt-injected tool result) that deliberately +keeps the *reported* context embedding static while the *actual* topic +drifts would make a structural clock under-forget stale memories — the +mirror image of the benefit demonstrated here. That risk is out of scope +for this synthetic benchmark and is listed as required future work before +any production integration (see [ADR-340](../../../adr/ADR-340-structural-time-memory-decay.md)). + +--- + +## Governance + +This nightly's result is a REJECT of a pre-registered ACCEPT threshold, not +a promoted capability. No production code path is modified. The new crate +is additive (`crates/ruvector-structural-memory`, added to the workspace +member list) and carries no feature flag because nothing consumes it yet. + +--- + +## MCP Implications + +Not applicable at REJECT: no capability is being exposed for external +invocation. If a future iteration of this direction reached ACCEPT, the +natural MCP surface would mirror `ruvector-agent-memory`'s existing +`memory_compact(context, target_pct)` tool, with an added `clock: "wall" | +"structural"` parameter — narrow, and read/write-scoped identically to the +existing tool, not a new authority class. + +--- + +## WASM Implications + +`emergent-time` is dependency-free and has a companion `emergent-time-wasm` +crate already in the workspace; `ruvector-structural-memory` adds only +`Vec` arithmetic and one HashSet, so a WASM build is architecturally +unblocked. Not attempted in this nightly — no deployment claim is made. + +--- + +## RVF Implications + +A `Session { contexts, topics, memories, snapshots }` is exactly the shape +of an RVF-portable trajectory artifact: replaying it deterministically +(same seed → same session, verified by this crate's own tests) is a +prerequisite RVF already expects for reproducible cognitive state. Not +implemented here — noted because the reusability was evident during +implementation, not retrofitted for this section. + +--- + +## RVM Implications + +None identified. This experiment has no privileged operation, isolation +boundary, or coherence-domain crossing to enforce. + +--- + +## ruFlo Implications + +If a future version of this direction reached ACCEPT, the natural ruFlo +workflow is a periodic memory-maintenance job: run compaction with the +structural clock on a live agent's memory store on a schedule, logging +recall-preservation estimates against a held-out query set. Not +implemented; the mechanism (a scheduled compaction pass) already exists +conceptually in `ruvector-agent-memory`'s design notes. + +--- + +## Practical Applications + +| # | User | Problem | RuVector capability | Time horizon | +|---|---|---|---|---| +| 1 | Long-running coding agent | Loses cheap access to early-session decisions during a long refactor even though they're still relevant | Structural-time-weighted compaction (if reworked to clear the bar) | Near | +| 2 | Customer-support agent | Wall-clock decay discards case history from a long, stable ticket thread | Same mechanism applied to `ruvector-agent-memory` | Near | +| 3 | Research assistant agent | Rapid topic-switching sessions accumulate stale memory from abandoned threads | Structural clock's fast aging right after a switch (the flip side of this benchmark) | Near | +| 4 | Multi-agent swarm coordinator | Shared memory pool needs per-topic, not per-turn, retention policy | `ruvector-structural-memory` + `ruvector-namespace-merge` (2026-08-08) combined | Mid | +| 5 | Edge/Cognitum agent | Constrained memory budget needs the most information-dense retention policy | Same, on `emergent-time-wasm` | Mid | +| 6 | Compliance/audit agent | Needs to justify *why* a memory was kept or dropped | Compaction event sealed via `emergent_time::witness` | Mid | +| 7 | Personal AI assistant (weeks-long context) | Wall-clock decay under stable-life-routine stretches discards useful habits/preferences | Same mechanism at much longer plateau lengths | Long | +| 8 | Autonomous research agent (months-long project) | Session length in *turns* is a poor proxy for "how much has actually changed" | Structural time as the native temporal unit for agent memory, not wall time | Long | + +--- + +## Long Horizon Applications + +| # | Thesis | Required advances | RuVector role | Primary uncertainty | +|---|---|---|---|---| +| 1 | Agents run for years, not sessions; memory needs a temporal unit that isn't turns | Reliable low-drift detection at scale, not just synthetic plateaus | Native structural-time index | Whether real context embeddings are ever this cleanly "quiet" (see Limitations) | +| 2 | Multi-agent swarms need a shared notion of "how much has the world changed" for coordinated forgetting | Distributed clock synchronization across agents | `emergent-time` + swarm memory | Consensus cost of a shared structural clock | +| 3 | Structural time as an anomaly-and-retention unifier: the same clock that flags drift also ages memory | Single production implementation serving both roles | `structural_clock.rs`'s existing early-warning code, reused | Whether one metric can honestly serve both purposes without conflicting incentives | +| 4 | Proof-gated forgetting: a witness chain proving *why* a memory was structurally aged out | Signed, verifiable compaction decisions | `emergent_time::witness` + `ruvector-proof-gate` | Whether "why" is auditable without leaking the memory content itself | +| 5 | Edge cognition with bounded memory needs the most information-dense retention rule physically realizable | WASM structural-time compaction at sub-millisecond budgets | `emergent-time-wasm` | Compute budget on real edge hardware, not simulated | +| 6 | World models that track "how much has my environment model changed" as their own internal clock | Structural time applied to model-state deltas, not just embeddings | `StructuralMetric`'s `ΔG`/`ΔE` channels, unused in this nightly | No honest signal source demonstrated yet (this nightly's own limitation) | +| 7 | Self-healing agent memory that ages faster near contradictions | `ΔC` (coherence loss) channel, unused here | Same crate, extended | Needs a real coherence signal (e.g. `ruvector-coherence`) wired in | +| 8 | A general theory of "agent time" as the native coordinate for all RuVector temporal reasoning, replacing wall-clock timestamps repo-wide | Much broader validation than one compaction benchmark | `emergent-time` as a foundational primitive | This nightly is one data point, not sufficient evidence for a repo-wide claim | + +--- + +## Competitor Comparison + +| System | Documented recency mechanism | Directly measured here? | +|---|---|---| +| MemGPT / Letta | Token-budget eviction | documented_external_capability | +| Mem0 (2025) | LLM-driven ADD/UPDATE/DELETE, no continuous decay | documented_external_capability | +| Zep | Temporal knowledge graph, wall-clock validity windows | documented_external_capability | +| LangChain memory | Wall-clock / turn-count windows | documented_external_capability | + +No comparison system was run or benchmarked in this nightly; the table +above reflects public documentation only, per this harness's rule against +treating undocumented or unmeasured external claims as directly comparable. +`ruvector-agent-memory`'s own wall-clock baseline (this nightly's +`WallClock` variant) is the only directly measured comparison point. + +--- + +## Limitations + +- **Synthetic corpus only.** Topic centroids are random unit vectors in a + 32-dimensional space; real conversational embeddings are not uniformly + near-orthogonal and carry residual within-topic drift that this + experiment's near-zero context noise (0.001) may understate. This is + flagged, not hidden: the noise scale was chosen to make the mechanism + measurable at all, and a follow-up should sweep it to find the drift + level at which the effect disappears. +- **Small effect size.** Even where the structural clock wins, it wins by + exactly one memory out of 15 (+6.67pp) — a real but modest margin at this + scale. +- **Single dataset shape.** Only one topic-visitation pattern (each topic + visited exactly once, in sequence) was tested. Revisited topics, more + than 4 topics, or higher/lower embedding dimensions are untested. +- **`StructuralFull`'s entropy channel showed no benefit** at the deciding + configuration — the exploratory extension did not strengthen the case. + +--- + +## Falsification Criteria + +This hypothesis is falsified by exactly what was measured: a fixed, +pre-registered mean-lead threshold at a fixed configuration, evaluated +honestly over multiple seeds. It was falsified. A different result would +require either a different (larger) drift-vs-noise ratio, a different +compaction-pressure regime, or a genuinely different scenario shape — any of +which is a new experiment, not a reinterpretation of this one. + +--- + +## Production Path + +**Not recommended for promotion in its current form.** If this direction is +revisited: + +1. Sweep context-noise/drift ratio to find where the effect crosses 5pp + reliably, if it ever does, rather than fixing one value. +2. Test with a real embedding source (e.g. actual LLM-embedded conversation + turns) instead of synthetic random-unit-vector topics. +3. Wire a real `ΔC`/`ΔG` signal (e.g. from `ruvector-coherence` or + `ruvector-mincut`) into `StructuralFull` rather than leaving those + channels at zero weight. +4. Re-run the full multi-seed protocol against the new configuration before + any acceptance claim. + +--- + +## Next Research + +- Sweep drift-vs-noise ratio (item 1 above) as a standalone follow-up — + answers whether this REJECT is a parameter-regime artifact or a durable + ceiling on the mechanism's effect size. +- Wire `ruvector-coherence`'s cluster-coherence score into `StructuralFull`'s + `ΔC` channel as a genuine (not zero-weighted) signal. +- Test structural-time compaction on a real (not synthetic) embedded + conversation corpus if one becomes available in-repo. + +--- + +## References + +- ADR-251 — `emergent-time`: calculus of emergent/relational time. +- 2026-06-14 nightly — Coherence-Weighted Agent Memory Compaction + (`ruvector-agent-memory`), the production baseline this experiment's + methodology mirrors. +- Park et al. 2023, *Generative Agents* (arXiv:2304.03442). +- Zhong et al. 2023, *MemoryBank* (arXiv:2305.10250, AAAI 2024). +- Mem0, 2025 production paper (arXiv:2504.19413). +- `crates/emergent-time/src/structural_clock.rs` — source of + `StructuralProperTime`, `Clock`, `StateSnapshot`, `WallClock`, and this + crate's own reused synthetic-scenario generation style. diff --git a/docs/research/nightly/2026-08-24-structural-time-memory-decay/gist.md b/docs/research/nightly/2026-08-24-structural-time-memory-decay/gist.md new file mode 100644 index 0000000000..0f900289d8 --- /dev/null +++ b/docs/research/nightly/2026-08-24-structural-time-memory-decay/gist.md @@ -0,0 +1,150 @@ +# Structural-Time Memory Decay: A Negative Result, Honestly Measured + +## Problem + +Agent memory systems decide what to forget using wall-clock time: a memory +written 500 turns ago is scored as "older" than one written 5 turns ago, +regardless of what actually happened in between. That conflates two +different things — *time elapsed* and *change occurred*. An agent that +spent 495 of those 500 turns heads-down on one stable task didn't really +"drift" much; a memory from turn 5 of that stretch is not meaningfully +staler than one from turn 495. + +`emergent-time` is a RuVector crate implementing several formalisms of +*internal* time — time defined by how much a system's own state has changed, +rather than by an external clock. Its `StructuralProperTime` construction +defines internal time as the accumulated arc length of a system's state +trajectory: quiet periods add almost no internal time, sharp changes add a +lot. It had never been applied to memory retention scoring. This project +tests whether it should be. + +## Hypothesis + +Swap the recency term in a memory-compaction retention score from "wall-clock +step count" to "accumulated embedding-arc-length" (`StructuralProperTime`, +embedding channel only), and measure whether recall of the *true* most- +relevant memories, after compacting to a fixed budget, improves — averaged +over many random synthetic sessions, not one lucky seed. + +## Technical Design + +A synthetic agent session visits 4 topics in sequence, each held for a fixed +number of steps (a "plateau") before a sharp switch to the next. One memory +is written per step, embedded near that step's context plus independent +noise. Three clocks are compared, all literal `emergent-time` types: + +- `WallClock` — age = step count (today's implicit convention). +- `StructuralEmbeddingClock` — age = accumulated `Δv` (pure embedding-arc + length via `StructuralProperTime`). +- `StructuralFullClock` — age = `Δv` + a genuine entropy signal (Shannon + entropy of the softmax over cosine similarities to the topic centroids — + derived from real data, not fabricated). + +Retention score = `0.5 * cos_sim(memory, current_context) + 0.5 * +exp(-age_under_clock / tau)`, with `tau` fixed as a constant fraction of +each clock's own total elapsed time (so no clock gets a hand-tuned decay +scale). Compact to a fixed budget of 25 memories; measure recall@15 against +the true (oracle) nearest neighbors of the final context. + +## Actual Implementation + +`crates/ruvector-structural-memory` — a self-contained Rust crate depending +only on `emergent-time` (path dependency, no reimplemented clock math) and +the standard library. Deterministic xorshift64* scenario generation, 7 +unit/integration tests, a `benchmark` binary that sweeps 3 plateau lengths × +3 clocks × 10 seeds with 25 timing repetitions per cell. + +## Actual Benchmark Evidence + +```text +plateau_len clock total_steps budget recall@15(mean±sd) mean_time_ns causal_ok +20 WallClock 80 25 1.0000±0.0000 5975 true +20 StructuralEmbedding 80 25 1.0000±0.0000 7823 true +60 WallClock 240 25 0.3867±0.1147 15180 true +60 StructuralEmbedding 240 25 0.4000±0.1075 19102 true +150 WallClock 600 25 0.1600±0.0442 39362 true +150 StructuralEmbedding 600 25 0.1800±0.0600 51889 true + +acceptance clauses (thresholds fixed before this run; means over 10 seeds): + (a) mean long-plateau lead >= 5pp: measured 2.00pp -> FAIL + (b) mean short-plateau regression <= 2pp: measured 0.00pp delta -> PASS + (c) compute overhead ratio <= 5x: measured 1.30x -> PASS + (d) causal order preserved for every clock/config/seed: -> PASS + +ACCEPTANCE RESULT: REJECT +``` + +Full raw output, including per-seed detail, is in the nightly README. + +## Why This Is a REJECT, Not a Discard + +The pre-registered bar was a +5 percentage point mean recall lead at the +long-plateau configuration, averaged over 10 seeds fixed by a formula +decided before the final run. The measured mean lead was +2.00pp. That +clause failed, so the acceptance result is REJECT. + +It's worth being explicit about how this number was reached, because the +first version of this benchmark reported a much better number. On a single +seed (`0xC0FFEE`), the structural clock beat wall-clock by +6.67pp — a +result that, reported alone, would have looked like a clean win. Three more +seeds tried while debugging an unrelated parameter showed two exact ties and +one more win. Publishing the first seed and stopping there would have been +textbook cherry-picking. The benchmark was rewritten to average over 10 +seeds generated by a fixed formula, and gated on that mean instead. The +honest number is 2.00pp, and it's below the bar. + +The per-seed data is still informative: across 30 (seed × plateau_len) +comparison cells, the structural clock never underperformed wall-clock — it +tied in most cells and won outright in a few, by the same fixed margin each +time (+6.67pp, exactly one extra correct memory out of 15). That's +consistent with a real mechanism that only changes the outcome when a +specific ranking boundary is crossed, which — with only 4 topic centroids +per session — depends on the particular random draw. It's a plausible +explanation for the pattern, not a reason to call this an ACCEPT. + +## Limitations + +- Synthetic corpus: random unit-vector topic centroids, not real embedded + conversation. +- One dataset shape: 4 topics, each visited exactly once. +- The within-plateau noise scale was fixed at one value chosen to make the + mechanism observable at all, not swept to find where the effect grows or + vanishes. +- The entropy-augmented variant (`StructuralFullClock`) showed no measurable + benefit over the pure embedding-arc clock at the deciding configuration. + +## Production Relevance + +None, currently — this is explicitly not being promoted to +`ruvector-agent-memory` or any production path (see ADR-340). The benchmark +harness itself is the reusable asset: a deterministic, multi-seed, +oracle-recall methodology for testing any future memory-retention clock, +plus a documented record that this specific configuration does not clear its +own bar, so a future attempt does not have to rediscover that from scratch. + +## RuVector Ecosystem Implications + +Connects `emergent-time` (ADR-251, previously untested outside its own +generic anomaly/compression benchmarks) to a concrete agent-memory use case +for the first time, alongside vector search (cosine similarity), and +(architecturally, not implemented) witness/provenance and RVF portability — +see the nightly README's ecosystem-fit sections for detail. + +## Future Direction + +1. Sweep the within-plateau noise-to-switch-jump ratio to find whether a + 5pp-clearing regime exists, rather than testing one fixed value. +2. Test against real embedded conversation data instead of synthetic + random-unit-vector topics. +3. Wire an actual coherence signal (e.g. `ruvector-coherence`) into the + `StructuralFullClock`'s unused `ΔC` channel. + +## References + +- `crates/emergent-time` (ADR-251) — source of `StructuralProperTime`, + `Clock`, `StateSnapshot`, `WallClock`, `entropy::entropy_from_spectrum`. +- `docs/research/nightly/2026-06-14-agent-memory-compaction` — the + production baseline (`ruvector-agent-memory`) this experiment's + methodology mirrors. +- `docs/adr/ADR-340-structural-time-memory-decay.md` — the formal decision + record for this result.