feat: Agentic Dynamic Workflows — Multi-Agent Legion Orchestration

src/apps/cli/src/daemon/service.rs

@@ -85,13 +85,15 @@ fn render_launch_agent(executable: &Path) -> String {
     )
 }
 
+#[cfg(target_os = "linux")]
 fn run_command(program: &str, args: &[&str]) -> Result<std::process::Output> {
     std::process::Command::new(program)
         .args(args)
         .output()
         .with_context(|| format!("run `{program} {}`", args.join(" ")))
 }
 
+#[cfg(target_os = "linux")]
 fn ensure_success(program: &str, args: &[&str]) -> Result<()> {
     let output = run_command(program, args)?;
     if output.status.success() {

src/apps/desktop/src/api/agentic_api.rs

@@ -2497,6 +2497,33 @@ fn system_time_to_unix_secs(time: std::time::SystemTime) -> u64 {
     }
 }
 
+// ── Legion preset commands ──────────────────────────────────────────
+
+#[tauri::command]
+pub async fn list_legion_presets() -> Result<Vec<bitfun_core::agentic::agents::team_presets::LegionPreset>, String> {
+    bitfun_core::agentic::agents::team_presets::list_presets()
+}
+
+#[tauri::command]
+pub async fn get_legion_preset(id: String) -> Result<bitfun_core::agentic::agents::team_presets::LegionPreset, String> {
+    bitfun_core::agentic::agents::team_presets::get_preset(&id)
+}
+
+#[tauri::command]
+pub async fn create_legion_preset(preset: bitfun_core::agentic::agents::team_presets::LegionPreset) -> Result<(), String> {
+    bitfun_core::agentic::agents::team_presets::create_preset(&preset)
+}
+
+#[tauri::command]
+pub async fn update_legion_preset(preset: bitfun_core::agentic::agents::team_presets::LegionPreset) -> Result<(), String> {
+    bitfun_core::agentic::agents::team_presets::update_preset(&preset)
+}
+
+#[tauri::command]
+pub async fn delete_legion_preset(id: String) -> Result<(), String> {
+    bitfun_core::agentic::agents::team_presets::delete_preset(&id)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/apps/desktop/src/api/browser_api.rs

@@ -142,16 +142,14 @@ pub async fn browser_webview_create(
     let window = app
         .get_window("main")
         .ok_or_else(|| "main window not found".to_string())?;
-    let mut builder =
+    let builder =
         tauri::webview::WebviewBuilder::new(request.label, tauri::WebviewUrl::External(url))
             .initialization_script(video_decoder_compatibility_script())
             .transparent(false)
             .background_color(tauri::window::Color(0, 0, 0, 255));
 
     #[cfg(any(debug_assertions, feature = "devtools"))]
-    {
-        builder = builder.devtools(true);
-    }
+    let builder = builder.devtools(true);
 
     window
         .add_child(

src/apps/desktop/src/api/remote_workspace_policy.rs

@@ -278,6 +278,10 @@ pub const REMOTE_WORKSPACE_COMMAND_POLICIES: &[(&str, RemoteWorkspacePolicy)] =
     ),
     ("create_directory", RemoteWorkspacePolicy::LegacyUnaudited),
     ("create_file", RemoteWorkspacePolicy::LegacyUnaudited),
+    (
+        "create_legion_preset",
+        RemoteWorkspacePolicy::WorkspaceAgnostic,
+    ),
     ("create_miniapp", RemoteWorkspacePolicy::LegacyUnaudited),
     ("create_session", RemoteWorkspacePolicy::LegacyUnaudited),
     ("create_subagent", RemoteWorkspacePolicy::LegacyUnaudited),
@@ -305,6 +309,10 @@ pub const REMOTE_WORKSPACE_COMMAND_POLICIES: &[(&str, RemoteWorkspacePolicy)] =
     ),
     ("delete_directory", RemoteWorkspacePolicy::LegacyUnaudited),
     ("delete_file", RemoteWorkspacePolicy::LegacyUnaudited),
+    (
+        "delete_legion_preset",
+        RemoteWorkspacePolicy::WorkspaceAgnostic,
+    ),
     ("delete_mcp_server", RemoteWorkspacePolicy::LegacyUnaudited),
     ("delete_miniapp", RemoteWorkspacePolicy::LegacyUnaudited),
     (
@@ -477,6 +485,10 @@ pub const REMOTE_WORKSPACE_COMMAND_POLICIES: &[(&str, RemoteWorkspacePolicy)] =
         "get_latest_insights",
         RemoteWorkspacePolicy::LegacyUnaudited,
     ),
+    (
+        "get_legion_preset",
+        RemoteWorkspacePolicy::WorkspaceAgnostic,
+    ),
     ("get_mcp_prompt", RemoteWorkspacePolicy::LegacyUnaudited),
     (
         "get_mcp_remote_oauth_session",
@@ -727,6 +739,10 @@ pub const REMOTE_WORKSPACE_COMMAND_POLICIES: &[(&str, RemoteWorkspacePolicy)] =
         "list_directory_files",
         RemoteWorkspacePolicy::LegacyUnaudited,
     ),
+    (
+        "list_legion_presets",
+        RemoteWorkspacePolicy::WorkspaceAgnostic,
+    ),
     (
         "list_manageable_subagents",
         RemoteWorkspacePolicy::RemoteRouted,
@@ -1527,6 +1543,10 @@ pub const REMOTE_WORKSPACE_COMMAND_POLICIES: &[(&str, RemoteWorkspacePolicy)] =
         RemoteWorkspacePolicy::WorkspaceAgnostic,
     ),
     ("update_cron_job", RemoteWorkspacePolicy::LegacyUnaudited),
+    (
+        "update_legion_preset",
+        RemoteWorkspacePolicy::WorkspaceAgnostic,
+    ),
     (
         "update_custom_agent",
         RemoteWorkspacePolicy::LegacyUnaudited,

src/apps/desktop/src/lib.rs

@@ -924,6 +924,11 @@ pub async fn run() {
             api::agentic_api::generate_session_title,
             api::agentic_api::get_available_modes,
             api::agentic_api::get_default_review_team_definition,
+            api::agentic_api::list_legion_presets,
+            api::agentic_api::get_legion_preset,
+            api::agentic_api::create_legion_preset,
+            api::agentic_api::update_legion_preset,
+            api::agentic_api::delete_legion_preset,
             api::btw_api::btw_ask_stream,
             api::btw_api::btw_cancel,
             api::editor_ai_api::editor_ai_stream,

src/crates/adapters/ai-adapters/src/providers/openai/common.rs

@@ -376,7 +376,28 @@ pub(crate) fn convert_tools_flat(
     tools: Option<Vec<ToolDefinition>>,
 ) -> Option<Vec<serde_json::Value>> {
     tools.map(|defs| {
-        defs.into_iter()
+        let mut seen = std::collections::HashSet::new();
+        let mut dupes = Vec::new();
+        let filtered: Vec<ToolDefinition> = defs
+            .into_iter()
+            .filter(|tool| {
+                if !seen.insert(tool.name.clone()) {
+                    dupes.push(tool.name.clone());
+                    false
+                } else {
+                    true
+                }
+            })
+            .collect();
+        if !dupes.is_empty() {
+            log::error!(
+                target: "ai::openai_stream_request",
+                "DUPLICATE TOOL NAMES detected and deduplicated: {:?}",
+                dupes
+            );
+        }
+        filtered
+            .into_iter()
             .map(|tool| {
                 serde_json::json!({
                     "type": "function",

src/crates/adapters/ai-adapters/src/providers/openai/message_converter.rs

@@ -406,7 +406,27 @@ impl OpenAIMessageConverter {
 
     pub fn convert_tools(tools: Option<Vec<ToolDefinition>>) -> Option<Vec<Value>> {
         tools.map(|tool_defs| {
-            tool_defs
+            let mut seen = std::collections::HashSet::new();
+            let mut dupes = Vec::new();
+            let filtered: Vec<ToolDefinition> = tool_defs
+                .into_iter()
+                .filter(|tool| {
+                    if !seen.insert(tool.name.clone()) {
+                        dupes.push(tool.name.clone());
+                        false
+                    } else {
+                        true
+                    }
+                })
+                .collect();
+            if !dupes.is_empty() {
+                log::error!(
+                    target: "ai::openai_stream_request",
+                    "DUPLICATE TOOL NAMES detected and deduplicated: {:?}",
+                    dupes
+                );
+            }
+            filtered
                 .into_iter()
                 .map(|tool| {
                     json!({

src/crates/assembly/core/src/agentic/agents/definitions/modes/team.rs

@@ -40,6 +40,13 @@ impl TeamMode {
                 "Git".to_string(),
                 "ControlHub".to_string(),
                 "GetFileDiff".to_string(),
+                "SessionControl".to_string(),
+                "SessionMessage".to_string(),
+                "SessionHistory".to_string(),
+                "get_goal".to_string(),
+                "create_goal".to_string(),
+                "update_goal".to_string(),
+                "LegionControl".to_string(),
             ],
         }
     }

src/crates/assembly/core/src/agentic/agents/definitions/subagents/acp_agent.rs

@@ -0,0 +1,77 @@
+//! ACP bridge agent — an AgentRegistry entry for every configured ACP client.
+//!
+//! Each ACP client (OpenCode, Claude Code, CodeBuddy, etc.) is represented as a
+//! `SubAgent` so it appears in the agent selector and can be targeted by
+//! `SessionControl` / `SessionMessage` for legion orchestration.
+
+use crate::agentic::agents::{Agent, UserContextPolicy};
+use async_trait::async_trait;
+
+/// A thin Agent wrapper around a single ACP client config.
+#[allow(dead_code)]
+pub struct AcpAgent {
+    agent_id: String,
+    display_name: String,
+    default_tools: Vec<String>,
+}
+
+impl AcpAgent {
+    pub fn new(client_id: String, display_name: String) -> Self {
+        let agent_id = Self::agent_id_for(&client_id);
+        Self {
+            // ACP prompt tool is registered in the global tool registry by
+            // register_configured_tools() — do NOT add it to default_tools
+            // here, or the tool name will appear twice in the model manifest.
+            default_tools: vec![
+                "Read".to_string(),
+                "Grep".to_string(),
+                "Glob".to_string(),
+                "LS".to_string(),
+            ],
+            agent_id,
+            display_name,
+        }
+    }
+
+    /// The agent registry id: `acp__<client_id>`
+    pub fn agent_id_for(client_id: &str) -> String {
+        format!("acp__{client_id}")
+    }
+}
+
+#[async_trait]
+impl Agent for AcpAgent {
+    fn as_any(&self) -> &dyn std::any::Any {
+        self
+    }
+
+    fn id(&self) -> &str {
+        &self.agent_id
+    }
+
+    fn name(&self) -> &str {
+        &self.display_name
+    }
+
+    fn description(&self) -> &str {
+        "ACP agent"
+    }
+
+    fn prompt_template_name(&self, _model_name: Option<&str>) -> &str {
+        "acp_agent"
+    }
+
+    fn default_tools(&self) -> Vec<String> {
+        self.default_tools.clone()
+    }
+
+    fn user_context_policy(&self) -> UserContextPolicy {
+        UserContextPolicy::empty()
+            .with_workspace_context()
+            .with_workspace_instructions()
+    }
+
+    fn is_readonly(&self) -> bool {
+        false
+    }
+}

src/crates/assembly/core/src/agentic/agents/definitions/subagents/mod.rs

@@ -1,9 +1,11 @@
+mod acp_agent;
 mod computer_use;
 mod explore;
 mod file_finder;
 mod general_purpose;
 mod research_specialist;
 
+pub use acp_agent::AcpAgent;
 pub use computer_use::ComputerUseMode;
 pub use explore::ExploreAgent;
 pub use file_finder::FileFinderAgent;

src/crates/assembly/core/src/agentic/agents/mod.rs

@@ -5,6 +5,7 @@
 mod definitions;
 mod prompt_builder;
 mod registry;
+pub mod team_presets;
 
 use crate::agentic::session::{SystemPromptCacheIdentity, UserContextCacheIdentity};
 use crate::agentic::tools::framework::ToolExposure;
@@ -35,7 +36,8 @@ pub use definitions::review::{
 };
 pub use definitions::shared::ReadonlySubagent;
 pub use definitions::subagents::{
-    ComputerUseMode, ExploreAgent, FileFinderAgent, GeneralPurposeAgent, ResearchSpecialistAgent,
+    AcpAgent, ComputerUseMode, ExploreAgent, FileFinderAgent, GeneralPurposeAgent,
+    ResearchSpecialistAgent,
 };
 use indexmap::IndexMap;
 pub use prompt_builder::{
@@ -132,6 +134,8 @@ pub fn shared_coding_mode_tools() -> Vec<String> {
         "ReviewPlatform".to_string(),
         "ControlHub".to_string(),
         "InitMiniApp".to_string(),
+        "SessionMessage".to_string(),
+        "SessionHistory".to_string(),
     ];
     append_provider_group_tools(&mut tools, "core.canvas");
     tools

src/crates/assembly/core/src/agentic/agents/prompts/acp_agent.md

@@ -0,0 +1,17 @@
+You are a bridge to an external ACP agent running inside BitFun. A commander has delegated a task to you. Your job is to forward the task through your ACP tool and return the result, nothing more.
+
+## How You Work
+
+1. Read the task that was sent to you via SessionMessage.
+2. Call your ACP prompt tool with the task as the `prompt` parameter.
+3. Return the ACP agent's response exactly as received — do not summarise, reinterpret, or embellish.
+4. If the ACP tool returns an error, report the error with the original task context so the commander can decide how to proceed.
+
+## Constraints
+
+- You do NOT have file write or edit capabilities by default. Your only execution tool is the ACP bridge.
+- Do NOT ask the user questions. The commander is your only audience.
+- Be concise. The commander is managing many agents and needs clear, direct responses.
+- Do NOT pretend to perform work that should be delegated through the ACP tool.
+
+{LANGUAGE_PREFERENCE}