terraphim_orchestrator 1.20.1

AI Dark Factory orchestrator wiring spawner, router, supervisor into a reconciliation loop
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

//! Fleet invariant: every `*build-runner` agent in the live conf.d files must
//! have `event_only = true`. This locks in the dispatch-gate policy across the
//! fleet so a future operator who adds a new build-runner clone cannot
//! accidentally reintroduce the comment-mention dispatch bug fixed in #1104.
//!
//! Conf.d fixtures are copied from /opt/ai-dark-factory/conf.d/ at test-write
//! time. The migrate-to-confd.py pipeline is one-shot, so the tests/fixtures/
//! directory is the supported way to reference live config from a unit test
//! without coupling to absolute paths under /opt/ai-dark-factory/.

use std::path::PathBuf;
use toml::Value;

const FLEET_FILES: &[&str] = &[
    "terraphim.toml",
    "atomic-server.toml",
    "better-auth-rust.toml",
    "gitea.toml",
    "gitea-robot.toml",
];

fn fixture_path(name: &str) -> PathBuf {
    let mut p = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    p.push("tests");
    p.push("fixtures");
    p.push("conf.d");
    p.push(name);
    p
}

#[test]
fn test_fleet_conf_d_build_runner_event_only_invariant() {
    let mut total_build_runners = 0usize;

    for fname in FLEET_FILES {
        let path = fixture_path(fname);
        let content = std::fs::read_to_string(&path)
            .unwrap_or_else(|e| panic!("could not read fixture {}: {}", path.display(), e));
        let value: Value = toml::from_str(&content)
            .unwrap_or_else(|e| panic!("could not parse {}: {}", path.display(), e));

        let agents = value.get("agents").and_then(Value::as_array);
        let agents = match agents {
            Some(a) => a,
            None => continue,
        };

        for agent in agents {
            let name = agent
                .get("name")
                .and_then(Value::as_str)
                .unwrap_or("<unnamed>");
            if !name.ends_with("build-runner") {
                continue;
            }

            total_build_runners += 1;
            let event_only = agent
                .get("event_only")
                .and_then(Value::as_bool)
                .unwrap_or(false);
            assert!(
                event_only,
                "fleet invariant violated: agent {:?} in {} must have event_only = true (Refs #1104)",
                name, fname
            );
        }
    }

    assert!(
        total_build_runners >= 5,
        "expected at least 5 build-runner-pattern agents across the fleet; found {}",
        total_build_runners
    );
}

#[test]
fn test_source_template_build_runner_event_only() {
    let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    path.pop();
    path.pop();
    path.push("scripts");
    path.push("adf-setup");
    path.push("agents");
    path.push("build-runner.toml");

    let content = std::fs::read_to_string(&path)
        .unwrap_or_else(|e| panic!("could not read source template {}: {}", path.display(), e));
    let value: Value = toml::from_str(&content)
        .unwrap_or_else(|e| panic!("could not parse source template: {}", e));

    let agents = value
        .get("agents")
        .and_then(Value::as_array)
        .expect("source template must contain [[agents]]");

    let build_runner = agents
        .iter()
        .find(|a| a.get("name").and_then(Value::as_str) == Some("build-runner"))
        .expect("source template must contain build-runner agent");

    let event_only = build_runner
        .get("event_only")
        .and_then(Value::as_bool)
        .unwrap_or(false);
    assert!(
        event_only,
        "source template build-runner must have event_only = true to match the fleet invariant"
    );
}