Make Codex and Claude Code subscriptions go further: a local model router that gives routine agent work to economical models and keeps your strongest model for the hard parts.
Rust ai-agentsai-gatewayclaude-codecodexcoding-agentcost-optimizationdeepseekllm-gatewayllm-routerlocal-firstmodel-routingrusttask-routingtauri
//! Authenticated HMAC-only native evidence. Edge/node ordering, quarantine and
//! deletion are shared by every analysis facet; arrival never renews a proof.
use super::schema;
use crate::{LocalObservationStore, query_v2::ObservationV2Error as Error};
use hiroute_domain::*;
use rusqlite::{Connection, OptionalExtension, params};
use std::cmp::Ordering;
#[derive(Clone)]
struct Prior {
active: bool,
observation: NativeProofObservationV1,
}
fn order(a: &NativeProofObservationV1, b: &NativeProofObservationV1) -> Option<Ordering> {
if a.observer_id == b.observer_id {
Some(a.sequence.cmp(&b.sequence))
} else {
match a.observed_at_ms.cmp(&b.observed_at_ms) {
Ordering::Equal => None,
order => Some(order),
}
}
}
fn valid_stamp(s: &NativeProofObservationV1) -> bool {
!s.observer_id.is_empty()
&& s.observer_id.len() <= 128
&& s.sequence > 0
&& s.observed_at_ms >= 0
&& s.age_ms <= 3_600_000
}
fn stamp_key(w: &str, parent: &str, child: &str) -> Result<String, Error> {
Ok(format!(
"edge-stamp/{}",
CanonicalDigest::of(&(w, parent, child)).map_err(|_| Error::Invalid)?
))
}
fn latest(db: &Connection, w: &str, parent: &str, child: &str) -> Result<Option<Prior>, Error> {
let row:Option<(bool,String,String,i64)>=db.query_row("SELECT active,observer_id,sequence,observed_ms FROM observation_native_relations_v1 WHERE workspace_id=?1 AND parent_id=?2 AND child_id=?3 ORDER BY revision DESC LIMIT 1",params![w,parent,child],|r|Ok((r.get(0)?,r.get(1)?,r.get(2)?,r.get(3)?))).optional()?;
let mut prior = row
.map(|(active, id, seq, at)| {
Ok::<_, Error>(Prior {
active,
observation: NativeProofObservationV1 {
observer_id: id,
sequence: seq.parse().map_err(|_| Error::Unavailable)?,
observed_at_ms: at,
age_ms: 0,
},
})
})
.transpose()?;
if let Some(p) = &mut prior {
let extra: Option<String> = db
.query_row(
"SELECT value FROM observation_analysis_meta_v1 WHERE key=?1",
[stamp_key(w, parent, child)?],
|r| r.get(0),
)
.optional()?;
if let Some(body) = extra {
p.observation = serde_json::from_str(&body).map_err(|_| Error::Unavailable)?;
}
}
Ok(prior)
}
fn put_edge(
db: &Connection,
e: &NativeContinuationEvidenceV1,
parent: &str,
child: &str,
mut active: bool,
stamp: &NativeProofObservationV1,
) -> Result<(), Error> {
if let Some(old) = latest(db, &e.workspace_id, parent, child)? {
match order(stamp, &old.observation) {
Some(Ordering::Less | Ordering::Equal) => return Ok(()),
None => {
if !old.active {
return Ok(());
}
active = false;
}
Some(Ordering::Greater) => {}
}
if old.active == active {
// Keep the latest *observed* stamp without mutating the immutable
// R row or refreshing its source provenance on a cached replay.
let body = serde_json::to_string(stamp).map_err(|_| Error::Invalid)?;
db.execute("INSERT INTO observation_analysis_meta_v1 VALUES(?1,?2) ON CONFLICT(key) DO UPDATE SET value=excluded.value",params![stamp_key(&e.workspace_id,parent,child)?,body])?;
return Ok(());
}
}
let revision = schema::advance(db, &format!("relation_revision/{}", e.workspace_id))?;
let proof = CanonicalDigest::of(&(&stamp.observer_id, stamp.sequence, stamp.observed_at_ms))
.map_err(|_| Error::Invalid)?
.to_string();
db.execute(
"INSERT INTO observation_native_relations_v1 VALUES(?1,?2,?3,?4,?5,?6,?7,?8,?9,?10,?11)",
params![
e.workspace_id,
revision,
parent,
child,
active,
stamp.observer_id,
stamp.sequence.to_string(),
stamp.observed_at_ms,
e.ingress_at_ms,
e.request_id,
proof
],
)?;
let body = serde_json::to_string(stamp).map_err(|_| Error::Invalid)?;
db.execute("INSERT INTO observation_analysis_meta_v1 VALUES(?1,?2) ON CONFLICT(key) DO UPDATE SET value=excluded.value",params![stamp_key(&e.workspace_id,parent,child)?,body])?;
Ok(())
}
fn current_state(
db: &Connection,
e: &NativeContinuationEvidenceV1,
state: &NativeCurrentStateV1,
) -> Result<(), Error> {
let prior:Option<(String,String,i64)>=db.query_row("SELECT observer_id,sequence,observed_ms FROM observation_native_states_v1 WHERE workspace_id=?1 AND session_id=?2",params![e.workspace_id,e.current_session_id],|r|Ok((r.get(0)?,r.get(1)?,r.get(2)?))).optional()?;
if let Some((id, seq, at)) = prior {
let old = NativeProofObservationV1 {
observer_id: id,
sequence: seq.parse().map_err(|_| Error::Unavailable)?,
observed_at_ms: at,
age_ms: 0,
};
if order(&state.observation, &old) != Some(Ordering::Greater) {
return Ok(());
}
}
let name = match state.value {
NativeSessionStateV1::Open => "open",
NativeSessionStateV1::CompressionClosed => "compression_closed",
NativeSessionStateV1::OtherClosed => "other_closed",
};
db.execute("INSERT INTO observation_native_states_v1 VALUES(?1,?2,?3,?4,?5,?6) ON CONFLICT(workspace_id,session_id) DO UPDATE SET state=excluded.state,observer_id=excluded.observer_id,sequence=excluded.sequence,observed_ms=excluded.observed_ms",params![e.workspace_id,e.current_session_id,name,state.observation.observer_id,state.observation.sequence.to_string(),state.observation.observed_at_ms])?;
if state.value != NativeSessionStateV1::CompressionClosed {
for (parent, child) in incident(db, &e.workspace_id, &e.current_session_id, true)? {
put_edge(db, e, &parent, &child, false, &state.observation)?;
}
}
Ok(())
}
fn incident(
db: &Connection,
w: &str,
id: &str,
outgoing: bool,
) -> Result<Vec<(String, String)>, Error> {
let mut stmt=db.prepare("SELECT e.parent_id,e.child_id FROM observation_native_relations_v1 e WHERE e.workspace_id=?1
AND (e.parent_id=?2 OR (?3=0 AND e.child_id=?2)) AND e.active=1
AND e.revision=(SELECT MAX(new.revision) FROM observation_native_relations_v1 new WHERE new.workspace_id=e.workspace_id AND new.parent_id=e.parent_id AND new.child_id=e.child_id)")?;
Ok(stmt
.query_map(params![w, id, outgoing], |r| Ok((r.get(0)?, r.get(1)?)))?
.collect::<Result<_, _>>()?)
}
fn state_allows(
db: &Connection,
e: &NativeContinuationEvidenceV1,
parent: &str,
) -> Result<bool, Error> {
let prior:Option<(String,String,String,i64)>=db.query_row("SELECT state,observer_id,sequence,observed_ms FROM observation_native_states_v1 WHERE workspace_id=?1 AND session_id=?2",params![e.workspace_id,parent],|r|Ok((r.get(0)?,r.get(1)?,r.get(2)?,r.get(3)?))).optional()?;
let Some((state, id, seq, at)) = prior else {
return Ok(true);
};
if state == "compression_closed" {
return Ok(true);
}
let stamp = NativeProofObservationV1 {
observer_id: id,
sequence: seq.parse().map_err(|_| Error::Unavailable)?,
observed_at_ms: at,
age_ms: 0,
};
Ok(e.proof_observation
.as_ref()
.is_some_and(|p| order(p, &stamp) == Some(Ordering::Greater)))
}
fn retained(
db: &Connection,
input: &NativeContinuationEvidenceV1,
) -> Result<Option<NativeContinuationEvidenceV1>, Error> {
let mut e = input.clone();
let mut ids = e.ids.clone();
if let Some(n) = &e.invalid_edges {
for pair in &n.edges {
ids.extend(pair.iter().cloned());
}
}
let json = serde_json::to_string(&ids).map_err(|_| Error::Invalid)?;
let mut stmt=db.prepare("SELECT c.session_id,c.through_ms FROM observation_analysis_cuts_v1 c WHERE c.workspace_id=?1 AND c.session_id IN(SELECT value FROM json_each(?2))")?;
let cuts = stmt
.query_map(params![e.workspace_id, json], |r| {
Ok((r.get::<_, String>(0)?, r.get::<_, i64>(1)?))
})?
.collect::<Result<std::collections::BTreeMap<_, _>, _>>()?;
if cuts
.get(&e.current_session_id)
.is_some_and(|through| e.ingress_at_ms <= *through)
{
return Ok(None);
}
let mut start = 0;
for (index, pair) in e.ids.windows(2).enumerate() {
if (cuts.contains_key(&pair[0]) || cuts.contains_key(&pair[1]))
&& !super::native_origin::edge_retained(
db,
&e.workspace_id,
&pair[0],
&pair[1],
e.proof_observation
.as_ref()
.map_or(-1, |s| s.observed_at_ms),
)?
{
start = index + 1;
}
}
if start > 0 || cuts.contains_key(&e.ids[0]) {
e.ids = e.ids[start..].to_vec();
e.complete = false;
}
if let Some(n) = &mut e.invalid_edges {
let mut kept = Vec::new();
for [p, c] in &n.edges {
if (!cuts.contains_key(p) && !cuts.contains_key(c))
|| super::native_origin::edge_retained(
db,
&e.workspace_id,
p,
c,
n.observation.observed_at_ms,
)?
{
kept.push([p.clone(), c.clone()]);
}
}
n.edges = kept;
if n.edges.is_empty() {
e.invalid_edges = None;
}
}
Ok(Some(e))
}
fn store_event(db: &Connection, e: &NativeContinuationEvidenceV1, body: &str) -> Result<(), Error> {
db.execute("INSERT INTO observation_native_events_v1 VALUES(?1,?2,?3) ON CONFLICT(workspace_id,event_id) DO UPDATE SET body=excluded.body",params![e.workspace_id,e.event_id,body])?;
db.execute(
"DELETE FROM observation_native_event_members_v1 WHERE workspace_id=?1 AND event_id=?2",
params![e.workspace_id, e.event_id],
)?;
let mut ids = e
.ids
.iter()
.cloned()
.collect::<std::collections::BTreeSet<_>>();
if let Some(n) = &e.invalid_edges {
for [p, c] in &n.edges {
ids.insert(p.clone());
ids.insert(c.clone());
}
}
for id in ids {
db.execute(
"INSERT INTO observation_native_event_members_v1 VALUES(?1,?2,?3)",
params![e.workspace_id, id, e.event_id],
)?;
}
Ok(())
}
impl LocalObservationStore {
pub fn ingest_native_continuation(
&self,
e: &NativeContinuationEvidenceV1,
) -> Result<(), Error> {
if e.schema_version != NATIVE_CONTINUATION_SCHEMA_V1
|| WorkspaceId::parse(&e.workspace_id).is_err()
|| LogicalRequestId::parse(&e.request_id).is_err()
|| e.ids.is_empty()
|| e.ids.len() > 32
|| e.ids.last() != Some(&e.current_session_id)
|| e.proof_observation
.as_ref()
.is_some_and(|p| !valid_stamp(p))
|| e.proof_observation.is_none()
&& (e.ids.len() != 1
|| e.complete
|| e.current_state.is_some()
|| e.invalid_edges.is_some())
|| e.ingress_at_ms < 0
|| e.ids.iter().any(|id| SessionId::parse(id).is_err())
|| e.ids
.iter()
.collect::<std::collections::BTreeSet<_>>()
.len()
!= e.ids.len()
{
return Err(Error::Invalid);
}
if e.current_state
.as_ref()
.is_some_and(|s| !valid_stamp(&s.observation) || s.observation.age_ms > 1000)
|| e.invalid_edges
.as_ref()
.is_some_and(|n| !valid_stamp(&n.observation) || n.edges.len() > 31)
{
return Err(Error::Invalid);
}
if serde_json::to_vec(e).map_err(|_| Error::Invalid)?.len() > 32 * 1024 {
return Err(Error::Invalid);
}
let mut db = self.connection.lock();
if !schema::available(&db) {
return Err(Error::Unavailable);
}
let tx = db.transaction()?;
// A replay from covered history must not install origin evidence after
// a full deletion removed that member's reverse references.
let deleted:bool=tx.query_row("SELECT EXISTS(SELECT 1 FROM observation_analysis_cuts_v1 WHERE workspace_id=?1 AND session_id=?2 AND through_ms>=?3)",params![e.workspace_id,e.current_session_id,e.ingress_at_ms],|r|r.get(0))?;
if deleted {
return Ok(());
}
super::native_origin::record(&tx, e)?;
let Some(e) = retained(&tx, e)? else {
return Ok(());
};
let mut e = e;
// Older retained readers deserialize this strict v1 body. The optional
// transport extension is persisted only in its additive origin table.
if let Some(state) = &mut e.current_state {
state.started_at_ms = None;
}
let e = &e;
let body = serde_json::to_string(e).map_err(|_| Error::Invalid)?;
let previous:Option<String>=tx.query_row("SELECT body FROM observation_native_events_v1 WHERE workspace_id=?1 AND event_id=?2",params![e.workspace_id,e.event_id],|r|r.get(0)).optional()?;
if let Some(previous) = previous {
if previous == body {
return Ok(());
}
return Err(Error::RelationshipConflict);
}
if let Some(state) = &e.current_state {
current_state(&tx, e, state)?;
}
if let Some(negative) = &e.invalid_edges {
for [parent, child] in &negative.edges {
put_edge(&tx, e, parent, child, false, &negative.observation)?;
}
}
for id in &e.ids {
tx.execute(
"INSERT OR IGNORE INTO observation_native_presence_v1 VALUES(?1,?2)",
params![e.workspace_id, id],
)?;
}
if e.complete
&& let Some(stamp) = &e.proof_observation
{
let proof_id =
CanonicalDigest::of(&(&stamp.observer_id, stamp.sequence, stamp.observed_at_ms))
.map_err(|_| Error::Invalid)?
.to_string();
tx.execute(
"INSERT OR IGNORE INTO observation_native_roots_v1 VALUES(?1,?2,?3,?4,?5)",
params![
e.workspace_id,
e.ids[0],
proof_id,
e.request_id,
stamp.observed_at_ms
],
)?;
}
for pair in e.ids.windows(2) {
let Some(proof) = &e.proof_observation else {
continue;
};
let (parent, child) = (&pair[0], &pair[1]);
if !state_allows(&tx, e, parent)? {
continue;
}
let mut competitors = incident(&tx, &e.workspace_id, parent, true)?;
competitors.extend(
incident(&tx, &e.workspace_id, child, false)?
.into_iter()
.filter(|(p, c)| c == child && p != parent),
);
competitors.retain(|(p, c)| p != parent || c != child);
if !competitors.is_empty() {
for (p, c) in competitors {
put_edge(&tx, e, &p, &c, false, proof)?;
}
put_edge(&tx, e, parent, child, false, proof)?;
} else {
put_edge(&tx, e, parent, child, true, proof)?;
}
}
store_event(&tx, e, &body)?;
tx.commit()?;
Ok(())
}
}
pub(crate) fn full_delete(
db: &Connection,
w: &str,
session: &str,
through: i64,
) -> rusqlite::Result<()> {
if !schema::available(db) {
return Ok(());
}
for table in [
"observation_analysis_attempts_v1",
"observation_analysis_recorded_v1",
"observation_analysis_requests_v1",
"observation_analysis_models_v1",
"observation_analysis_reasoning_v1",
"observation_analysis_turns_v1",
] {
db.execute(&format!("DELETE FROM {table} WHERE workspace_id=?1 AND request_id IN(SELECT request_id FROM logical_requests WHERE workspace_id=?1 AND session_id=?2)"),params![w,session])?;
}
db.execute("DELETE FROM observation_native_roots_v1 WHERE workspace_id=?1 AND (session_id=?2 OR request_id IN(SELECT request_id FROM logical_requests WHERE workspace_id=?1 AND session_id=?2))",params![w,session])?;
db.execute(
"DELETE FROM observation_native_presence_v1 WHERE workspace_id=?1 AND session_id=?2",
params![w, session],
)?;
db.execute(
"DELETE FROM observation_native_origins_v1 WHERE workspace_id=?1 AND session_id=?2",
params![w, session],
)?;
db.execute("INSERT INTO observation_analysis_cuts_v1 VALUES(?1,?2,?3,'full') ON CONFLICT(workspace_id,session_id,kind) DO UPDATE SET through_ms=MAX(through_ms,excluded.through_ms)",params![w,session,through])?;
let removed=db.execute("DELETE FROM observation_native_relations_v1 WHERE workspace_id=?1 AND (parent_id=?2 OR child_id=?2)",params![w,session])?;
if removed > 0 {
schema::advance(db, &format!("relation_revision/{w}"))?;
}
db.execute(
"DELETE FROM observation_native_states_v1 WHERE workspace_id=?1 AND session_id=?2",
params![w, session],
)?;
db.execute("DELETE FROM observation_analysis_members_v1 WHERE session_id=?2 AND scope_id IN(SELECT id FROM observation_analysis_scopes_v1 WHERE workspace_id=?1)",params![w,session])?;
// Preserve a still-proven suffix after the deleted bridge, while dropping
// its prefix and reverse references. This is retained observation evidence,
// never a replacement canonical execution/receipt payload.
while redact_events(db, w, Some(session), 200).map_err(|_| rusqlite::Error::InvalidQuery)?
== 200
{}
Ok(())
}
pub(super) fn redact_events(
db: &Connection,
w: &str,
session: Option<&str>,
limit: usize,
) -> Result<usize, Error> {
let mut stmt=db.prepare("SELECT DISTINCT e.event_id,e.body FROM observation_native_events_v1 e
JOIN observation_native_event_members_v1 m ON m.workspace_id=e.workspace_id AND m.event_id=e.event_id
JOIN observation_analysis_cuts_v1 c ON c.workspace_id=m.workspace_id AND c.session_id=m.session_id
WHERE e.workspace_id=?1 AND (?2 IS NULL OR m.session_id=?2)
AND ((m.session_id=json_extract(e.body,'$.current_session_id') AND json_extract(e.body,'$.ingress_at_ms')<=c.through_ms)
OR (json_extract(e.body,'$.complete')=1 AND m.session_id=json_extract(e.body,'$.ids[0]'))
OR EXISTS(SELECT 1 FROM json_each(e.body,'$.ids') n
WHERE CAST(n.key AS INTEGER)>0
AND c.session_id IN(n.value,json_extract(e.body,'$.ids['||(CAST(n.key AS INTEGER)-1)||']'))
AND NOT EXISTS(SELECT 1 FROM observation_native_origins_v1 o
WHERE o.workspace_id=e.workspace_id AND o.session_id=n.value AND o.not_before_ms>c.through_ms
AND o.not_before_ms<=json_extract(e.body,'$.proof_observation.observed_at_ms')-1000
AND NOT EXISTS(SELECT 1 FROM logical_requests r WHERE r.workspace_id=o.workspace_id AND r.session_id=o.session_id AND r.started_at_ms<o.not_before_ms)))
OR EXISTS(SELECT 1 FROM json_each(e.body,'$.invalid_edges.edges') n
WHERE c.session_id IN(json_extract(n.value,'$[0]'),json_extract(n.value,'$[1]'))
AND NOT EXISTS(SELECT 1 FROM observation_native_origins_v1 o
WHERE o.workspace_id=e.workspace_id AND o.session_id=json_extract(n.value,'$[1]') AND o.not_before_ms>c.through_ms
AND o.not_before_ms<=json_extract(e.body,'$.invalid_edges.observation.observed_at_ms')-1000
AND NOT EXISTS(SELECT 1 FROM logical_requests r WHERE r.workspace_id=o.workspace_id AND r.session_id=o.session_id AND r.started_at_ms<o.not_before_ms))))
ORDER BY e.event_id LIMIT ?3")?;
let events = stmt
.query_map(params![w, session, limit], |r| {
Ok((r.get::<_, String>(0)?, r.get::<_, String>(1)?))
})?
.collect::<Result<Vec<_>, _>>()?;
let mut count = 0;
for (id, body) in events {
let e: NativeContinuationEvidenceV1 =
serde_json::from_str(&body).map_err(|_| Error::Unavailable)?;
if let Some(retained) = retained(db, &e)? {
let next = serde_json::to_string(&retained).map_err(|_| Error::Unavailable)?;
if next != body {
store_event(db, &retained, &next)?;
count += 1;
}
} else {
db.execute(
"DELETE FROM observation_native_events_v1 WHERE workspace_id=?1 AND event_id=?2",
params![w, id],
)?;
db.execute("DELETE FROM observation_native_event_members_v1 WHERE workspace_id=?1 AND event_id=?2",params![w,id])?;
count += 1;
}
}
Ok(count)
}