ai-dispatch 10.52.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

// Text leaderboard evidence alongside advised candidates.
// Exports: leaderboard_lines; no fetching or scoring.
// Deps: typed score evidence, advice payload and model labels.

use super::{AdviceReport, candidate_mark, unrated_served_line};

pub(super) fn leaderboard_lines(evidence: &crate::scores::Evidence) -> Vec<String> {
    let mut lines = vec![format!(
        "     capability: {} ({})",
        evidence
            .capability
            .map(|value| format!("{value:.2}/10"))
            .unwrap_or_else(|| "unknown".into()),
        evidence.harness
    )];
    for score in &evidence.scores {
        lines.push(format!(
            "     {} / {}: {} {} rank {}/{} effort {} cli {} date {}",
            score.source,
            score.board,
            score.value,
            score.unit,
            score
                .rank
                .map(|rank| rank.to_string())
                .unwrap_or_else(|| "unknown".into()),
            score
                .of
                .map(|of| of.to_string())
                .unwrap_or_else(|| "unknown".into()),
            score.effort.as_deref().unwrap_or("unknown"),
            score.cli.as_deref().unwrap_or("model-level"),
            score.date
        ));
    }
    lines
}

pub(super) fn print_candidates(report: &AdviceReport) {
    for (index, candidate) in report.candidates.iter().enumerate() {
        let availability = candidate_mark(
            candidate
                .exclusion_reason
                .as_deref()
                .or(candidate.demotion_reason.as_deref()),
        );
        let item = &candidate.breakdown;
        println!(
            concat!(
                "  {}. {:<10} {:>5.1}  base {:.1}  {:+.1} model  {:+.1} budget  {:+.1} limit",
                "  {:+.1} history  {:+.1} team  {:+.1} headroom  model {}{}"
            ),
            index + 1,
            candidate.agent,
            candidate.score,
            item.base,
            item.model_capability,
            item.budget_penalty,
            item.rate_limit_penalty,
            item.history_bonus,
            item.team_bonus,
            item.headroom_penalty,
            crate::agent::run_model::model_label(
                candidate.model.as_deref(),
                candidate.pinned,
                candidate.source,
            ),
            availability,
        );
        for line in leaderboard_lines(&candidate.capability_evidence) {
            println!("{line}");
        }
        if let Some(line) = unrated_served_line(candidate) {
            println!("{line}");
        }
    }
    print_custom_candidates(report);
}

fn print_custom_candidates(report: &AdviceReport) {
    if !report.custom_candidates.is_empty() {
        println!("Custom agents (separate capability scale):");
        for candidate in &report.custom_candidates {
            for line in leaderboard_lines(&candidate.capability_evidence) {
                println!("{line}");
            }
            let availability = candidate_mark(candidate.exclusion_reason.as_deref());
            let preference = if candidate.team_preferred {
                "  team preferred"
            } else {
                ""
            };
            println!(
                "  {:<20} capability {}  +{} strength{}{}",
                candidate.agent,
                candidate.category_capability,
                candidate.strength_bonus,
                preference,
                availability,
            );
        }
    }
}