opencrabs 0.5.1

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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

//! Parent-binding tests for the boot-resume path (#110).
//!
//! A revived sub-agent session must be recognizable from its status file and
//! the file must carry the spawning session: without that binding the
//! resumed result routes to the surface-less default and vanishes.

use crate::brain::agent::service::work_status::{WorkKind, WorkState, WorkStatus};
use uuid::Uuid;

fn temp_status_dir(tag: &str) -> std::path::PathBuf {
    let dir = std::env::temp_dir().join(format!(
        "oc-ws-parent-test-{tag}-{}-{}",
        std::process::id(),
        Uuid::new_v4().simple()
    ));
    std::fs::create_dir_all(&dir).expect("temp dir");
    crate::brain::agent::service::work_status::test_override::set(dir.clone());
    dir
}

fn drop_status_dir(dir: std::path::PathBuf) {
    crate::brain::agent::service::work_status::test_override::clear();
    let _ = std::fs::remove_dir_all(dir);
}

#[test]
fn status_file_carries_parent_and_lookup_finds_child() {
    let dir = temp_status_dir("carry");
    let child = Uuid::new_v4();
    let parent = Uuid::new_v4();

    WorkStatus::new_agent(
        "agent-carry",
        "review lens",
        &child.to_string(),
        "do the review",
        Some(&parent.to_string()),
    )
    .expect("write status");

    // Round-trip: the parent survives the disk write.
    let status = WorkStatus::read("agent-carry").expect("status exists");
    assert_eq!(
        status.parent_session_id.as_deref(),
        Some(parent.to_string().as_str())
    );
    assert_eq!(status.session_id, child.to_string());
    assert!(!status.state.is_terminal());

    // The resume path's detector: found by child session, non-terminal.
    let found = WorkStatus::find_agent_by_session(&child.to_string()).expect("found");
    assert_eq!(found.id, "agent-carry");
    assert_eq!(
        found.parent_session_id.as_deref(),
        Some(parent.to_string().as_str())
    );

    // Unknown session: no hit, no panic.
    assert!(WorkStatus::find_agent_by_session(&Uuid::new_v4().to_string()).is_none());

    drop_status_dir(dir);
}

#[test]
fn interrupted_file_is_still_detected_after_reconcile() {
    let dir = temp_status_dir("interrupted");
    let child = Uuid::new_v4();
    let parent = Uuid::new_v4();

    let mut agent = WorkStatus::new_agent(
        "agent-int",
        "restarted lens",
        &child.to_string(),
        "task",
        Some(&parent.to_string()),
    )
    .expect("write status");

    // Upstream reconciliation marks the file Interrupted at boot, before
    // the resumed session finishes — the detector must still find it.
    agent.mark_interrupted().expect("mark interrupted");
    assert!(agent.state.is_terminal());
    let found = WorkStatus::find_agent_by_session(&child.to_string()).expect("found");
    assert_eq!(found.id, "agent-int");
    assert_eq!(
        found.parent_session_id.as_deref(),
        Some(parent.to_string().as_str())
    );

    drop_status_dir(dir);
}

#[test]
fn legacy_file_without_parent_deserializes_and_is_skipped_by_nothing() {
    let dir = temp_status_dir("legacy");
    let child = Uuid::new_v4();
    let path = crate::brain::agent::service::work_status::status_path("agent-legacy");
    let body = format!(
        r#"{{"id":"agent-legacy","kind":"agent","session_id":"{child}","label":"old","task":"p","spawned_at":"2026-01-01T00:00:00Z","state":"Running"}}"#
    );
    std::fs::write(&path, body).expect("write legacy file");

    let status = WorkStatus::read("agent-legacy").expect("legacy parses");
    assert!(
        status.parent_session_id.is_none(),
        "legacy file has no parent"
    );
    assert_eq!(status.session_id, child.to_string());
    // Still detected as a revived agent (so its result at least finalizes the
    // file), but with no parent to route to.
    assert!(WorkStatus::find_agent_by_session(&child.to_string()).is_some());

    drop_status_dir(dir);
}

#[test]
fn lookup_skips_commands_and_outcome_terminal_agents() {
    let dir = temp_status_dir("skip");
    let child = Uuid::new_v4();

    // A detached command sharing the session id must not look like an agent.
    WorkStatus::new_command("cmd-1", &child.to_string(), "a command", "ls")
        .expect("write command status");
    assert!(WorkStatus::find_agent_by_session(&child.to_string()).is_none());

    // An outcome-terminal agent must not look revivable.
    let mut agent = WorkStatus::new_agent(
        "agent-done",
        "finished lens",
        &child.to_string(),
        "task",
        None,
    )
    .expect("write agent status");
    agent.mark_completed("done".to_string()).expect("finalize");
    assert!(matches!(agent.state, WorkState::Completed));
    assert_eq!(agent.kind, WorkKind::Agent);
    assert!(WorkStatus::find_agent_by_session(&child.to_string()).is_none());

    // A failed agent is equally final.
    let mut agent = WorkStatus::new_agent(
        "agent-fail",
        "failed lens",
        &child.to_string(),
        "task",
        None,
    )
    .expect("write agent status");
    agent.mark_failed("boom".to_string()).expect("finalize");
    assert!(WorkStatus::find_agent_by_session(&child.to_string()).is_none());

    drop_status_dir(dir);
}