alter_ego / serving /src /ecosystem.rs
geraldaton20's picture
initial upload: source code (no build artifacts)
f4f166e verified
Raw History Blame Contribute Delete
32.7 kB
//! 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<u32>,
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<String>,
/// SCoRe-lite revision episode (when a low-trust first attempt triggered
/// a second pass).
pub revision: Option<RevisionInfo>,
/// What the user actually receives (revision if it scored higher).
pub final_output_ids: Vec<u32>,
/// 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<dyn Judge>,
pub memory: TriMemory,
pub adapters: Arc<AdapterHandle>,
pub lr: f32,
pub step: usize,
pub tokenizer: Box<dyn Tokenizer>,
pub embedder: Box<dyn Embedder>,
pub archived_skills: Vec<String>,
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<std::sync::Arc<dyn Fn(&str, &serde_json::Value) + Send + Sync>>,
rng: Rng,
}
impl Ecosystem {
pub fn new(
mut student: San,
judge: Box<dyn Judge>,
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<dyn Judge>,
replay_max: usize,
lr: f32,
) -> Result<Self> {
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<f32> {
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<f32> = 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<Vec<u32>> {
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<Vec<u32>> {
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<f32> = 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<u32>, 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<u32>, 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<TurnResult> {
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<Option<(Experience, TrustScore, Verdict)>> {
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<u32> = 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<TurnResult> {
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<Vec<u32>> {
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<dyn Tokenizer>) {
self.tokenizer = t;
self.recall_conditioning = true;
}
pub fn set_embedder(&mut self, e: Box<dyn Embedder>) {
self.embedder = e;
}
pub fn turn_text(
&mut self,
text: &str,
input_ids: &[u32],
gen_len: usize,
) -> Result<TurnResult> {
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<u32> = 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<u32> = ctx_ids
.into_iter()
.rev()
.take(budget)
.collect::<Vec<_>>()
.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<TurnResult> {
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<TrustScore> = None;
let mut first_verdict: Option<Verdict> = 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<Vec<f32>> {
let sample: Vec<Experience> = {
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<usize> {
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<String>, Vec<String>) {
let now = now_secs();
let mut rehearse = Vec::new();
let mut rotten = Vec::new();
let names: Vec<String> = 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");
}
}