decapod 0.47.21

Decapod is the daemonless, local-first control plane that agents call on demand to align intent, enforce boundaries, and produce proof-backed completion across concurrent multi-agent work. 🦀
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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

use decapod::core::store::{Store, StoreKind};
use decapod::plugins::health::{AutonomyTier, HealthState, compute_health, initialize_health_db};
use tempfile::tempdir;

#[test]
fn test_autonomy_tier_display() {
    assert_eq!(AutonomyTier::Untrusted.to_string(), "untrusted");
    assert_eq!(AutonomyTier::Basic.to_string(), "basic");
    assert_eq!(AutonomyTier::Verified.to_string(), "verified");
    assert_eq!(AutonomyTier::Core.to_string(), "core");
}

#[test]
fn test_autonomy_tier_default() {
    let tier = AutonomyTier::default();
    assert_eq!(tier, AutonomyTier::Untrusted);
}

#[test]
fn test_compute_health_no_events() {
    let (state, msg) = compute_health(
        &decapod::plugins::health::Claim {
            id: "test".to_string(),
            subject: "test".to_string(),
            kind: "TODO".to_string(),
            provenance: "test".to_string(),
            created_at: "".to_string(),
        },
        &[],
        1000,
    );

    assert_eq!(state, HealthState::ASSERTED);
    assert!(msg.contains("No proof events"));
}

#[test]
fn test_compute_health_verified() {
    let claim = decapod::plugins::health::Claim {
        id: "test".to_string(),
        subject: "test".to_string(),
        kind: "TODO".to_string(),
        provenance: "test".to_string(),
        created_at: "".to_string(),
    };

    let events = vec![decapod::plugins::health::ProofEvent {
        event_id: "e1".to_string(),
        claim_id: "test".to_string(),
        ts: "1000Z".to_string(),
        surface: "cargo test".to_string(),
        result: "pass".to_string(),
        sla_seconds: 3600,
    }];

    let (state, msg) = compute_health(&claim, &events, 2000);

    assert_eq!(state, HealthState::VERIFIED);
    assert!(msg.contains("Valid proof"));
}

#[test]
fn test_compute_health_contradicted() {
    let claim = decapod::plugins::health::Claim {
        id: "test".to_string(),
        subject: "test".to_string(),
        kind: "TODO".to_string(),
        provenance: "test".to_string(),
        created_at: "".to_string(),
    };

    let events = vec![decapod::plugins::health::ProofEvent {
        event_id: "e1".to_string(),
        claim_id: "test".to_string(),
        ts: "1000Z".to_string(),
        surface: "cargo test".to_string(),
        result: "fail".to_string(),
        sla_seconds: 3600,
    }];

    let (state, msg) = compute_health(&claim, &events, 2000);

    assert_eq!(state, HealthState::CONTRADICTED);
    assert!(msg.contains("failed"));
}

#[test]
fn test_compute_health_stale() {
    let claim = decapod::plugins::health::Claim {
        id: "test".to_string(),
        subject: "test".to_string(),
        kind: "TODO".to_string(),
        provenance: "test".to_string(),
        created_at: "".to_string(),
    };

    let events = vec![decapod::plugins::health::ProofEvent {
        event_id: "e1".to_string(),
        claim_id: "test".to_string(),
        ts: "1000Z".to_string(),
        surface: "cargo test".to_string(),
        result: "pass".to_string(),
        sla_seconds: 60, // 60 seconds SLA
    }];

    // 5000 seconds later - expired
    let (state, msg) = compute_health(&claim, &events, 6000);

    assert_eq!(state, HealthState::STALE);
    assert!(msg.contains("expired SLA"));
}

#[test]
fn test_health_db_init() {
    let tmp = tempdir().unwrap();
    let store = Store {
        kind: StoreKind::User,
        root: tmp.path().to_path_buf(),
    };

    initialize_health_db(&store.root).unwrap();

    let db_path = store.root.join("governance.db");
    assert!(db_path.exists());
}