//! 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>, session_id: String, next_id: Mutex, forgotten: Mutex>, } 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>, session_id: impl Into) -> 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 { 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> { 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, } impl VerificationTier for TrustVerificationTier { fn name(&self) -> &'static str { "alter-ego-trust" } fn classify(&self, question: &str, answer: &str) -> Verdict { let ids: Vec = 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); })); } }