lean_ctx/core/context_kernel/

multi_agent_e2e.rs

#[cfg(test)]
mod tests {
    use std::collections::HashMap;

    use super::super::capsule_wire::{self, ContextCapsuleV1};
    use super::super::etpao::{EtpaoMetrics, EtpaoTracker};
    use super::super::knowledge_health;
    use super::super::result_fusion::{self, ChildResult, FusionStrategy};
    use super::super::types::{ContextReceiptV1, ReceiptOutcome};

    fn receipt(id: &str, delivered_tokens: usize, cache_hits: usize) -> ContextReceiptV1 {
        ContextReceiptV1 {
            receipt_id: format!("receipt:{id}"),
            plan_id: format!("plan:{id}"),
            delivered_tokens,
            cache_hits,
            cache_misses: usize::from(cache_hits == 0),
            outcome: ReceiptOutcome::Accepted,
            quality_signals: Vec::new(),
            feedback_attribution: HashMap::new(),
        }
    }

    fn capsule(owner: &str, refs: Vec<String>, budget: u64) -> ContextCapsuleV1 {
        ContextCapsuleV1::new("multi-agent-e2e", refs, budget, owner)
    }

    fn child_result(
        agent_id: &str,
        evidence: &[&str],
        confidence: f64,
        quality_score: f64,
        contradicts: &[&str],
    ) -> ChildResult {
        ChildResult {
            agent_id: agent_id.to_owned(),
            receipt_ref: format!("receipt:{agent_id}"),
            evidence: evidence.iter().map(|item| (*item).to_owned()).collect(),
            confidence,
            quality_score,
            contradicts: contradicts
                .iter()
                .map(|agent| (*agent).to_owned())
                .collect(),
        }
    }

    #[test]
    fn three_deep_chain_budget_cascade() {
        let mut tracker = EtpaoTracker::default();
        let mut parent = capsule("parent", vec!["ref:root".to_owned()], 10_000);

        let mut child = capsule("child", vec!["ref:child".to_owned()], 5_000);
        child.parent_capsule = Some(parent.capsule_id.clone());
        parent.budget_remaining = parent.budget_remaining.saturating_sub(child.budget_tokens);
        tracker.record_receipt(
            "parent",
            &receipt("parent-to-child", 5_000, 0),
            ReceiptOutcome::Accepted,
        );

        let mut grandchild = capsule("grandchild", vec!["ref:grandchild".to_owned()], 2_500);
        grandchild.parent_capsule = Some(child.capsule_id.clone());
        child.budget_remaining = child
            .budget_remaining
            .saturating_sub(grandchild.budget_tokens);
        tracker.record_receipt(
            "child",
            &receipt("child-to-grandchild", 2_500, 0),
            ReceiptOutcome::Accepted,
        );

        assert_eq!(parent.budget_remaining, 5_000);
        assert_eq!(child.budget_remaining, 2_500);
        assert_eq!(grandchild.budget_remaining, 2_500);
        assert!(grandchild.budget_remaining <= child.budget_remaining);
        assert!(child.budget_remaining <= parent.budget_remaining);
        assert_eq!(
            tracker.get("parent").map(|metrics| metrics.tokens_input),
            Some(5_000)
        );
        assert_eq!(
            tracker.get("child").map(|metrics| metrics.tokens_input),
            Some(2_500)
        );
    }

    #[test]
    fn sibling_context_dedup() {
        let shared = ["ref:A", "ref:B"];
        let siblings: Vec<_> = ["ref:one", "ref:two", "ref:three"]
            .into_iter()
            .enumerate()
            .map(|(index, unique)| {
                capsule(
                    &format!("sibling-{index}"),
                    shared
                        .into_iter()
                        .chain([unique])
                        .map(str::to_owned)
                        .collect(),
                    1_000,
                )
            })
            .collect();

        let report = capsule_wire::dedup_siblings(&siblings);

        assert_eq!(report.shared_refs, vec!["ref:A", "ref:B"]);
        assert!(report.dedup_ratio > 0.0);
        assert!(report.unique_per_capsule.iter().all(|refs| refs.len() == 1));
    }

    #[test]
    fn delta_transfer_smaller_than_full() {
        let original_refs: Vec<_> = (0..10)
            .map(|index| format!("ref:original-context-object-{index:02}-with-stable-metadata"))
            .collect();
        let base = capsule("parent", original_refs.clone(), 5_000);
        let mut updated_refs = original_refs[..8].to_vec();
        updated_refs.extend([
            "ref:new-context-object-10-with-stable-metadata".to_owned(),
            "ref:new-context-object-11-with-stable-metadata".to_owned(),
        ]);
        let mut updated = capsule("parent", updated_refs, 5_000);
        updated.created_at_epoch = base.created_at_epoch;

        let delta = capsule_wire::compute_delta(&base, &updated);
        let delta_size = serde_json::to_vec(&delta).expect("delta serializes").len();
        let full_size = serde_json::to_vec(&updated)
            .expect("capsule serializes")
            .len();
        let applied = capsule_wire::apply_delta(&base, &delta);

        assert!(delta_size * 2 < full_size);
        assert_eq!(applied, updated);
    }

    #[test]
    fn result_fusion_resolves_contradiction() {
        let results = [
            child_result("agent-a", &["finding:accepted"], 0.95, 0.95, &["agent-b"]),
            child_result("agent-b", &["finding:rejected"], 0.80, 0.90, &["agent-a"]),
            child_result("agent-c", &["finding:accepted"], 0.85, 0.90, &[]),
        ];

        let report = result_fusion::fuse_results(&results, FusionStrategy::WeightedMerge);

        assert!(report.conflicts.iter().any(|conflict| {
            (conflict.agent_a == "agent-a" && conflict.agent_b == "agent-b")
                || (conflict.agent_a == "agent-b" && conflict.agent_b == "agent-a")
        }));
        assert_eq!(report.winning_agent, "agent-a");
        assert!(
            report
                .merged_evidence
                .contains(&"finding:accepted".to_owned())
        );
    }

    #[test]
    fn etpao_improves_with_context_reuse() {
        let mut tracker = EtpaoTracker::default();
        for index in 0..5 {
            tracker.record_receipt(
                "chain",
                &receipt(&format!("uncached-{index}"), 1_000, 0),
                ReceiptOutcome::Accepted,
            );
        }
        let first: EtpaoMetrics = tracker.aggregate();
        let first_etpao = first.etpao();

        for index in 0..5 {
            tracker.record_receipt(
                "chain",
                &receipt(&format!("cached-{index}"), 100, 1),
                ReceiptOutcome::Accepted,
            );
        }
        let second_etpao = tracker.aggregate().etpao();

        assert!(second_etpao < first_etpao);
    }

    #[test]
    fn knowledge_health_detects_stale_facts() {
        let mut facts = vec![(true, false); 3];
        facts.extend([(false, false); 5]);
        facts.extend([(false, true); 2]);

        let report = knowledge_health::assess_health(&facts, 0, 0, 0, 0);

        assert!((report.freshness_score - 0.3).abs() < f64::EPSILON);
        assert!((report.stale_ratio - 0.7).abs() < f64::EPSILON);
        assert!((report.contradiction_rate - 0.2).abs() < f64::EPSILON);
    }
}