Skip to content

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.

7.3 KB
Raw Blame
//! One physical-member resolver for conversation and monetary consumers.
use crate::query_v2::ObservationV2Error as Error;
use rusqlite::{Connection, params};
use std::collections::{BTreeMap, BTreeSet};

#[derive(Clone)]
pub(super) struct Member {
    pub id: String,
    pub anchor: String,
    pub predecessor: Option<String>,
    pub gap: Option<String>,
    pub edge_versions: Vec<u64>,
}

pub(super) fn resolve(
    db: &Connection,
    w: &str,
    watermark: u64,
    physical: &BTreeSet<String>,
    stable_from: i64,
) -> Result<(Vec<Member>, Vec<u64>), Error> {
    let mut stmt=db.prepare("SELECT e.revision,e.parent_id,e.child_id,e.request_id,e.ingress_ms,e.observed_ms FROM observation_native_relations_v1 e
      WHERE e.workspace_id=?1 AND e.revision<=?2 AND e.active=1
       AND NOT EXISTS(SELECT 1 FROM observation_native_relations_v1 newer WHERE newer.workspace_id=e.workspace_id AND newer.parent_id=e.parent_id AND newer.child_id=e.child_id AND newer.revision>e.revision AND newer.revision<=?2)")?;
    let edges = stmt
        .query_map(params![w, watermark], |r| {
            Ok((
                r.get::<_, u64>(0)?,
                r.get::<_, String>(1)?,
                r.get::<_, String>(2)?,
                r.get::<_, String>(3)?,
                r.get::<_, i64>(4)?,
                r.get::<_, i64>(5)?,
            ))
        })?
        .collect::<Result<Vec<_>, _>>()?;
    if edges.is_empty() {
        return Ok((
            physical
                .iter()
                .map(|id| Member {
                    id: id.clone(),
                    anchor: id.clone(),
                    predecessor: None,
                    gap: None,
                    edge_versions: vec![],
                })
                .collect(),
            vec![],
        ));
    }
    let mut parents = BTreeMap::<String, (String, u64)>::new();
    let mut gaps = BTreeMap::<String, String>::new();
    let mut successors = BTreeMap::<String, Vec<String>>::new();
    for (rev, parent, child, request, ingress, proof_at) in edges {
        if parent == child {
            gaps.insert(child, "lineage_cycle".into());
            continue;
        }
        if !edge_usable(db, w, &parent, &child, &request, stable_from, proof_at)? {
            gaps.insert(child, "predecessor_unavailable".into());
            continue;
        }
        let _ = ingress;
        if parents.contains_key(&child) {
            gaps.insert(child.clone(), "competing_predecessors".into());
        }
        parents.insert(child.clone(), (parent.clone(), rev));
        successors.entry(parent).or_default().push(child);
    }
    for children in successors.values().filter(|children| children.len() > 1) {
        for child in children {
            gaps.insert(child.clone(), "competing_successors".into());
        }
    }
    let mut connected = physical.clone();
    let mut queue: std::collections::VecDeque<_> = physical.iter().cloned().collect();
    while let Some(id) = queue.pop_front() {
        if !gaps.contains_key(&id)
            && let Some((parent, _)) = parents.get(&id)
            && connected.insert(parent.clone())
        {
            queue.push_back(parent.clone());
        }
        for child in successors.get(&id).into_iter().flatten() {
            if !gaps.contains_key(child) && connected.insert(child.clone()) {
                queue.push_back(child.clone());
            }
        }
    }
    let mut members = Vec::with_capacity(connected.len());
    let mut roots = BTreeMap::<String, (String, Option<String>)>::new();
    let mut group_edges = BTreeMap::<String, BTreeSet<u64>>::new();
    for id in &connected {
        let mut node = id.clone();
        let mut seen = BTreeSet::new();
        let mut path = Vec::<(String, u64)>::new();
        let mut gap = None;
        let mut cycle = false;
        loop {
            if let Some((root, reason)) = roots.get(&node) {
                node = root.clone();
                gap = reason.clone();
                break;
            }
            if let Some(reason) = gaps.get(&node) {
                gap = Some(reason.clone());
                break;
            }
            if !seen.insert(node.clone()) {
                cycle = true;
                gap = Some("lineage_cycle".into());
                break;
            }
            let Some((parent, rev)) = parents.get(&node) else {
                break;
            };
            path.push((node.clone(), *rev));
            node = parent.clone();
        }
        if cycle {
            for (id, _) in &path {
                roots.insert(id.clone(), (id.clone(), gap.clone()));
                gaps.insert(id.clone(), "lineage_cycle".into());
            }
            node = id.clone();
            path.clear();
        } else {
            roots.insert(node.clone(), (node.clone(), gap.clone()));
            for (child, rev) in path {
                roots.insert(child, (node.clone(), gap.clone()));
                group_edges.entry(node.clone()).or_default().insert(rev);
            }
        }
        let predecessor = if gaps.contains_key(id) {
            None
        } else {
            parents.get(id).map(|p| p.0.clone())
        };
        members.push(Member {
            id: id.clone(),
            anchor: node,
            predecessor,
            gap: gap.or_else(|| gaps.get(id).cloned()),
            edge_versions: vec![],
        });
    }
    let mut used = BTreeSet::new();
    // Every included physical group is selected as a whole. Keep its proof
    // set once, avoiding quadratic paths for long proven compression chains.
    for m in &mut members {
        if let Some(edges) = group_edges.remove(&m.anchor) {
            used.extend(edges.iter().copied());
            m.edge_versions = edges.into_iter().collect();
        }
    }
    Ok((members, used.into_iter().collect()))
}

pub(super) fn edge_usable(
    db: &Connection,
    w: &str,
    parent: &str,
    child: &str,
    request: &str,
    stable_from: i64,
    proof_at_ms: i64,
) -> Result<bool, Error> {
    // Generic barriers do not prove user deletion: expiry produces them too.
    // When old origin is unavailable they only make ancestry unavailable. A
    // ContentOnly deletion retains its source requests and keeps grouping.
    let usable:bool=db.query_row("SELECT
      EXISTS(SELECT 1 FROM logical_requests WHERE workspace_id=?1 AND request_id=?4 AND started_at_ms>=?5)
      AND EXISTS(SELECT 1 FROM logical_requests WHERE workspace_id=?1 AND session_id=?2 AND started_at_ms>=?5)
      AND NOT EXISTS(SELECT 1 FROM observation_session_barriers_v2 b WHERE b.workspace_id=?1 AND b.session_id IN(?2,?3)
        AND NOT EXISTS(SELECT 1 FROM logical_requests r WHERE r.workspace_id=b.workspace_id AND r.session_id=b.session_id AND r.started_at_ms<=b.through_ms)
        AND NOT EXISTS(SELECT 1 FROM observation_analysis_cuts_v1 c WHERE c.workspace_id=b.workspace_id AND c.session_id=b.session_id)
        AND NOT EXISTS(SELECT 1 FROM observation_native_origins_v1 o WHERE o.workspace_id=b.workspace_id AND o.session_id=?3 AND o.not_before_ms>b.through_ms
          AND o.not_before_ms<=?6-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)))",params![w,parent,child,request,stable_from,proof_at_ms],|r|r.get(0))?;
    Ok(usable && super::native_origin::edge_retained(db, w, parent, child, proof_at_ms)?)
}