opencrabs 0.3.81

The autonomous, self-improving AI agent. Single Rust binary. Every channel. Recommended: the 40MB prebuilt binary for macOS, Linux and Windows: https://github.com/adolfousier/opencrabs/releases
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
126
127
128
129
130
131
132
133
134

//! Startup reconciliation of orphaned sub-agent status files (#1038).
//!
//! A sub-agent dies with the process; its status file does not. Every file
//! still `Pending` or `Running` at startup belongs to an agent that no longer
//! exists, and must stop reading as live.

use crate::brain::tools::subagent::reconcile::reconcile_orphaned_agents;
use crate::brain::tools::subagent::status::*;
use std::fs;

fn isolate(tag: &str) {
    let dir = std::env::temp_dir().join(format!(
        "opencrabs-subagent-reconcile-{}-{}",
        tag,
        std::process::id()
    ));
    let _ = fs::remove_dir_all(&dir);
    test_override::set(dir);
}

#[test]
fn a_running_agent_becomes_interrupted() {
    isolate("running");
    let mut s = AgentStatus::new("agent-1", "build docs", "sess-a", "do things").unwrap();
    s.mark_running().unwrap();

    let orphans = reconcile_orphaned_agents();

    assert_eq!(orphans.len(), 1);
    assert_eq!(orphans[0].id, "agent-1");
    assert_eq!(orphans[0].state, AgentState::Interrupted);

    // Persisted, not just returned: the next reader must see it too.
    let reread = AgentStatus::read("agent-1").expect("status file still present");
    assert_eq!(reread.state, AgentState::Interrupted);
}

#[test]
fn a_pending_agent_becomes_interrupted() {
    // Killed between the status file being written and the task starting.
    isolate("pending");
    AgentStatus::new("agent-2", "lint", "sess-b", "do things").unwrap();

    let orphans = reconcile_orphaned_agents();

    assert_eq!(orphans.len(), 1);
    assert_eq!(orphans[0].state, AgentState::Interrupted);
}

#[test]
fn interrupted_carries_a_reason_and_a_completion_stamp() {
    // The reason distinguishes a restart from a genuine failure, and the
    // stamp lets the file age out on the same schedule as any other
    // terminal state.
    isolate("reason");
    let mut s = AgentStatus::new("agent-3", "test", "sess-c", "do things").unwrap();
    s.mark_running().unwrap();

    let orphans = reconcile_orphaned_agents();

    assert!(
        orphans[0]
            .error
            .as_deref()
            .unwrap_or("")
            .contains("restart")
    );
    assert!(orphans[0].completed_at.is_some());
}

#[test]
fn terminal_agents_are_left_alone() {
    isolate("terminal");
    let mut done = AgentStatus::new("agent-done", "a", "sess-d", "p").unwrap();
    done.mark_completed("output".to_string()).unwrap();
    let mut failed = AgentStatus::new("agent-failed", "b", "sess-d", "p").unwrap();
    failed.mark_failed("boom".to_string()).unwrap();

    let orphans = reconcile_orphaned_agents();

    assert!(orphans.is_empty(), "nothing mid-flight to reconcile");
    assert_eq!(
        AgentStatus::read("agent-done").unwrap().state,
        AgentState::Completed
    );
    assert_eq!(
        AgentStatus::read("agent-failed").unwrap().state,
        AgentState::Failed
    );
}

#[test]
fn the_parent_session_survives_so_the_report_can_be_routed() {
    // The whole point of returning the statuses: the caller needs to know
    // which session to tell.
    isolate("parent");
    let mut s = AgentStatus::new("agent-4", "deploy", "sess-parent", "p").unwrap();
    s.mark_running().unwrap();

    let orphans = reconcile_orphaned_agents();

    assert_eq!(orphans[0].parent_session_id, "sess-parent");
}

#[test]
fn reconciling_is_idempotent() {
    // A second startup must not re-report an agent already accounted for.
    isolate("idempotent");
    let mut s = AgentStatus::new("agent-5", "x", "sess-e", "p").unwrap();
    s.mark_running().unwrap();

    assert_eq!(reconcile_orphaned_agents().len(), 1);
    assert!(reconcile_orphaned_agents().is_empty());
}

#[test]
fn a_missing_status_dir_is_not_an_error() {
    isolate("missing");
    assert!(reconcile_orphaned_agents().is_empty());
}

#[test]
fn unparseable_files_do_not_abort_the_pass() {
    isolate("corrupt");
    ensure_dir().unwrap();
    fs::write(status_dir().join("garbage.json"), "not json at all").unwrap();
    let mut s = AgentStatus::new("agent-6", "y", "sess-f", "p").unwrap();
    s.mark_running().unwrap();

    let orphans = reconcile_orphaned_agents();

    assert_eq!(orphans.len(), 1, "the healthy file is still reconciled");
    assert_eq!(orphans[0].id, "agent-6");
}