shepherd-core 6.6.0

The harness-agnostic shepherd engine: domain types, configuration schema, and run state. Knows nothing about any CLI, harness, or process.
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

use shepherd_core::{Harness, dispatch::*};

fn child_identity(event: &str) -> NormalizedIdentity {
    RawIdentity::new(
        Harness::Pi,
        event,
        "session-child",
        Some("agent-child"),
        Some("shepherd:coder"),
        None,
        None,
        None,
    )
    .normalize()
    .expect("fixture identity")
}

fn binding() -> DispatchBinding {
    DispatchBinding::new(
        Some(RunId::new("v645").expect("run")),
        Some(Role::Coder),
        Some(LaneId::new("l1-engine").expect("lane")),
        Some(AgentId::new("parent").expect("parent")),
        vec!["crates/core/src/dispatch/**".into()],
        None,
        [
            "read",
            "search",
            "shell",
            "skill-load",
            "write",
            "subagent-provider",
        ],
        "native",
        "1",
        None,
        60_000,
    )
    .expect("binding")
}

#[test]
fn child_start_and_resume_never_become_native_dispatch_requests() {
    let start =
        plan_lifecycle(&child_identity("SubagentStart"), Some(&binding())).expect("start plan");
    assert!(matches!(
        start,
        DispatchPlan::Blocked(DispatchError::BrokerRequired)
    ));

    let mut resume_binding = binding();
    resume_binding.source_agent_id = Some(AgentId::new("source").expect("source"));
    let resume = plan_lifecycle(&child_identity("SubagentResume"), Some(&resume_binding))
        .expect("resume plan");
    assert!(matches!(
        resume,
        DispatchPlan::Blocked(DispatchError::BrokerRequired)
    ));
}

#[test]
fn terminal_cleanup_response_is_strict_and_not_replayable() {
    let response = LaunchCleanupResponse {
        schema: LAUNCH_CLEANUP_SCHEMA.into(),
        launch_id_hash: [4; 32],
        state: PendingLaunchState::Expired,
    };
    response.validate().expect("terminal cleanup");
    let mut replay = response.clone();
    replay.state = PendingLaunchState::Active;
    assert!(replay.validate().is_err());
    let mut malformed = response;
    malformed.schema = "wrong".into();
    assert!(malformed.validate().is_err());
}

#[test]
fn digest_comparison_is_fixed_width_and_constant_time_api() {
    let mut other = [0_u8; 32];
    other[31] = 1;
    assert!(constant_time_digest_eq(&[7; 32], &[7; 32]));
    assert!(!constant_time_digest_eq(&[7; 32], &other));
}

#[test]
fn pending_launch_state_has_one_claim_and_no_direct_active_edge() {
    assert!(PendingLaunchState::Pending.can_claim());
    assert!(!PendingLaunchState::ClaimedUnspawned.can_claim());
    assert!(!PendingLaunchState::Active.can_claim());
    assert!(PendingLaunchState::ClaimedUnspawned.can_activate());
    assert!(!PendingLaunchState::Pending.can_activate());
    assert!(!PendingLaunchState::Active.can_activate());
    assert!(PendingLaunchState::LaunchFailed.is_terminal());
    assert!(PendingLaunchState::Canceled.is_terminal());
    assert!(PendingLaunchState::Expired.is_terminal());
}

#[test]
fn scope_validation_rejects_unicode_and_alias_forms_and_keeps_case_distinct() {
    let scopes = ["crates/core/**".to_owned()];
    for path in [
        "crates/core/src/é.rs",
        "crates/core/./src/lib.rs",
        "crates/core/src/../lib.rs",
        "crates/core/src/lib~1.rs",
    ] {
        assert!(
            path_in_write_scope(path, &scopes).is_err(),
            "unsafe path accepted: {path}"
        );
    }
    assert!(path_in_write_scope("crates/core/src/lib.rs", &scopes).expect("safe path"));
    // Repository names preserve case, so a case variant is a DIFFERENT path
    // rather than a malformed one. crates/core/tests/dispatch_scope_paths.rs owns
    // that contract in full; these keep this suite consistent with it.
    assert!(!path_in_write_scope("Crates/core/src/lib.rs", &scopes).expect("case stays distinct"));
    assert!(
        !path_in_write_scope("crates/core/src/lib.rs", &["Crates/core/**".into()])
            .expect("case stays distinct")
    );
}