feat(team): team enhancements, subagentModel, parallel tool exec

Team coordination layer, sub-agent model wiring, parallel read-only tool
execution, and model-resolution robustness fixes. ~2,100 lines across 11
files — zero deletions of upstream functionality.

subagentModel config wiring (fix):
- RuntimeFeatureConfig.subagent_model field + accessor + parser so the
  subagentModel setting from /setup is actually read and stored instead
  of silently dropped.
- resolve_agent_model: subagentModel -> session provider model -> default.

Parallel tool execution (perf):
- ToolCall/ToolResult/TurnProgressReporter re-exported from runtime.
- CliToolExecutor::execute_batch runs read-only tools (read_file, glob,
  grep, WebFetch/WebSearch, LSP, Git*, ToolSearch, Skill, Agent*,
  TeamStatus, Task*) concurrently via std::thread::scope.
- Results in original model order; hooks stay sequential.

Team coordination layer (feature):
- AgentMessage, TaskClaim, TeamStatus tools + shared mailbox + mode
  presets (tiny/1x ... mega/6x) + enriched tool descriptions + team
  watcher.
- /team slash command: on/off/status of CLAWD_AGENT_TEAMS.

Model-resolution robustness fixes:
- qualify_for_provider(): prefix bare models with custom/ when provider
  is custom-openai so sub-agents route through the same endpoint.
- providerFallbacks.primary no longer silently overrides caller's model.
- 404 model-not-found falls through to next chain entry.
- Sub-agents call runtime::inject_config_as_env_fallbacks() so /setup
  credentials work for spawned agents.

Also:
- lane_completion test helper: remove stale team_id/task_id (compile fix).
- /team slash command: add missing validate_slash_command_input match arm.
- ApiError: add status_code() and response_body() accessors.

Tests: tools 112 passed, commands 42 passed, runtime team_cron 17 passed,
cli 205 passed, provider chain 4 passed.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: TheArchitectit

rust/crates/api/src/error.rs

@@ -180,6 +180,49 @@ impl ApiError {
         }
     }
 
+    /// HTTP status code for an `Api` error, if any. Used by callers (e.g. the
+    /// sub-agent provider chain) to decide whether to advance to the next
+    /// configured model — a 404 "model not found" on the primary should fall
+    /// through to the next fallback rather than killing the whole chain.
+    #[must_use]
+    pub fn status_code(&self) -> Option<reqwest::StatusCode> {
+        match self {
+            Self::Api { status, .. } => Some(*status),
+            Self::RetriesExhausted { last_error, .. } => last_error.status_code(),
+            Self::MissingCredentials { .. }
+            | Self::ContextWindowExceeded { .. }
+            | Self::ExpiredOAuthToken
+            | Self::Auth(_)
+            | Self::InvalidApiKeyEnv(_)
+            | Self::Http(_)
+            | Self::Io(_)
+            | Self::Json { .. }
+            | Self::InvalidSseFrame(_)
+            | Self::BackoffOverflow { .. }
+            | Self::RequestBodySizeExceeded { .. } => None,
+        }
+    }
+
+    /// Response body (best-effort) for an `Api` error, if any.
+    #[must_use]
+    pub fn response_body(&self) -> Option<&str> {
+        match self {
+            Self::Api { body, .. } => Some(body.as_str()),
+            Self::RetriesExhausted { last_error, .. } => last_error.response_body(),
+            Self::MissingCredentials { .. }
+            | Self::ContextWindowExceeded { .. }
+            | Self::ExpiredOAuthToken
+            | Self::Auth(_)
+            | Self::InvalidApiKeyEnv(_)
+            | Self::Http(_)
+            | Self::Io(_)
+            | Self::Json { .. }
+            | Self::InvalidSseFrame(_)
+            | Self::BackoffOverflow { .. }
+            | Self::RequestBodySizeExceeded { .. } => None,
+        }
+    }
+
     #[must_use]
     pub fn safe_failure_class(&self) -> &'static str {
         match self {

rust/crates/api/src/lib.rs

@@ -28,8 +28,9 @@ pub use providers::openai_compat::{
 };
 pub use providers::{
     detect_provider_kind, max_tokens_for_model, max_tokens_for_model_with_override,
-    model_family_identity_for, model_family_identity_for_kind, provider_diagnostics_for_model,
-    resolve_model_alias, ProviderDiagnostics, ProviderKind,
+    model_family_identity_for, model_family_identity_for_kind, model_token_limit,
+    provider_diagnostics_for_model, resolve_model_alias, ModelTokenLimit, ProviderDiagnostics,
+    ProviderKind,
 };
 pub use sse::{parse_frame, SseParser};
 pub use types::{

rust/crates/api/src/providers/mod.rs

@@ -270,6 +270,14 @@ pub fn metadata_for_model(model: &str) -> Option<ProviderMetadata> {
             default_base_url: openai_compat::DEFAULT_OPENAI_BASE_URL,
         });
     }
+    if canonical.starts_with("custom/") {
+        return Some(ProviderMetadata {
+            provider: ProviderKind::OpenAi,
+            auth_env: "CLAWCUSTOMOPENAI_API_KEY",
+            base_url_env: "CLAWCUSTOMOPENAI_BASE_URL",
+            default_base_url: openai_compat::DEFAULT_CUSTOM_OPENAI_BASE_URL,
+        });
+    }
     // Alibaba DashScope compatible-mode endpoint. Routes qwen/* and bare
     // qwen-* model names (qwen-max, qwen-plus, qwen-turbo, qwen-qwq, etc.)
     // to the OpenAI-compat client pointed at DashScope's /compatible-mode/v1.
@@ -377,6 +385,11 @@ pub fn detect_provider_kind(model: &str) -> ProviderKind {
     {
         return ProviderKind::OpenAi;
     }
+    // Explicit `custom/` prefix selects the Claw custom OpenAI-compat provider
+    // even when no other credentials are present.
+    if resolved_model.starts_with("custom/") {
+        return ProviderKind::OpenAi;
+    }
     if anthropic::has_auth_from_env_or_saved().unwrap_or(false) {
         return ProviderKind::Anthropic;
     }
@@ -666,15 +679,22 @@ pub fn model_token_limit(model: &str) -> Option<ModelTokenLimit> {
             max_output_tokens: 16_384,
             context_window_tokens: 256_000,
         }),
-        "qwen-max" => Some(ModelTokenLimit {
-            max_output_tokens: 8_192,
+        // Qwen models via DashScope / OpenAI-compat
+        "qwen3.6-35b-fast" | "qwen3-235b-a22b" | "qwen-max" | "qwen-plus" | "qwen-turbo"
+        | "qwen-qwq" => Some(ModelTokenLimit {
+            max_output_tokens: 16_384,
             context_window_tokens: 131_072,
         }),
-        "qwen-plus" => Some(ModelTokenLimit {
+        "glm-5.1-fast" => Some(ModelTokenLimit {
+            max_output_tokens: 16_384,
+            context_window_tokens: 200_000,
+        }),
+        // Generic fallback for any model: assume 128K context, 8K output.
+        // This prevents the "unknown model → no limit check → context overflow" bug.
+        _ => Some(ModelTokenLimit {
             max_output_tokens: 8_192,
             context_window_tokens: 131_072,
         }),
-        _ => None,
     }
 }
 
@@ -1138,6 +1158,21 @@ mod tests {
         assert_eq!(super::resolve_model_alias("KIMI"), "kimi-k2.5"); // case insensitive
     }
 
+    #[test]
+    fn custom_prefix_routes_to_custom_openai_env_vars() {
+        let meta = super::metadata_for_model("custom/openclaw_3750")
+            .expect("custom/ prefix must resolve to custom OpenAI metadata");
+        assert_eq!(meta.provider, ProviderKind::OpenAi);
+        assert_eq!(meta.auth_env, "CLAWCUSTOMOPENAI_API_KEY");
+        assert_eq!(meta.base_url_env, "CLAWCUSTOMOPENAI_BASE_URL");
+
+        assert_eq!(
+            detect_provider_kind("custom/openclaw_3750"),
+            ProviderKind::OpenAi,
+            "custom/ prefix must select OpenAi provider kind"
+        );
+    }
+
     #[test]
     fn provider_diagnostics_explain_openai_compatible_capabilities() {
         let diagnostics = super::provider_diagnostics_for_model("openai/deepseek-v4-pro");

rust/crates/api/src/providers/openai_compat.rs

@@ -21,6 +21,7 @@ use super::{preflight_message_request, resolve_model_alias, Provider, ProviderFu
 pub const DEFAULT_XAI_BASE_URL: &str = "https://api.x.ai/v1";
 pub const DEFAULT_OPENAI_BASE_URL: &str = "https://api.openai.com/v1";
 pub const DEFAULT_DASHSCOPE_BASE_URL: &str = "https://dashscope.aliyuncs.com/compatible-mode/v1";
+pub const DEFAULT_CUSTOM_OPENAI_BASE_URL: &str = "";
 const REQUEST_ID_HEADER: &str = "request-id";
 const ALT_REQUEST_ID_HEADER: &str = "x-request-id";
 const DEFAULT_INITIAL_BACKOFF: Duration = Duration::from_secs(1);

rust/crates/commands/src/lib.rs

@@ -65,6 +65,13 @@ const SLASH_COMMAND_SPECS: &[SlashCommandSpec] = &[
         argument_hint: None,
         resume_supported: true,
     },
+    SlashCommandSpec {
+        name: "tui",
+        aliases: &[],
+        summary: "Switch to the split-pane TUI dashboard",
+        argument_hint: None,
+        resume_supported: true,
+    },
     SlashCommandSpec {
         name: "status",
         aliases: &[],
@@ -808,7 +815,7 @@ const SLASH_COMMAND_SPECS: &[SlashCommandSpec] = &[
         name: "team",
         aliases: &[],
         summary: "Manage agent teams",
-        argument_hint: Some("[list|create|delete]"),
+        argument_hint: Some("[on|off|status]"),
         resume_supported: true,
     },
     SlashCommandSpec {
@@ -1188,10 +1195,14 @@ pub enum SlashCommand {
     History {
         count: Option<String>,
     },
-    Unknown(String),
+    Lsp {
+        action: Option<String>,
+        target: Option<String>,
+    },
     Team {
         action: Option<String>,
     },
+    Unknown(String),
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -1509,6 +1520,9 @@ pub fn validate_slash_command_input(
         "history" => SlashCommand::History {
             count: optional_single_arg(command, &args, "[count]")?,
         },
+        "team" => SlashCommand::Team {
+            action: optional_single_arg(command, &args, "[list|create|delete]")?,
+        },
         other => SlashCommand::Unknown(other.to_string()),
     }))
 }
@@ -5393,6 +5407,7 @@ pub fn handle_slash_command(
         | SlashCommand::OutputStyle { .. }
         | SlashCommand::AddDir { .. }
         | SlashCommand::History { .. }
+        | SlashCommand::Lsp { .. }
         | SlashCommand::Team { .. }
         | SlashCommand::Setup
         | SlashCommand::Unknown(_) => None,
@@ -5525,6 +5540,16 @@ mod tests {
     #[test]
     fn parses_supported_slash_commands() {
         assert_eq!(SlashCommand::parse("/help"), Ok(Some(SlashCommand::Help)));
+        assert_eq!(
+            SlashCommand::parse("/team"),
+            Ok(Some(SlashCommand::Team { action: None }))
+        );
+        assert_eq!(
+            SlashCommand::parse("/team on"),
+            Ok(Some(SlashCommand::Team {
+                action: Some("on".to_string())
+            }))
+        );
         assert_eq!(
             SlashCommand::parse(" /status "),
             Ok(Some(SlashCommand::Status))
@@ -6012,7 +6037,7 @@ mod tests {
         assert!(!help.contains("/login"));
         assert!(!help.contains("/logout"));
         assert!(help.contains("/setup"));
-        assert_eq!(slash_command_specs().len(), 140);
+        assert_eq!(slash_command_specs().len(), 141);
         assert!(resume_supported_slash_commands().len() >= 39);
     }
 

rust/crates/runtime/src/config.rs

@@ -163,6 +163,10 @@ pub struct RuntimeFeatureConfig {
     api_timeout: ApiTimeoutConfig,
     rules_import: RulesImportConfig,
     provider: RuntimeProviderConfig,
+    /// Model override used when spawning sub-agents via the Agent tool.
+    /// Read from `subagentModel` (or `subagent_model`) in settings; falls
+    /// back to the default model when unset.
+    subagent_model: Option<String>,
 }
 
 /// Controls which external AI coding framework rules are imported into the system prompt.
@@ -801,6 +805,7 @@ fn build_runtime_config(
         api_timeout: parse_optional_api_timeout_config(&merged_value)?,
         rules_import: parse_optional_rules_import(&merged_value)?,
         provider: parse_optional_provider_config(&merged_value)?,
+        subagent_model: parse_optional_subagent_model(&merged_value),
     };
 
     Ok(RuntimeConfig {
@@ -880,6 +885,13 @@ impl RuntimeConfig {
         self.feature_config.model.as_deref()
     }
 
+    /// Model override used when spawning sub-agents via the Agent tool.
+    /// Read from `subagentModel` in settings; `None` means "use default model".
+    #[must_use]
+    pub fn subagent_model(&self) -> Option<&str> {
+        self.feature_config.subagent_model.as_deref()
+    }
+
     #[must_use]
     pub fn aliases(&self) -> &BTreeMap<String, String> {
         &self.feature_config.aliases
@@ -1717,6 +1729,21 @@ fn parse_optional_model(root: &JsonValue) -> Option<String> {
         .map(ToOwned::to_owned)
 }
 
+/// Reads `subagentModel` (or the snake_case `subagent_model` alias) from
+/// merged settings. Returns `None` when absent or blank so the Agent tool
+/// falls back to the default model.
+fn parse_optional_subagent_model(root: &JsonValue) -> Option<String> {
+    root.as_object()
+        .and_then(|object| {
+            object
+                .get("subagentModel")
+                .or_else(|| object.get("subagent_model"))
+        })
+        .and_then(JsonValue::as_str)
+        .filter(|s| !s.trim().is_empty())
+        .map(|s| s.trim().to_string())
+}
+
 fn parse_optional_aliases(root: &JsonValue) -> Result<BTreeMap<String, String>, ConfigError> {
     let Some(object) = root.as_object() else {
         return Ok(BTreeMap::new());
@@ -2581,6 +2608,49 @@ fn deep_merge_objects(
     }
 }
 
+/// Read the provider config saved by `/setup` and inject its credentials
+/// into the environment so `ProviderClient::from_model()` can find them via
+/// the env-var-based provider dispatch. Only sets vars that aren't already
+/// present (preserves explicit env). Idempotent.
+///
+/// Called by the main CLI at startup and by sub-agent threads in the tools
+/// crate so that custom/ exotic providers work for spawned agents too.
+pub fn inject_config_as_env_fallbacks() {
+    let cwd = std::env::current_dir().unwrap_or_default();
+    let Ok(config) = ConfigLoader::default_for(&cwd).load() else {
+        return;
+    };
+    let provider = config.provider();
+
+    // Map provider kind to the expected env var names
+    let (api_key_env, base_url_env) = match provider.kind().unwrap_or("anthropic") {
+        "anthropic" => ("ANTHROPIC_API_KEY", "ANTHROPIC_BASE_URL"),
+        "xai" => ("XAI_API_KEY", "XAI_BASE_URL"),
+        "openai" => ("OPENAI_API_KEY", "OPENAI_BASE_URL"),
+        "dashscope" => ("DASHSCOPE_API_KEY", "DASHSCOPE_BASE_URL"),
+        "custom-openai" => ("CLAWCUSTOMOPENAI_API_KEY", "CLAWCUSTOMOPENAI_BASE_URL"),
+        _ => return, // unknown provider kind — don't inject
+    };
+
+    // Only set env vars that aren't already set (preserve user's explicit env)
+    if let Some(api_key) = provider.api_key() {
+        if std::env::var(api_key_env).is_err() {
+            std::env::set_var(api_key_env, api_key);
+        }
+    }
+    if let Some(base_url) = provider.base_url() {
+        if std::env::var(base_url_env).is_err() {
+            std::env::set_var(base_url_env, base_url);
+        }
+    }
+    // Also inject the saved model so resolve_model_alias sees it
+    if let Some(model) = provider.model() {
+        if std::env::var("CLAWD_PROVIDER_MODEL").is_err() {
+            std::env::set_var("CLAWD_PROVIDER_MODEL", model);
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::{