ccswarm 0.5.0

AI-powered multi-agent orchestration system with proactive intelligence, security monitoring, and session management
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
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

//! Delegate Mode for Lead-only orchestration
//!
//! In delegate mode, the lead agent only orchestrates - no direct code execution.
//! Tasks are split, assigned, and results integrated by the lead.

use serde::{Deserialize, Serialize};
use std::collections::HashMap;

use super::team::{Team, TeamTaskStatus};

/// Delegate mode configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DelegateConfig {
    pub enabled: bool,
    pub max_task_split: usize,
    pub auto_merge_results: bool,
    pub require_all_complete: bool,
}

impl Default for DelegateConfig {
    fn default() -> Self {
        Self {
            enabled: false,
            max_task_split: 10,
            auto_merge_results: true,
            require_all_complete: true,
        }
    }
}

/// A task split decision by the lead
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TaskSplit {
    pub original_task: String,
    pub subtasks: Vec<SubtaskAssignment>,
}

/// Assignment of a subtask to a teammate
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SubtaskAssignment {
    pub task_id: String,
    pub description: String,
    pub assigned_to: String,
    pub depends_on: Vec<String>,
}

/// Delegate mode orchestrator
pub struct DelegateOrchestrator {
    config: DelegateConfig,
    splits: HashMap<String, TaskSplit>,
}

impl DelegateOrchestrator {
    pub fn new(config: DelegateConfig) -> Self {
        Self {
            config,
            splits: HashMap::new(),
        }
    }

    pub fn is_enabled(&self) -> bool {
        self.config.enabled
    }

    /// Split a task into subtasks
    pub fn split_task(
        &mut self,
        original_task: impl Into<String>,
        subtasks: Vec<SubtaskAssignment>,
    ) -> Result<String, String> {
        if subtasks.len() > self.config.max_task_split {
            return Err(format!(
                "Too many subtasks: {} (max: {})",
                subtasks.len(),
                self.config.max_task_split
            ));
        }

        let task = original_task.into();
        let split = TaskSplit {
            original_task: task.clone(),
            subtasks,
        };
        self.splits.insert(task.clone(), split);
        Ok(task)
    }

    /// Check if all subtasks for an original task are complete
    pub fn is_task_complete(&self, original_task: &str, team: &Team) -> bool {
        if let Some(split) = self.splits.get(original_task) {
            split.subtasks.iter().all(|sub| {
                team.task_list
                    .tasks
                    .iter()
                    .find(|t| t.id == sub.task_id)
                    .map(|t| t.status == TeamTaskStatus::Completed)
                    .unwrap_or(false)
            })
        } else {
            false
        }
    }

    pub fn get_split(&self, original_task: &str) -> Option<&TaskSplit> {
        self.splits.get(original_task)
    }
}

impl Default for DelegateOrchestrator {
    fn default() -> Self {
        Self::new(DelegateConfig::default())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_delegate_config() {
        let config = DelegateConfig::default();
        assert!(!config.enabled);
        assert_eq!(config.max_task_split, 10);
    }

    #[test]
    fn test_split_task() {
        let mut orchestrator = DelegateOrchestrator::new(DelegateConfig {
            enabled: true,
            ..Default::default()
        });

        let result = orchestrator.split_task(
            "build-auth",
            vec![SubtaskAssignment {
                task_id: "t1".to_string(),
                description: "Create API".to_string(),
                assigned_to: "backend-agent".to_string(),
                depends_on: vec![],
            }],
        );

        assert!(result.is_ok());
        assert!(orchestrator.get_split("build-auth").is_some());
    }
}