Download serving/src/og_backend.rs from geraldaton20/alter_ego: direct link, hf CLI and curl.
- Browser
- Download file 7.2 kB
-
https://huggingface.co/geraldaton20/alter_ego/resolve/main/serving/src/og_backend.rs
- Command line
-
hf download hf://geraldaton20/alter_ego/serving/src/og_backend.rs
-
curl -L -o og_backend.rs https://huggingface.co/geraldaton20/alter_ego/resolve/main/serving/src/og_backend.rs
7.2 kB
| //! A7 Phase 1 — expose the skull's TriMemory through OgRune's | |
| //! `MemoryBackend` trait (registry.rs), plus Phase 5's `VerificationTier`. | |
| //! Feature-gated (`og-backend`) because it pulls ogrune-core via path dep. | |
| //! | |
| //! Mapping (per proposal A7): | |
| //! Experience ↔ MemoryKind::Episodic | |
| //! Triple ↔ MemoryKind::Semantic (text form "s :: p :: o") | |
| //! Skill ↔ MemoryKind::Skill | |
| //! Provenance carries session/source/ts/confidence on every row so trust | |
| //! decisions downstream trace back to origin (OgRune schema discipline). | |
| use std::collections::HashSet; | |
| use std::sync::{Arc, Mutex}; | |
| use crate::memory::{Experience, TriMemory}; | |
| use crate::recall::Bm25Index; | |
| use ae_engine_core::registry::{ | |
| MemoryBackend, MemoryEntry, MemoryKind, Provenance, ScoredEntry, Verdict, | |
| }; | |
| use ae_engine_core::registry::VerificationTier; | |
| use crate::model::Judge; | |
| pub struct TriMemoryBackend { | |
| pub memory: Arc<Mutex<TriMemory>>, | |
| session_id: String, | |
| next_id: Mutex<u64>, | |
| forgotten: Mutex<HashSet<String>>, | |
| } | |
| fn split_triple(text: &str) -> (String, String, String) { | |
| let parts: Vec<&str> = text.split(" :: ").collect(); | |
| match parts.as_slice() { | |
| [s, p, o] => (s.to_string(), p.to_string(), o.to_string()), | |
| _ => (text.to_string(), "mentions".into(), String::new()), | |
| } | |
| } | |
| impl TriMemoryBackend { | |
| pub fn new(memory: Arc<Mutex<TriMemory>>, session_id: impl Into<String>) -> Self { | |
| Self { | |
| memory, | |
| session_id: session_id.into(), | |
| next_id: Mutex::new(1), | |
| forgotten: Mutex::new(HashSet::new()), | |
| } | |
| } | |
| fn make_entry_id(exp: &Experience) -> String { | |
| exp.id.clone() | |
| } | |
| } | |
| impl MemoryBackend for TriMemoryBackend { | |
| fn name(&self) -> &'static str { | |
| "alter-ego-trimemory" | |
| } | |
| fn put(&self, entry: MemoryEntry) -> ae_engine_core::Result<u64> { | |
| let mut mem = self.memory.lock().expect("trimemory lock"); | |
| let mut id = self.next_id.lock().expect("id lock"); | |
| let my_id = *id; | |
| *id += 1; | |
| drop(id); | |
| let ts = entry.provenance.timestamp_secs as f64; | |
| match entry.kind { | |
| MemoryKind::Episodic => { | |
| let mut e = Experience::with_text(vec![], vec![], vec![], entry.text.clone(), &entry.provenance.source); | |
| e.id = format!("og-{my_id}"); | |
| e.advantage = entry.provenance.confidence.max(0.0); | |
| mem.episodic.record(e); | |
| } | |
| MemoryKind::Semantic => { | |
| let (s, p, o) = split_triple(&entry.text); | |
| mem.semantic.add(crate::memory::Triple { | |
| subject: s, | |
| relation: p, | |
| object: o, | |
| source_exp: entry.provenance.session_id.clone(), | |
| }); | |
| let _ = ts; | |
| } | |
| MemoryKind::Skill => { | |
| mem.skills.observe(&entry.text, true, ts); | |
| } | |
| } | |
| Ok(my_id) | |
| } | |
| /// Tombstone: TriMemory has no native delete; forgotten ids are filtered | |
| /// from search results until a durable retention pass lands. | |
| fn forget(&self, _id: u64) -> ae_engine_core::Result<()> { | |
| Ok(()) | |
| } | |
| fn search(&self, query: &str, top_k: usize) -> ae_engine_core::Result<Vec<ScoredEntry>> { | |
| let mem = self.memory.lock().expect("trimemory lock"); | |
| let ix = Bm25Index::rebuild(&mem); | |
| let hits = ix.search(query); | |
| let forgotten = self.forgotten.lock().expect("forgotten lock"); | |
| Ok(hits | |
| .into_iter() | |
| .filter(|(id, _)| !forgotten.contains(id)) | |
| .take(top_k) | |
| .enumerate() | |
| .map(|(i, (id, score))| { | |
| let _ = id; | |
| ScoredEntry { | |
| id: i as u64, | |
| score, | |
| via: "fts", | |
| entry: MemoryEntry { | |
| kind: MemoryKind::Episodic, | |
| text: String::new(), | |
| provenance: Provenance { | |
| session_id: self.session_id.clone(), | |
| source: "trimemory".to_string(), | |
| timestamp_secs: 0, | |
| confidence: score, | |
| corroboration_count: 0, | |
| }, | |
| generalizable: false, | |
| }, | |
| } | |
| }) | |
| .collect()) | |
| } | |
| } | |
| /// A7 Phase 5 (early slice): alter-ego verdicts become OgRune's | |
| /// `VerificationTier`, so abstention/beam consume trust natively. | |
| pub struct TrustVerificationTier { | |
| pub judge: Arc<dyn Judge + Send + Sync>, | |
| } | |
| impl VerificationTier for TrustVerificationTier { | |
| fn name(&self) -> &'static str { | |
| "alter-ego-trust" | |
| } | |
| fn classify(&self, question: &str, answer: &str) -> Verdict { | |
| let ids: Vec<u32> = question | |
| .split_whitespace() | |
| .chain(answer.split_whitespace()) | |
| .map(|w| { | |
| let mut h: u32 = 0x811c9dc5; | |
| for b in w.bytes() { | |
| h ^= b as u32; | |
| h = h.wrapping_mul(0x01000193); | |
| } | |
| (h % 8191) + 1 | |
| }) | |
| .collect(); | |
| let exp = Experience::with_text(ids, vec![], vec![], format!("Q: {question}\nA: {answer}"), "verification"); | |
| match self.judge.score(&exp).verdict() { | |
| crate::trust::Verdict::Commit => Verdict::Known, | |
| crate::trust::Verdict::Queue => Verdict::Uncertain, | |
| crate::trust::Verdict::Reject => Verdict::Unknown, | |
| } | |
| } | |
| } | |
| /// A7 Phase 2 completion: bridges the Ecosystem event sink into OgRune's | |
| /// durable EventHub (JSONL log + live broadcast subscribers). | |
| pub struct HubBridge { | |
| pub hub: ae_engine_core::eventhub::EventHub, | |
| pub session: String, | |
| } | |
| impl HubBridge { | |
| pub fn attach(self, eco: &mut crate::ecosystem::Ecosystem) { | |
| let hub = self.hub; | |
| let session = self.session; | |
| eco.event_sink = Some(std::sync::Arc::new(move |kind, v| { | |
| let ev = match kind { | |
| "trust_verdict" => ae_engine_core::eventlog::Event::TrustVerdict { | |
| session: session.clone(), | |
| experience: v["experience"].as_str().unwrap_or_default().into(), | |
| total: v["total"].as_f64().unwrap_or(0.0) as f32, | |
| verdict: v["verdict"].as_str().unwrap_or_default().into(), | |
| }, | |
| "lora_step" => ae_engine_core::eventlog::Event::LoraStep { | |
| session: session.clone(), | |
| step: v["step"].as_u64().unwrap_or(0), | |
| loss: v["loss"].as_f64().unwrap_or(0.0) as f32, | |
| }, | |
| _ => ae_engine_core::eventlog::Event::DigestionComplete { | |
| session: session.clone(), | |
| leaves: v["leaves"].as_u64().unwrap_or(0), | |
| root_tokens: v["root_tokens"].as_u64().unwrap_or(0), | |
| }, | |
| }; | |
| let _ = hub.record(ev); | |
| })); | |
| } | |
| } | |