ai-dispatch 11.2.0

Multi-AI CLI team orchestrator
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

// Mirror precondition failures exercise the production builder and exec dispatch fallback.
// Synthetic homes preserve all local content and require no credentials or model calls.

use super::*;
use crate::agent::{Agent, RunOpts};
use std::process::Command;
#[path = "turn/fixture.rs"]
mod fixture;
use fixture::Fixture;

fn assert_exec(fixture: &Fixture, reason: &str) {
    fixture.dispatch();
    let events = fixture.store.get_events(fixture.task.as_str()).unwrap();
    assert!(
        events
            .iter()
            .any(|event| event.metadata.as_ref().is_some_and(|metadata| {
                metadata["codex_app_server_fallback"] == true
                    && metadata["reason"]
                        .as_str()
                        .is_some_and(|detail| detail.contains(reason))
            }))
    );
    assert_eq!(
        fixture
            .store
            .get_task(fixture.task.as_str())
            .unwrap()
            .unwrap()
            .status,
        crate::types::TaskStatus::Done
    );
    assert!(
        std::fs::read_to_string(&fixture.log)
            .unwrap()
            .contains("STEERED")
    );
}

#[test]
fn retry_uses_exec_when_real_home_lacks_sessions() {
    let mut fixture = Fixture::new("complete");
    let real = fixture.home.path().join("real-codex");
    std::fs::remove_dir(real.join("sessions")).unwrap();
    let local = fixture.home.path().join("codex-home/sessions");
    std::fs::create_dir_all(&local).unwrap();
    std::fs::write(
        local.join("rollout-2026-10-15T10-00-00-saved-session.jsonl"),
        "local",
    )
    .unwrap();
    let opts = retry_options();
    crate::agent::codex::cli_config::set_test_codex_home(Some(real));
    let built = crate::agent::codex::CodexAgent.build_command("retry prompt", &opts);
    crate::agent::codex::cli_config::set_test_codex_home(None);
    let built = built.unwrap();
    assert!(!built.get_args().any(|arg| arg == "resume"));
    let mut command = Command::new(fixture.command.get_program());
    command.args(built.get_args());
    for (key, value) in fixture.command.get_envs() {
        if let Some(value) = value {
            command.env(key, value);
        }
    }
    fixture.command = command;
    assert_exec(&fixture, "requires existing sessions and state_5.sqlite");
    assert!(local.is_dir());
    assert!(!fixture.home.path().join("real-codex/sessions").exists());
}

fn retry_options() -> RunOpts {
    RunOpts {
        dir: None,
        output: None,
        result_file: None,
        model: None,
        budget: false,
        read_only: true,
        sandbox: false,
        context_files: vec![],
        session_id: Some("saved-session".into()),
        env: None,
        env_forward: None,
    }
}

#[test]
fn uses_exec_when_real_home_lacks_state_database() {
    let fixture = Fixture::new("complete");
    let database = fixture.home.path().join("real-codex/state_5.sqlite");
    std::fs::remove_file(&database).unwrap();
    assert_exec(&fixture, "requires existing sessions and state_5.sqlite");
    assert!(!database.exists());
}

#[test]
fn refresh_falls_back_when_local_entry_collides_with_real_entry() {
    for directory in [false, true] {
        let fixture = Fixture::new("complete");
        let home = Home::for_command(&fixture.command).unwrap();
        let local = home.path.join("later");
        let real = fixture.home.path().join("real-codex/later");
        if directory {
            std::fs::create_dir(&local).unwrap();
            std::fs::create_dir(&real).unwrap();
        } else {
            std::fs::write(&local, "local").unwrap();
            std::fs::write(&real, "real").unwrap();
        }
        assert_exec(&fixture, "local state invisible to the real home");
        assert!(!local.symlink_metadata().unwrap().file_type().is_symlink());
        if !directory {
            assert_eq!(std::fs::read_to_string(local).unwrap(), "local");
            assert_eq!(std::fs::read_to_string(real).unwrap(), "real");
        }
    }
}

#[test]
fn rejects_non_regular_config_entries_in_persistent_mirror() {
    for name in ["config.toml-dir", "config.toml-link"] {
        let fixture = Fixture::new("complete");
        let home = Home::for_command(&fixture.command).unwrap();
        let path = home.path.join(name);
        if name.ends_with("-dir") {
            std::fs::create_dir(&path).unwrap();
        } else if name.ends_with("-link") {
            std::os::unix::fs::symlink(home.path.join("missing"), &path).unwrap();
        } else {
            std::fs::write(&path, "synthetic user config").unwrap();
        }
        assert_exec(&fixture, "contains non-regular user configuration");
        assert!(path.symlink_metadata().is_ok());
    }
}