codetether-agent 4.7.0-a-002.4

A2A-native AI coding agent for the CodeTether ecosystem
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

//! Tests for [`DelegationState`] mutation methods.

#[cfg(test)]
mod tests {
    use crate::session::delegation::{DelegationConfig, DelegationState};
    use crate::session::relevance::{Bucket, Dependency, Difficulty, ToolUse};

    fn bucket() -> Bucket {
        Bucket {
            difficulty: Difficulty::Easy,
            dependency: Dependency::Isolated,
            tool_use: ToolUse::No,
        }
    }

    #[test]
    fn delegation_state_update_seeds_and_records() {
        let mut state = DelegationState::with_config(DelegationConfig::default());
        state.update("openai", "model_call", bucket(), true);
        let score = state
            .score("openai", "model_call", bucket())
            .expect("update must seed the posterior");
        assert!(score.is_finite());
    }

    #[test]
    fn delegate_to_respects_margin() {
        let mut state = DelegationState::with_config(DelegationConfig::default());
        let b = bucket();
        for _ in 0..20 {
            state.update("local", "skill", b, true);
            state.update("local", "skill", b, false);
        }
        for _ in 0..20 {
            state.update("peer", "skill", b, true);
            state.update("peer", "skill", b, false);
        }
        for _ in 0..2 {
            state.update("peer", "skill", b, true);
        }
        let maybe = state.delegate_to("local", &["peer"], "skill", b);
        assert!(maybe.is_some() || maybe.is_none());
    }

    #[test]
    fn shrink_cold_start_pulls_neighbour_mass() {
        let mut state = DelegationState::with_config(DelegationConfig::default());
        let b1 = bucket();
        let b2 = Bucket {
            difficulty: Difficulty::Medium,
            ..b1
        };
        for _ in 0..10 {
            state.update("agent", "skill", b2, true);
        }
        state.shrink_cold_start("agent", "skill", b1, &[b2], 2.0);
        let post = state
            .beliefs
            .get(&DelegationState::key("agent", "skill", b1))
            .unwrap();
        assert!(post.alpha > post.beta);
    }
}