//! Real-time learning loop - the unified in-process ecosystem ("skull"). //! //! PRD section 4 execution model, sequential with background learning: //! 1. (gate) long inputs are digested before anything else //! 1. student generates (blocking, user-facing) //! 2. experience captured to Episodic IMMEDIATELY (any verdict) //! 3. alter ego validates on the TEXT form //! 4. COMMIT -> semantic triples + replay + queued LoRA micro-steps //! QUEUE -> ValidationLedger (never replay) //! REJECT -> logged rationale only //! 5. skills observe success/staleness; stale rehearsed, rotten archived //! Background trainer drains the VALIDATED replay backlog only - never the //! unvalidated current interaction - mutating ONLY the LoRA standby buffer, //! published atomically between turns. The base stays frozen forever. use std::sync::Arc; use std::time::Instant; use crate::digestion::{self, Embedder, Tokenizer, GATE_TOKENS}; use crate::error::Result; use crate::lora::AdapterHandle; use crate::memory::{Experience, TriMemory}; use crate::model::{Judge, San}; use crate::recall::Bm25Index; use crate::trust::{TrustScore, Verdict}; use crate::vector_index::VectorIndex; #[derive(Debug)] pub struct TurnResult { pub output_ids: Vec, pub score: TrustScore, pub verdict: Verdict, /// All verdicts when digestion produced multiple leaves. pub verdicts: Vec<(String, Verdict, f32)>, pub confidence: f32, pub beam_used: bool, pub recalled_context: Vec, /// SCoRe-lite revision episode (when a low-trust first attempt triggered /// a second pass). pub revision: Option, /// What the user actually receives (revision if it scored higher). pub final_output_ids: Vec, /// Wall-clock for the full turn (PRD section 10 latency gate). pub duration_ms: f32, } pub const CONFIDENCE_BEAM_THRESHOLD: f32 = 0.6; pub const BEAM_CANDIDATES: usize = 3; const BEAM_TEMPS: [f32; 3] = [0.7, 1.0, 1.3]; const STALE_SECONDS: f64 = 7.0 * 24.0 * 3600.0; const ROTTEN_SECONDS: f64 = 30.0 * 24.0 * 3600.0; struct Rng(u64); impl Rng { fn new(seed: u64) -> Self { Self(seed | 1) } fn next_f32(&mut self) -> f32 { self.0 = self .0 .wrapping_mul(6364136223846793005) .wrapping_add(1442695040888963407); ((self.0 >> 40) as f32) / ((1u32 << 24) as f32) } } #[derive(Debug)] pub struct RevisionInfo { pub first_trust: f32, pub revised_trust: f32, pub accepted: bool, } pub struct Ecosystem { pub student: San, pub judge: Box, pub memory: TriMemory, pub adapters: Arc, pub lr: f32, pub step: usize, pub tokenizer: Box, pub embedder: Box, pub archived_skills: Vec, pub recall_conditioning: bool, pub revisions_enabled: bool, pub sc_attempts: usize, pub sc_hits: usize, /// Ingestion-only vector index over digested leaf chunks (E2.7). pub vector_index: VectorIndex, /// A7 Phase 2: optional typed-event sink (bridged to OgRune EventHub). pub event_sink: Option>, rng: Rng, } impl Ecosystem { pub fn new( mut student: San, judge: Box, replay_max: usize, lr: f32, ) -> Self { let handle = Arc::new(AdapterHandle::new(&student.cfg)); student.set_adapter(handle.active()); Self { student, judge, memory: TriMemory::new(replay_max), adapters: handle, lr, step: 0, tokenizer: Box::new(digestion::WordTokenizer { vocab: 8192 }), embedder: Box::new(digestion::StubEmbedder { dim: 64 }), archived_skills: Vec::new(), recall_conditioning: false, revisions_enabled: false, sc_attempts: 0, sc_hits: 0, vector_index: VectorIndex::default(), event_sink: None, rng: Rng::new(0xDA7A_5EED), } } /// Build from a loaded checkpoint parameter map (plug-in path). pub fn from_checkpoint( params: crate::model::ParamMap, cfg: crate::model::SanConfig, judge: Box, replay_max: usize, lr: f32, ) -> Result { let student = San::from_params(params, cfg)?; Ok(Self::new(student, judge, replay_max, lr)) } // ------------------------------------------------------------------ // step 1: generation (greedy or trust-guided beam) // ------------------------------------------------------------------ fn confidence_at_last(&self, ids: &[u32]) -> Result { let logits = self.student.forward(ids)?; let last = logits.row(logits.nrows() - 1); let m = last.iter().cloned().fold(f32::NEG_INFINITY, f32::max); let exps: Vec = last.iter().map(|x| (x - m).exp()).collect(); let sum: f32 = exps.iter().sum(); Ok(exps.iter().cloned().fold(0.0f32, f32::max) / sum.max(1e-9)) } pub fn generate_greedy(&self, input_ids: &[u32], gen_len: usize) -> Result> { self.student.generate(input_ids, gen_len) } /// Temperature-sampled variant (guided beam candidate). fn generate_sampled(&mut self, input_ids: &[u32], gen_len: usize, temp: f32) -> Result> { let mut seq = input_ids.to_vec(); for _ in 0..gen_len { if seq.len() >= self.student.cfg.max_seq_len { break; } let logits = self.student.forward(&seq)?; let last = logits.row(logits.nrows() - 1); let inv = 1.0 / temp.max(1e-3); let m = last.iter().cloned().fold(f32::NEG_INFINITY, f32::max); let mut acc = 0.0f32; let mut probs: Vec = Vec::with_capacity(last.len()); for x in last.iter() { let e = ((x - m) * inv).exp(); probs.push(e); acc += e; } for p in probs.iter_mut() { *p /= acc; } let r = self.rng.next_f32(); let mut c = 0.0f32; let mut choice = 0usize; for (j, p) in probs.iter().enumerate() { c += p; if r <= c { choice = j; break; } } seq.push(choice as u32); } Ok(seq[input_ids.len()..].to_vec()) } /// Guided beam search (PRD section 5): triggered by low confidence; /// candidates scored by the alter ego; highest trust wins. pub fn generate_guided( &mut self, input_ids: &[u32], gen_len: usize, ) -> Result<(Vec, bool)> { let conf = self.confidence_at_last(input_ids)?; if conf >= CONFIDENCE_BEAM_THRESHOLD { let out = self.generate_greedy(input_ids, gen_len)?; return Ok((out, false)); } let mut best: Option<(Vec, f32)> = None; for t in BEAM_TEMPS { let cand = self.generate_sampled(input_ids, gen_len, t)?; let exp = Experience::with_text( input_ids.to_vec(), cand.clone(), vec![], String::new(), "beam", ); let s = self.judge.score(&exp); if best.as_ref().map(|(_, bs)| s.total > *bs).unwrap_or(true) { best = Some((cand, s.total)); } } Ok((best.map(|(o, _)| o).unwrap_or_default(), true)) } // ------------------------------------------------------------------ // steps 2-4: capture, validate, route // ------------------------------------------------------------------ fn capture_and_route(&mut self, mut exp: Experience, gen_len: usize) -> Result { let (out, beam) = self.generate_guided(&exp.input, gen_len)?; let confidence = self.confidence_at_last(&exp.input).unwrap_or(0.0); exp.output = out.clone(); // step 2: immediate capture (PRD) - regardless of upcoming verdict self.memory.episodic.record(exp.clone()); // B3 accommodation: digest-first judging — long text is ROOT-compressed // so the 256-token judge window sees the whole meaning, not a truncation. let est_words = exp.text.split_whitespace().count(); if est_words > digestion::GATE_TOKENS { let doc = digestion::digest_document( &exp.text, self.tokenizer.as_ref(), self.embedder.as_ref(), ); let mut claims = exp.claims.clone(); for l in &doc.leaves { for c in &l.core_claims { if !claims.contains(c) { claims.push(c.clone()); } } } exp.claims = claims; exp.text = format!("ROOT DIGEST: {}", doc.root.text); let _ = digestion::LEAF_TOKENS; // window constants documented in module } // step 3: validation on the text form let score = self.judge.score(&exp); let verdict = score.verdict(); // single evaluation per experience match verdict { Verdict::Commit => { for c in &exp.claims { self.memory.semantic.add(crate::memory::Triple { subject: format!("exp:{}", exp.id), relation: "claims".into(), object: c.clone(), source_exp: exp.id.clone(), }); } self.memory.replay.push(exp.clone()); // validated anchor set ONLY } Verdict::Queue => { self.memory.ledger.push(exp.clone(), now_secs()); } Verdict::Reject => { log::info!("REJECT exp {} (trust={:.3})", exp.id, score.total); } } // ---- SCoRe-lite revision turn (PRD §5 extension) ---- let mut revision = None; let mut final_out = out.clone(); if self.revisions_enabled && verdict != Verdict::Commit { self.sc_attempts += 1; if let Some((mut e2, s2, v2)) = self.run_revision(&exp.input, &exp, &score, gen_len)? { e2.parent_exp_id = Some(exp.id.clone()); if v2 == Verdict::Commit { self.sc_hits += 1; e2.advantage = (1.0 + (s2.total - score.total)).clamp(1.0, 1.5); for c in &e2.claims { self.memory.semantic.add(crate::memory::Triple { subject: format!("exp:{}", e2.id), relation: "claims".into(), object: c.clone(), source_exp: e2.id.clone(), }); } // train on the full trajectory pair (attempt-1 context too) self.memory.replay.push(exp.clone()); self.memory.replay.push(e2.clone()); } else if v2 == Verdict::Queue { self.memory.ledger.push(e2.clone(), now_secs()); } else { log::info!("revision REJECT exp {} (trust={:.3})", e2.id, s2.total); } if s2.total > score.total { final_out = e2.output.clone(); } revision = Some(RevisionInfo { first_trust: score.total, revised_trust: s2.total, accepted: v2 == Verdict::Commit, }); } } self.step += 1; let vrow = (exp.id, verdict, score.total); Ok(TurnResult { output_ids: out, score, verdict, verdicts: vec![vrow], confidence, beam_used: beam, recalled_context: Vec::new(), duration_ms: 0.0, revision, final_output_ids: final_out, }) } /// One self-correction pass: condition on the prompt + judge feedback + /// first attempt; regenerate and re-judge. fn run_revision( &mut self, prompt_ids: &[u32], first: &Experience, s1: &TrustScore, gen_len: usize, ) -> Result> { let fb = format!( "prior answer scored low trust {:.2} (consistency={:.2} verifiability={:.2} safety={:.2}); revise it correcting those weaknesses.", s1.total, s1.consistency, s1.verifiability, s1.safety ); let mut rev_input: Vec = prompt_ids.to_vec(); rev_input.extend(self.tokenizer.encode(&fb)); rev_input.extend_from_slice(&first.output); let budget = self.student.cfg.max_seq_len; if rev_input.len() > budget { let skip = rev_input.len() - budget; rev_input.drain(0..skip); } let revised = self.generate_greedy(&rev_input, gen_len)?; let text2 = format!("{}\n[revision of {}]", first.text, first.id); let mut e2 = Experience::with_text( rev_input, revised, first.claims.clone(), text2, "user", ); e2.advantage = 1.0; let s2 = self.judge.score(&e2); let v2 = s2.verdict(); Ok(Some((e2, s2, v2))) } /// Plain token-level turn (no document text attached). pub fn turn(&mut self, input_ids: &[u32], gen_len: usize) -> Result { let t0 = Instant::now(); let exp = Experience::new(input_ids.to_vec(), vec![], vec![], "user"); let mut r = self.capture_and_route(exp, gen_len)?; r.duration_ms = t0.elapsed().as_secs_f32() * 1000.0; Ok(r) } /// Deterministic passthrough generation for lm-eval style harnesses: /// no memory writes, no digestion gate, no beam (E6 eval-mode). pub fn eval_turn(&self, input_ids: &[u32], gen_len: usize) -> Result> { self.generate_greedy(input_ids, gen_len) } /// Full turn with document text: recall -> (digestion gate) -> generate -> /// capture -> validate -> route. Long inputs (>256 est tokens) are chewed; /// each leaf is validated separately and commits train on compressed form. /// Swap in the Stage-3 BPE tokenizer (encode parity) or any Embedder. pub fn set_tokenizer(&mut self, t: Box) { self.tokenizer = t; self.recall_conditioning = true; } pub fn set_embedder(&mut self, e: Box) { self.embedder = e; } pub fn turn_text( &mut self, text: &str, input_ids: &[u32], gen_len: usize, ) -> Result { let t0 = Instant::now(); let index = Bm25Index::rebuild(&self.memory); let recalled = index.recall_context(&self.memory, text); // Recall-conditioned generation (PRD step 1): once a real tokenizer is // attached, retrieved episodes prepend to the conditioning window. let mut eff_ids: Vec = input_ids.to_vec(); if self.recall_conditioning && !recalled.is_empty() { let ctx_text = recalled.join("\n"); let ctx_ids = self.tokenizer.encode(&ctx_text); let budget = self .student .cfg .max_seq_len .saturating_sub(input_ids.len() + gen_len + 8); let trimmed: Vec = ctx_ids .into_iter() .rev() .take(budget) .collect::>() .into_iter() .rev() .collect(); eff_ids.splice(0..0, trimmed); } let est_tokens = text.split_whitespace().count(); let mut result = if est_tokens > GATE_TOKENS { self.turn_digest(text, &eff_ids, gen_len)? } else { let exp = Experience::with_text(eff_ids, vec![], vec![], text.to_string(), "user"); self.capture_and_route(exp, gen_len)? }; result.recalled_context = recalled; result.duration_ms = t0.elapsed().as_secs_f32() * 1000.0; Ok(result) } /// Digestion path (PRD section 4 pre-step): chew -> extract -> reduce -> /// validate each leaf -> commit trains on the compressed form. fn turn_digest(&mut self, text: &str, doc_ids: &[u32], _gen_len: usize) -> Result { let doc = digestion::digest_document(text, self.tokenizer.as_ref(), self.embedder.as_ref()); let doc_ref = format!("d{}", self.step); for (leaf_id, vec) in doc.leaves.iter().zip(doc.leaf_vectors.iter()) { let _ = self.vector_index.add(&leaf_id.chunk_id, vec.clone()); } for (subj, rel, obj) in doc.root_triples(&doc_ref) { self.memory.semantic.add(crate::memory::Triple { subject: subj, relation: rel, object: obj, source_exp: doc_ref.to_string(), }); } let mut verdicts: Vec<(String, Verdict, f32)> = Vec::new(); let mut first_score: Option = None; let mut first_verdict: Option = None; for exp in doc.experiences() { let score = self.judge.score(&exp); let verdict = score.verdict(); match verdict { Verdict::Commit => { for c in &exp.claims { self.memory.semantic.add(crate::memory::Triple { subject: format!("exp:{}", exp.id), relation: "claims".into(), object: c.clone(), source_exp: exp.id.clone(), }); } self.memory.episodic.record(exp.clone()); self.memory.replay.push(exp.clone()); } Verdict::Queue => { self.memory.ledger.push(exp.clone(), now_secs()); } Verdict::Reject => { log::info!("REJECT leaf {} (trust={:.3})", exp.id, score.total); } } if first_score.is_none() { first_score = Some(score.clone()); first_verdict = Some(verdict); } verdicts.push((exp.id, verdict, score.total)); } let _ = doc_ids; // conditioning ids reserved for BPE-tokenizer parity Ok(TurnResult { output_ids: Vec::new(), score: first_score.unwrap_or_default(), verdict: first_verdict.unwrap_or(Verdict::Reject), verdicts, confidence: 1.0, beam_used: false, recalled_context: Vec::new(), duration_ms: 0.0, revision: None, final_output_ids: Vec::new(), }) } // ------------------------------------------------------------------ // background trainer (step 4 continued): VALIDATED backlog only // ------------------------------------------------------------------ /// LoRA micro-steps against the committed replay backlog. Mutates ONLY /// the standby buffer, then publishes atomically. pub fn background_micro_steps(&mut self, n: usize) -> Result> { let sample: Vec = { let picked = self.memory.replay.sample(n); picked.into_iter().cloned().collect() }; if sample.is_empty() { return Ok(vec![]); } let mut standby = self.adapters.standby_clone(); let mut losses = Vec::with_capacity(sample.len()); for exp in &sample { if let Some(&target) = exp.output.last() { let loss = self.student .train_step_on(&exp.input, target, &mut standby, self.lr)?; losses.push(loss); } } self.adapters.publish(standby); self.student.set_adapter(self.adapters.active()); Ok(losses) } // ------------------------------------------------------------------ // re-validation pass over queued items (verdict table: QUEUE) // ------------------------------------------------------------------ pub fn revalidate_queued(&mut self, k: usize) -> Result { let batch = self.memory.ledger.drain(k); let mut promoted = 0; for mut exp in batch { let score = self.judge.score(&exp); match score.verdict() { Verdict::Commit => { self.memory.episodic.record(exp.clone()); self.memory.replay.push(exp.clone()); promoted += 1; } Verdict::Queue => self.memory.ledger.push(exp, now_secs()), Verdict::Reject => { log::info!("REJECT on revalidation (trust={:.3})", score.total); } } } Ok(promoted) } // ------------------------------------------------------------------ // step 5: skill lifecycle // ------------------------------------------------------------------ pub fn observe_skill(&mut self, name: &str, success: bool) { self.memory.skills.observe(name, success, now_secs()); } /// Stale -> rehearsal due-list; rotten -> archived. Pure bookkeeping here; /// the serving layer schedules synthetic rehearsals for returned skills. pub fn skill_maintenance(&mut self) -> (Vec, Vec) { let now = now_secs(); let mut rehearse = Vec::new(); let mut rotten = Vec::new(); let names: Vec = self.memory.skills.skills.keys().cloned().collect(); for name in names { let st = self.memory.skills.staleness(&name, now); if st > ROTTEN_SECONDS { rotten.push(name.clone()); } else if st > STALE_SECONDS { rehearse.push(name.clone()); } } for r in &rotten { self.archived_skills.push(r.clone()); self.memory.skills.skills.remove(r); } (rehearse, rotten) } fn emit(&self, kind: &str, v: serde_json::Value) { if let Some(f) = &self.event_sink { f(kind, &v); } } } fn now_secs() -> f64 { std::time::SystemTime::now() .duration_since(std::time::UNIX_EPOCH) .map(|d| d.as_secs_f64()) .unwrap_or(0.0) } #[cfg(test)] mod tests { use super::*; use crate::lora::RANK; use crate::model::{MockJudge, SanConfig}; fn cfg() -> SanConfig { SanConfig { vocab: 64, d_model: 16, n_layers: 2, ffn_ratio: 2, n_heads: 2, max_seq_len: 32, tied_embeddings: true, } } fn eco() -> Ecosystem { let student = crate::main_helpers::random_student(&cfg()); Ecosystem::new(student, Box::new(MockJudge), 64, 0.02) } #[test] fn reject_is_captured_but_never_replayed() { struct AlwaysReject; impl Judge for AlwaysReject { fn score(&self, _: &Experience) -> TrustScore { TrustScore::combine(0.0, 0.0, 0.0, 0.0, 0.0) } } let student = crate::main_helpers::random_student(&cfg()); let mut e = Ecosystem::new(student, Box::new(AlwaysReject), 64, 0.01); let r = e.turn(&[1, 2, 3, 4], 3).unwrap(); assert_eq!(r.verdict, Verdict::Reject); assert_eq!(e.memory.episodic.len(), 1, "captured immediately"); assert_eq!(e.memory.replay.items.len(), 0, "replay = committed only"); assert!(e.memory.ledger.is_empty()); } #[test] fn queue_lands_in_ledger_then_revalidates() { struct AlwaysQueue; impl Judge for AlwaysQueue { fn score(&self, _: &Experience) -> TrustScore { TrustScore::combine(0.5, 0.5, 0.5, 0.5, 0.5) // total .5 => QUEUE } } let student = crate::main_helpers::random_student(&cfg()); let mut e = Ecosystem::new(student, Box::new(AlwaysQueue), 64, 0.01); e.turn(&[5, 6, 7], 2).unwrap(); assert_eq!(e.memory.ledger.len(), 1); assert_eq!(e.memory.replay.items.len(), 0, "queue must NOT hit replay"); struct Promote; impl Judge for Promote { fn score(&self, _: &Experience) -> TrustScore { TrustScore::combine(1.0, 1.0, 1.0, 1.0, 1.0) // COMMIT } } e.judge = Box::new(Promote); let promoted = e.revalidate_queued(4).unwrap(); assert_eq!(promoted, 1); assert_eq!(e.memory.replay.items.len(), 1); assert!(e.memory.ledger.is_empty()); } #[test] fn commit_trains_only_the_adapter() { struct AlwaysCommit; impl Judge for AlwaysCommit { fn score(&self, _: &Experience) -> TrustScore { TrustScore::combine(1.0, 1.0, 1.0, 1.0, 1.0) } } let student = crate::main_helpers::random_student(&cfg()); let mut e = Ecosystem::new(student, Box::new(AlwaysCommit), 64, 0.05); let base_before = e.student.params["tok_emb.weight"].clone(); let ad_before = e.adapters.active().checksum(); e.turn(&[9, 8, 7, 6], 3).unwrap(); assert_eq!(e.memory.replay.items.len(), 1); let losses = e.background_micro_steps(4).unwrap(); assert!(!losses.is_empty()); assert_eq!( e.student.params["tok_emb.weight"], base_before, "base frozen" ); assert_ne!( e.adapters.active().checksum(), ad_before, "adapter trained + published" ); assert_eq!(e.adapters.active().param_count() > 0, true); let _ = RANK; } #[test] fn digestion_gate_chews_long_inputs() { let mut e = eco(); let short = "Short note about cats."; let r = e.turn_text(short, &[1, 2], 2).unwrap(); assert!(r.verdicts.len() <= 1, "short input bypasses digestion"); let filler = "The System implies stability because checks run first. Then set values. "; let long_doc = filler.repeat(60); // >> 256 words let r2 = e.turn_text(&long_doc, &[3, 4], 2).unwrap(); assert!(r2.verdicts.len() > 1, "long input must be chewed into leaves"); assert!( e.memory.semantic.triples.iter().any(|t| t.relation == "summarizes"), "ROOT cluster triples stored" ); } #[test] fn recall_surfaces_committed_history() { let mut e = eco(); e.turn_text("unique zebra crossing protocol", &[1, 2], 2).unwrap(); let r = e.turn_text("tell me about the zebra crossing", &[3, 4], 2).unwrap(); assert!( r.recalled_context.iter().any(|c| c.contains("zebra")), "BM25 recall must surface prior episode" ); } #[test] fn low_confidence_triggers_guided_beam() { struct PreferSeven; impl Judge for PreferSeven { fn score(&self, exp: &Experience) -> TrustScore { let hit = exp.output.iter().any(|&t| t % 11 == 7); TrustScore::combine(1.0, 1.0, if hit { 1.0 } else { 0.2 }, 1.0, 1.0) } } let student = crate::main_helpers::random_student(&cfg()); let mut e = Ecosystem::new(student, Box::new(PreferSeven), 16, 0.0); // direct guided call: whatever the init confidence, both paths must work let (_out, _used) = e.generate_guided(&[1, 2, 3], 4).unwrap(); let r = e.turn(&[4, 5, 6], 3).unwrap(); assert!((0.0..=1.0).contains(&r.confidence)); } #[test] fn skill_lifecycle_stale_and_rotten() { let mut e = eco(); e.observe_skill("search", true); // backdate by rewriting timestamp let old = now_secs() - (40.0 * 24.0 * 3600.0); e.memory.skills.skills.get_mut("search").unwrap().last_used_ts = old; let (rehearse, rotten) = e.skill_maintenance(); assert!(rotten.contains(&"search".to_string())); assert!(rehearse.is_empty()); assert!(e.archived_skills.contains(&"search".to_string())); assert!(!e.memory.skills.skills.contains_key("search")); } } #[cfg(test)] mod screore_tests { use super::*; use crate::model::SanConfig; fn cfg() -> SanConfig { SanConfig { vocab: 64, d_model: 16, n_layers: 2, ffn_ratio: 2, n_heads: 2, max_seq_len: 32, tied_embeddings: true } } /// Bare prompts land in the QUEUE band; anything enriched with judge /// feedback / beam context (tokens beyond the tiny prompt alphabet) /// is COMMIT-grade. struct ImproveAfterFirst; impl Judge for ImproveAfterFirst { fn score(&self, e: &Experience) -> TrustScore { let bare = e.input.iter().all(|&t| t < 16); if e.text.starts_with("[revision") || !e.output.is_empty() && e.input.len() > 8 { TrustScore::combine(1.0, 1.0, 1.0, 1.0, 1.0) } else if bare && e.source == "user" { TrustScore::combine(0.5, 0.5, 0.5, 0.5, 0.5) // 0.50 QUEUE } else { TrustScore::combine(1.0, 1.0, 1.0, 1.0, 1.0) } } } #[test] fn revision_promotes_and_links_pair() { let student = crate::main_helpers::random_student(&cfg()); let mut e = Ecosystem::new(student, Box::new(ImproveAfterFirst), 64, 0.02); e.revisions_enabled = true; let r = e.turn(&[3, 1, 4], 4).unwrap(); assert!(r.revision.is_some(), "QUEUE must trigger a revision turn"); let rev = r.revision.unwrap(); assert_eq!(rev.first_trust, 0.5); assert!(rev.accepted); assert_eq!(e.sc_attempts, 1); assert_eq!(e.sc_hits, 1); // pair anchored in replay with lineage + advantage let items: Vec<&Experience> = e.memory.replay.items.iter().collect(); assert_eq!(items.len(), 2, "attempt-1 context + revision both trained on"); let child = items.iter().find(|x| x.parent_exp_id.is_some()).unwrap(); assert_eq!(child.advantage > 1.0, true); let parent_id = child.parent_exp_id.clone().unwrap(); assert!(items.iter().any(|x| x.id == parent_id)); assert!(!r.final_output_ids.is_empty() || !r.output_ids.is_empty()); } #[test] fn revisions_can_be_disabled() { struct AlwaysQueue; impl Judge for AlwaysQueue { fn score(&self, _: &Experience) -> TrustScore { TrustScore::combine(0.5,0.5,0.5,0.5,0.5) } } let student = crate::main_helpers::random_student(&cfg()); let mut e = Ecosystem::new(student, Box::new(AlwaysQueue), 64, 0.01); e.revisions_enabled = false; let r = e.turn(&[1, 2], 2).unwrap(); assert!(r.revision.is_none()); assert_eq!(e.sc_attempts, 0); assert_eq!(e.memory.replay.items.len(), 0, "still never replayed"); assert_eq!(e.memory.ledger.len(), 1); } #[test] fn advantage_scales_training_lr() { struct AlwaysCommit; impl Judge for AlwaysCommit { fn score(&self, _: &Experience) -> TrustScore { TrustScore::combine(1.0,1.0,1.0,1.0,1.0) } } let student = crate::main_helpers::random_student(&cfg()); let mut e = Ecosystem::new(student, Box::new(AlwaysCommit), 64, 0.05); let base_before = e.student.params["tok_emb.weight"].clone(); e.turn(&[7, 8, 9], 3).unwrap(); // two identical experiences, different advantages for adv in [2.0f32, 0.5f32] { let mut x = Experience::with_text(vec![11u32, 12], vec![13], vec![], "pair".into(), "s"); x.advantage = adv; e.memory.replay.push(x); } let losses = e.background_micro_steps(4).unwrap(); assert_eq!(losses.len(), 3); // 1 committed turn + 2 pair members; // replay had 1 committed + 2 pushed assert_eq!(e.student.params["tok_emb.weight"], base_before, "base frozen under weighted steps"); } }