alter_ego / serving /src /og_backend.rs
geraldaton20's picture
initial upload: source code (no build artifacts)
f4f166e verified
Raw History Blame Contribute Delete
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);
}));
}
}