feat(subagents): implement coordinated subagents with unified tool dispatch and enhanced role management

- Introduced subagent events for tracking lifecycle: `SubagentStarted`, `SubagentStep`, `SubagentToolCall`, and `SubagentFinished`.
- Enhanced the timeline to display subagent activities and their statuses.
- Implemented environment detection and session caching for workspace management.
- Added Git tools scoped to the workspace, including commands for status, diff, log, and more.
- Established a shell execution framework with command allowlisting and child process management.
- Refactored tool dispatching to support subagent operations across multiple providers (Anthropic, OpenRouter, OpenAI).
- Updated documentation to reflect new features and usage guidelines for subagents.

Author: iptoux

.agents/plans/coordinated-subagents.md

@@ -11,16 +11,16 @@
 
 use super::system_prompt::system_prompt;
 use crate::agent::protocol::{AgentEvent, AgentImageContextItem};
-use crate::agent::state::{AgentEngineState, ClientToolResult};
-use crate::agent::tools::{self, ToolSite, WorkspaceRootGuard};
+use crate::agent::state::AgentEngineState;
+use crate::agent::tool_dispatch::{dispatch_tool, DispatchContext};
+use crate::agent::tools::{self, WorkspaceRootGuard};
 use crate::agent_settings::{AgentProviderSettings, ThinkingLevel};
 use crate::tasks;
 use serde::Deserialize;
 use serde_json::{json, Value};
 use std::sync::Arc;
 use std::time::Duration;
 use tokio::io::AsyncBufReadExt;
-use tokio::sync::oneshot;
 
 const ANTHROPIC_URL: &str = "https://api.anthropic.com/v1/messages";
 const ANTHROPIC_VERSION: &str = "2023-06-01";
@@ -131,6 +131,11 @@ pub async fn run_chat_turn(
     let thinking_cfg = thinking_budget(settings.thinking_level)
         .map(|budget| json!({ "type": "enabled", "budget_tokens": budget }));
 
+    let dispatch_ctx = DispatchContext {
+        settings: settings.clone(),
+        api_key: api_key.clone(),
+    };
+
     let client = match reqwest::Client::builder()
         .timeout(Duration::from_secs(180))
         .build()
@@ -234,7 +239,15 @@ pub async fn run_chat_turn(
             let args_val: Value =
                 serde_json::from_str(&call.arguments).unwrap_or_else(|_| json!({}));
             let outcome =
-                dispatch_tool(&state, &call.id, &call.name, &args_val, root_guard.as_ref()).await;
+                dispatch_tool(
+                    &state,
+                    &call.id,
+                    &call.name,
+                    &args_val,
+                    root_guard.as_ref(),
+                    Some(&dispatch_ctx),
+                )
+                .await;
 
             if outcome.ok && call.name.starts_with("task_") {
                 maybe_emit_task_snapshot(&state, root_guard.as_ref());
@@ -287,6 +300,7 @@ fn maybe_emit_task_snapshot(state: &Arc<AgentEngineState>, root: Option<&Workspa
 }
 
 fn emit_aborted(state: &Arc<AgentEngineState>) {
+    crate::agent::shell_exec::kill_all_children();
     state.push(AgentEvent::AssistantDelta {
         delta: "\n_Abgebrochen._\n".into(),
     });
@@ -648,65 +662,3 @@ mod tests {
         assert!(encoded.contains("marked read"));
     }
 }
-
-async fn dispatch_tool(
-    state: &Arc<AgentEngineState>,
-    call_id: &str,
-    name: &str,
-    args: &Value,
-    root: Option<&WorkspaceRootGuard>,
-) -> tools::ToolOutcome {
-    state.push(AgentEvent::ToolCall {
-        tool: name.to_owned(),
-        call_id: Some(call_id.to_owned()),
-        args: Some(args.clone()),
-    });
-
-    let Some(def) = tools::find(name) else {
-        return tools::ToolOutcome {
-            ok: false,
-            content: format!("unknown tool: {name}"),
-        };
-    };
-
-    match def.site {
-        ToolSite::Server => tools::execute_server_tool(name, args, root),
-        ToolSite::Client => wait_for_client_tool(state, call_id, name).await,
-    }
-}
-
-async fn wait_for_client_tool(
-    state: &Arc<AgentEngineState>,
-    call_id: &str,
-    name: &str,
-) -> tools::ToolOutcome {
-    let (tx, rx) = oneshot::channel::<ClientToolResult>();
-    state.register_client_tool(call_id.to_owned(), tx);
-
-    match rx.await {
-        Ok(res) => {
-            let mut body = res.message.unwrap_or_default();
-            if let Some(data) = res.data {
-                if !body.is_empty() {
-                    body.push('\n');
-                }
-                body.push_str(&data.to_string());
-            }
-            if body.is_empty() {
-                body = if res.ok {
-                    format!("{name} ok")
-                } else {
-                    format!("{name} failed")
-                };
-            }
-            tools::ToolOutcome {
-                ok: res.ok,
-                content: body,
-            }
-        }
-        Err(_) => tools::ToolOutcome {
-            ok: false,
-            content: format!("{name}: tool result channel closed"),
-        },
-    }
-}

src-tauri/src/agent/anthropic.rs

@@ -0,0 +1,135 @@
+//! Workspace environment detection and session cache.
+
+use crate::agent::tools::{ToolOutcome, WorkspaceRootGuard};
+use serde_json::{json, Value};
+use std::process::Command;
+use std::sync::{Mutex, OnceLock};
+
+#[derive(Clone, Debug)]
+struct CacheEntry {
+    workspace: String,
+    snapshot: Value,
+}
+
+static ENV_CACHE: OnceLock<Mutex<Option<CacheEntry>>> = OnceLock::new();
+
+fn cache() -> &'static Mutex<Option<CacheEntry>> {
+    ENV_CACHE.get_or_init(|| Mutex::new(None))
+}
+
+pub fn invalidate_cache() {
+    if let Ok(mut g) = cache().lock() {
+        *g = None;
+    }
+}
+
+pub fn workspace_has_cache(workspace: &str) -> bool {
+    cache()
+        .lock()
+        .ok()
+        .and_then(|g| g.as_ref().map(|e| e.workspace == workspace))
+        .unwrap_or(false)
+}
+
+pub fn require_environment(workspace: &str) -> Result<(), ToolOutcome> {
+    if workspace_has_cache(workspace) {
+        Ok(())
+    } else {
+        Err(ToolOutcome {
+            ok: false,
+            content: "call environment_detect first for this workspace".into(),
+        })
+    }
+}
+
+fn detect_os() -> &'static str {
+    match std::env::consts::OS {
+        "linux" => "linux",
+        "macos" => "macos",
+        "windows" => "windows",
+        other => other,
+    }
+}
+
+fn default_shell() -> &'static str {
+    if cfg!(windows) {
+        "powershell"
+    } else {
+        "bash"
+    }
+}
+
+fn available_shells() -> Vec<&'static str> {
+    if cfg!(windows) {
+        vec!["powershell", "pwsh", "cmd"]
+    } else {
+        vec!["bash", "sh"]
+    }
+}
+
+fn git_available() -> bool {
+    Command::new("git")
+        .arg("--version")
+        .output()
+        .map(|o| o.status.success())
+        .unwrap_or(false)
+}
+
+pub fn detect(root: &WorkspaceRootGuard) -> Value {
+    json!({
+        "os": detect_os(),
+        "arch": std::env::consts::ARCH,
+        "defaultShell": default_shell(),
+        "availableShells": available_shells(),
+        "pathSeparator": std::path::MAIN_SEPARATOR.to_string(),
+        "lineEnding": if cfg!(windows) { "\r\n" } else { "\n" },
+        "gitAvailable": git_available(),
+        "workspaceRoot": root.as_str(),
+    })
+}
+
+pub fn tool_environment_detect(root: Option<&WorkspaceRootGuard>) -> ToolOutcome {
+    let Some(root) = root else {
+        return ToolOutcome {
+            ok: false,
+            content: "no workspace configured".into(),
+        };
+    };
+    let snapshot = detect(root);
+    let ws = root.as_str();
+    if let Ok(mut g) = cache().lock() {
+        *g = Some(CacheEntry {
+            workspace: ws.clone(),
+            snapshot: snapshot.clone(),
+        });
+    }
+    match serde_json::to_string(&snapshot) {
+        Ok(body) => ToolOutcome {
+            ok: true,
+            content: body,
+        },
+        Err(e) => ToolOutcome {
+            ok: false,
+            content: format!("serialize environment: {e}"),
+        },
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn cache_invalidated_on_clear() {
+        let dir = std::env::temp_dir().join(format!("blx-env-test-{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let root = WorkspaceRootGuard::parse(dir.to_str().unwrap())
+            .unwrap()
+            .unwrap();
+        let _ = tool_environment_detect(Some(&root));
+        assert!(workspace_has_cache(&root.as_str()));
+        invalidate_cache();
+        assert!(!workspace_has_cache(&root.as_str()));
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+}