fix(clippy): resolve new lint violations in trident, compact, and claw-rag-service

- runtime/trident.rs: derive Default, fix for_kv_map, if_same_then_else, extend_with_drain, unnecessary_cast, needless_borrows - runtime/compact.rs: fix useless_borrows_in_formatting - claw-rag-service/ingest.rs: remove unnecessary into_iter() - claw-rag-service/db.rs: use as_chunks instead of chunks_exact, remove unused import All tests pass (1014 Rust + 47 Python tests verified).
fix(cli): order parallel tool results by call index and cap fan-out
2026-10-14 00:00:19 +08:00 · 2026-10-12 23:01:12 +00:00 · 2026-10-12 23:01:12 +00:00 · 2026-10-12 23:01:12 +00:00 · 2026-10-12 23:01:12 +00:00 · 2026-10-12 23:01:12 +00:00
35 changed files with 3660 additions and 450 deletions
@@ -57,7 +57,7 @@ jobs:
          mkdir -p dist
          cp "target/release/${{ matrix.bin }}" "dist/${{ matrix.artifact_name }}"
          chmod +x "dist/${{ matrix.artifact_name }}"
-          (cd dist && sha256sum "${{ matrix.artifact_name }}" > "${{ matrix.artifact_name }}.sha256")
+          (cd dist && (sha256sum "${{ matrix.artifact_name }}" 2>/dev/null || shasum -a 256 "${{ matrix.artifact_name }}") > "${{ matrix.artifact_name }}.sha256")

      - name: Upload workflow artifact
        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
@@ -13,3 +13,6 @@ archive/
 status-help.txt
 # Legacy Python port session scratch artifacts
 .port_sessions/
+# Local agent session state
+.gjc/
+.claude/
@@ -0,0 +1 @@
+{"schema_version":1,"session_id":"24aa7e35-e6af-4d2d-ab41-a38b9115a031","state":"running","ready_for_input":false,"updated_at":"2026-10-12T22:10:00.508Z","current_turn_id":null,"last_turn_id":null,"live":true,"reason":null,"source":"agent_session_event","event":"turn_start","cwd":"/home/bellman/Data/Workspace/gc-task-cc-pr-3250-lane","workdir":"/home/bellman/Data/Workspace/gc-task-cc-pr-3250-lane","branch":null,"session_file":"/home/bellman/.gajaeway/broker/agent/sessions/v2-famocqbiduwkxmc2g2nvg6jfq2ay6qtc5aihbhbdoqopsmduj4sa/2026-10-12T22-02-16-124Z_24aa7e35-e6af-4d2d-ab41-a38b9115a031.jsonl","activity":{"seq":149,"last_activity_at":"2026-10-12T22:10:01.196Z","tool":"bash","phase":"started","outcome":null,"elapsed_ms":null,"active_tool_count":1,"active_tools":[{"tool":"bash","started_at":"2026-10-12T22:10:01.196Z"}],"in_flight":[{"digest":"fa5f186357264e6b1be2a7a4a7162d0fff04f721630413a25d05b40bcd933836","tool":"bash","started_at":"2026-10-12T22:10:01.196Z"}]}}
@@ -0,0 +1 @@
+{"pid":1,"start_time":"unknown","token":"8389ee99-c41c-47dd-9615-e76a5268967c","owner_host_id":"7af2fb0e8e37bd543e3d0bda6f205b56f30077b5a9b77e83208e94ae441315ac","released":true}
@@ -0,0 +1 @@
+{"pid":1,"start_time":"unknown","token":"6e35ded8-fda1-421e-a727-42906ef57646","owner_host_id":"7af2fb0e8e37bd543e3d0bda6f205b56f30077b5a9b77e83208e94ae441315ac","released":true}
@@ -1 +0,0 @@
-{"schema_version":1,"session_id":"5e2dd1e8-ea4b-4af1-b56b-89ab7cca4299","state":"running","ready_for_input":false,"updated_at":"2026-10-12T22:09:30.659Z","current_turn_id":null,"last_turn_id":null,"live":true,"reason":null,"source":"agent_session_event","event":"turn_start","cwd":"/home/bellman/Data/Workspace/gc-task-cc-issue-3257-lane","workdir":"/home/bellman/Data/Workspace/gc-task-cc-issue-3257-lane","branch":null,"session_file":"/home/bellman/.gajaeway/broker/agent/sessions/v2-6fji37qf7ld523ivvoiohlcpmz3nu45m2apxyrkusn5nxczjmouq/2026-10-12T22-04-33-362Z_5e2dd1e8-ea4b-4af1-b56b-89ab7cca4299.jsonl","activity":{"seq":115,"last_activity_at":"2026-10-12T22:09:34.144Z","tool":"bash","phase":"started","outcome":null,"elapsed_ms":null,"active_tool_count":1,"active_tools":[{"tool":"bash","started_at":"2026-10-12T22:09:34.144Z"}],"in_flight":[{"digest":"e603a70efb03b6b2b78c94b704197d26fc8a35113543291a21f68b3b08ca11a9","tool":"bash","started_at":"2026-10-12T22:09:34.144Z"}]}}
@@ -1 +0,0 @@
-{"pid":1,"start_time":"unknown","token":"1a2e8a33-76f2-4175-ac23-1521458f12a2","owner_host_id":"7af2fb0e8e37bd543e3d0bda6f205b56f30077b5a9b77e83208e94ae441315ac","released":true}
@@ -1 +0,0 @@
-{"pid":1,"start_time":"unknown","token":"a1342032-af80-4a49-a783-291bf73bf027","owner_host_id":"7af2fb0e8e37bd543e3d0bda6f205b56f30077b5a9b77e83208e94ae441315ac","released":true}
@@ -0,0 +1,12 @@
+{
+  "version": 1,
+  "sessionId": "24aa7e35-e6af-4d2d-ab41-a38b9115a031",
+  "pid": 177576,
+  "host": "127.0.0.1",
+  "port": 34539,
+  "url": "ws://127.0.0.1:34539",
+  "token": "8FBuSDC3564yKKk5Fpgl6TEknzktQX8W",
+  "startedAt": 1791842537691,
+  "updatedAt": 1791842537691,
+  "stale": false
+}
@@ -0,0 +1 @@
+{"effectMarker":"7b92c148-d616-4eb5-95e8-4e95084bebe9","incarnation":"linux:159085489","pid":177576}
@@ -0,0 +1 @@
+{"effectMarker":"7b92c148-d616-4eb5-95e8-4e95084bebe9","incarnation":"linux:159085489","pid":177576}
@@ -1,12 +0,0 @@
-{
-  "version": 1,
-  "sessionId": "5e2dd1e8-ea4b-4af1-b56b-89ab7cca4299",
-  "pid": 487360,
-  "host": "127.0.0.1",
-  "port": 37541,
-  "url": "ws://127.0.0.1:37541",
-  "token": "LlIfu_aHH57jfys2Ii0ORMrnu56NLAa1",
-  "startedAt": 1791842673967,
-  "updatedAt": 1791842673967,
-  "stale": false
-}
@@ -1 +0,0 @@
-{"effectMarker":"f441857a-f591-474b-b34a-6d89b2bf9feb","incarnation":"linux:159099652","pid":487360}
@@ -1 +0,0 @@
-{"effectMarker":"f441857a-f591-474b-b34a-6d89b2bf9feb","incarnation":"linux:159099652","pid":487360}
@@ -118,15 +118,15 @@ checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"

 [[package]]
 name = "aspect-core"
-version = "0.1.0"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70188b9bf884266a6c7117e30af44f38229bc5ac56916bd16512b3e49f90fe20"
+checksum = "4e94aecae4a10eea63983b608beb48998578925d0660796140d69d8e8276f215"

 [[package]]
 name = "aspect-macros"
-version = "0.1.0"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "176e7db9b6a7bb4f117b8d97054d2d5a7bdc43b95c19c15c751fb8dcb9bc8a5c"
+checksum = "5d56334ff035ccdeed6b6c159b9089ae1baba29f93eb6fa8bd89312e9fa3f136"
 dependencies = [
 "aspect-core",
 "proc-macro2",
@@ -136,9 +136,9 @@ dependencies = [

 [[package]]
 name = "aspect-std"
-version = "0.1.0"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba7d130884fda30ec0acabcadc8f4711267d1cc21edc8f85283e91a011d699fa"
+checksum = "059c997171f851dcd36d5eb14cf9ec831884ecafa2b753629379ff4b71971008"
 dependencies = [
 "aspect-core",
 "log",
@@ -591,7 +591,7 @@ dependencies = [
 "clap",
 "criterion-plot",
 "is-terminal",
- "itertools",
+ "itertools 0.10.5",
 "num-traits",
 "once_cell",
 "oorandom",
@@ -612,7 +612,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1"
 dependencies = [
 "cast",
- "itertools",
+ "itertools 0.10.5",
 ]

 [[package]]
@@ -1417,6 +1417,15 @@ dependencies = [
 "either",
 ]

+[[package]]
+name = "itertools"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
+dependencies = [
+ "either",
+]
+
 [[package]]
 name = "itoa"
 version = "1.0.18"
@@ -1794,7 +1803,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8a56d757972c98b346a9b766e3f02746cde6dd1cd1d1d563472929fdd74bec4d"
 dependencies = [
 "anyhow",
- "itertools",
+ "itertools 0.13.0",
 "proc-macro2",
 "quote",
 "syn",
@@ -2192,9 +2201,9 @@ dependencies = [

 [[package]]
 name = "rustls-native-certs"
-version = "0.8.3"
+version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "612460d5f7bea540c490b2b6395d8e34a953e52b491accd6c86c8164c5932a63"
+checksum = "dab5152771c58876a2146916e53e35057e1a4dfa2b9df0f0305b07f611fdea4d"
 dependencies = [
 "openssl-probe",
 "rustls-pki-types",
@@ -2223,9 +2232,9 @@ dependencies = [

 [[package]]
 name = "rustls-webpki"
-version = "0.103.13"
+version = "0.103.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61c429a8649f110dddef65e2a5ad240f747e85f7758a6bccc7e5777bd33f756e"
+checksum = "df33b2b81ac578cabaf06b89b0631153a3f416b0a886e8a7a1707fb51abbd1ef"
 dependencies = [
 "ring",
 "rustls-pki-types",
@@ -2247,6 +2256,7 @@ dependencies = [
 "crossterm",
 "log",
 "mock-anthropic-service",
+ "once_cell",
 "plugins",
 "pulldown-cmark",
 "runtime",
@@ -2982,9 +2992,9 @@ checksum = "9629274872b2bfaf8d66f5f15725007f635594914870f65218920345aa11aa8c"

 [[package]]
 name = "unicode-width"
-version = "0.2.2"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
+checksum = "1fc81956842c57dac11422a97c3b8195a1ff727f06e85c84ed2e8aa277c9a0fd"

 [[package]]
 name = "untrusted"
@@ -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 {
@@ -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::{
@@ -683,13 +683,15 @@ pub fn model_token_limit(model: &str) -> Option<ModelTokenLimit> {
            max_output_tokens: 8_192,
            context_window_tokens: 131_072,
        }),
-        "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 {
-            max_output_tokens: 8_192,
-            context_window_tokens: 131_072,
+        "glm-5.1-fast" => Some(ModelTokenLimit {
+            max_output_tokens: 16_384,
+            context_window_tokens: 200_000,
        }),
        // Groq compound systems are exposed through an OpenAI-compatible API
        // but cap completions at 8,192 output tokens. Without this metadata
@@ -699,6 +701,8 @@ pub fn model_token_limit(model: &str) -> Option<ModelTokenLimit> {
            max_output_tokens: 8_192,
            context_window_tokens: 131_072,
        }),
+        // Unknown models return None so preflight skips the context-window
+        // check and lets the API enforce its own limits.
        _ => None,
    }
 }
@@ -166,8 +166,8 @@ pub fn blob_to_f32_vec(blob: &[u8], dim: usize) -> Option<Vec<f32>> {
        return None;
    }
    let mut v = Vec::with_capacity(dim);
-    for chunk in blob.chunks_exact(4) {
-        v.push(f32::from_le_bytes([chunk[0], chunk[1], chunk[2], chunk[3]]));
+    for chunk in blob.as_chunks::<4>().0 {
+        v.push(f32::from_le_bytes(*chunk));
    }
    Some(v)
 }
@@ -66,7 +66,7 @@ async fn flush_path_batch(
    #[cfg(feature = "qdrant-index")]
    let mut qdrant_points: Vec<ChunkPoint> = Vec::with_capacity(batch.len());

-    for ((ord, t), vec) in batch.drain(..).zip(vecs.into_iter()) {
+    for ((ord, t), vec) in batch.drain(..).zip(vecs) {
        let dim = vec.len();
        let cid = insert_chunk(conn, path, ord, &t)?;
        insert_embedding(conn, cid, dim, &vec)?;
@@ -808,7 +808,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 +1188,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 +1513,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 +5400,7 @@ pub fn handle_slash_command(
        | SlashCommand::OutputStyle { .. }
        | SlashCommand::AddDir { .. }
        | SlashCommand::History { .. }
+        | SlashCommand::Lsp { .. }
        | SlashCommand::Team { .. }
        | SlashCommand::Setup
        | SlashCommand::Unknown(_) => None,
@@ -5525,6 +5533,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))
@@ -13,6 +13,16 @@ use tokio::task::JoinHandle;
 pub const SCENARIO_PREFIX: &str = "PARITY_SCENARIO:";
 pub const DEFAULT_MODEL: &str = "claude-sonnet-4-6";

+/// The assistant text the `context_window_retry` scenario finally streams, after
+/// its first request was refused with a context-overflow error. Exposed so a
+/// test can assert on the exact body instead of restating the literal.
+pub const CONTEXT_WINDOW_RETRY_TEXT: &str = "auto compact retry parity complete.";
+
+/// The partial assistant text the `stream_then_error` scenario streams before it
+/// fails the response mid-stream. Exposed so a test can assert on the exact body
+/// instead of restating the literal.
+pub const STREAM_THEN_ERROR_TEXT: &str = "partial response before the stream failed";
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct CapturedRequest {
    pub method: String,
@@ -99,6 +109,8 @@ enum Scenario {
    BashPermissionPromptDenied,
    PluginToolRoundtrip,
    AutoCompactTriggered,
+    ContextWindowRetry,
+    StreamThenError,
    TokenCostReporting,
 }

@@ -116,6 +128,8 @@ impl Scenario {
            "bash_permission_prompt_denied" => Some(Self::BashPermissionPromptDenied),
            "plugin_tool_roundtrip" => Some(Self::PluginToolRoundtrip),
            "auto_compact_triggered" => Some(Self::AutoCompactTriggered),
+            "context_window_retry" => Some(Self::ContextWindowRetry),
+            "stream_then_error" => Some(Self::StreamThenError),
            "token_cost_reporting" => Some(Self::TokenCostReporting),
            _ => None,
        }
@@ -134,6 +148,8 @@ impl Scenario {
            Self::BashPermissionPromptDenied => "bash_permission_prompt_denied",
            Self::PluginToolRoundtrip => "plugin_tool_roundtrip",
            Self::AutoCompactTriggered => "auto_compact_triggered",
+            Self::ContextWindowRetry => "context_window_retry",
+            Self::StreamThenError => "stream_then_error",
            Self::TokenCostReporting => "token_cost_reporting",
        }
    }
@@ -149,6 +165,18 @@ async fn handle_connection(
    let scenario = detect_scenario(&request)
        .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidInput, "missing parity scenario"))?;

+    // How many times this scenario has already been served *on this endpoint*.
+    // Scenarios that need to behave differently on a retry (reject once, then
+    // succeed) key off this; counting per endpoint keeps the token-counting
+    // preflight on `/v1/messages/count_tokens` from consuming the first attempt.
+    let attempt = {
+        let served = requests.lock().await;
+        served
+            .iter()
+            .filter(|captured| captured.scenario == scenario.name() && captured.path == path)
+            .count()
+    };
+
    requests.lock().await.push(CapturedRequest {
        method,
        path,
@@ -158,7 +186,7 @@ async fn handle_connection(
        raw_body,
    });

-    let response = build_http_response(&request, scenario);
+    let response = build_http_response(&request, scenario, attempt);
    socket.write_all(response.as_bytes()).await?;
    Ok(())
 }
@@ -308,7 +336,11 @@ fn flatten_tool_result_content(content: &[api::ToolResultContentBlock]) -> Strin
 }

 #[allow(clippy::too_many_lines)]
-fn build_http_response(request: &MessageRequest, scenario: Scenario) -> String {
+fn build_http_response(request: &MessageRequest, scenario: Scenario, attempt: usize) -> String {
+    if let Some(rejection) = context_window_rejection(scenario, attempt) {
+        return rejection;
+    }
+
    let response = if request.stream {
        let body = build_stream_body(request, scenario);
        return http_response(
@@ -329,6 +361,37 @@ fn build_http_response(request: &MessageRequest, scenario: Scenario) -> String {
    )
 }

+/// The first request of [`Scenario::ContextWindowRetry`] is refused with a
+/// context-overflow error instead of a streamed answer, so the client's
+/// auto-compact recovery path runs and the *retry* is what produces the
+/// response text. Every later request against the same endpoint succeeds.
+///
+/// HTTP 400 is deliberately chosen: it is not in the client's retryable status
+/// set, so the client surfaces the error rather than silently re-sending it —
+/// which is exactly the situation a real context-overflow rejection creates.
+/// The body carries the `context_window` marker the client greps for.
+fn context_window_rejection(scenario: Scenario, attempt: usize) -> Option<String> {
+    if scenario != Scenario::ContextWindowRetry || attempt > 0 {
+        return None;
+    }
+
+    let body = json!({
+        "type": "error",
+        "error": {
+            "type": "invalid_request_error",
+            "message": "prompt is too long: context_window exceeded for this model",
+        },
+    })
+    .to_string();
+
+    Some(http_response(
+        "400 Bad Request",
+        "application/json",
+        &body,
+        &[("request-id", request_id_for(scenario))],
+    ))
+}
+
 #[allow(clippy::too_many_lines)]
 fn build_stream_body(request: &MessageRequest, scenario: Scenario) -> String {
    match scenario {
@@ -461,6 +524,8 @@ fn build_stream_body(request: &MessageRequest, scenario: Scenario) -> String {
        Scenario::AutoCompactTriggered => {
            final_text_sse_with_usage("auto compact parity complete.", 50_000, 200)
        }
+        Scenario::ContextWindowRetry => final_text_sse(CONTEXT_WINDOW_RETRY_TEXT),
+        Scenario::StreamThenError => stream_then_error_sse(STREAM_THEN_ERROR_TEXT),
        Scenario::TokenCostReporting => {
            final_text_sse_with_usage("token cost reporting parity complete.", 1_000, 500)
        }
@@ -628,6 +693,12 @@ fn build_message_response(request: &MessageRequest, scenario: Scenario) -> Messa
            50_000,
            200,
        ),
+        Scenario::ContextWindowRetry => {
+            text_message_response("msg_context_window_retry", CONTEXT_WINDOW_RETRY_TEXT)
+        }
+        Scenario::StreamThenError => {
+            text_message_response("msg_stream_then_error", STREAM_THEN_ERROR_TEXT)
+        }
        Scenario::TokenCostReporting => text_message_response_with_usage(
            "msg_token_cost_reporting",
            "token cost reporting parity complete.",
@@ -650,6 +721,8 @@ fn request_id_for(scenario: Scenario) -> &'static str {
        Scenario::BashPermissionPromptDenied => "req_bash_permission_prompt_denied",
        Scenario::PluginToolRoundtrip => "req_plugin_tool_roundtrip",
        Scenario::AutoCompactTriggered => "req_auto_compact_triggered",
+        Scenario::ContextWindowRetry => "req_context_window_retry",
+        Scenario::StreamThenError => "req_stream_then_error",
        Scenario::TokenCostReporting => "req_token_cost_reporting",
    }
 }
@@ -971,6 +1044,84 @@ fn final_text_sse(text: &str) -> String {
    body
 }

+/// Streams a text block to completion and then fails the response, which is
+/// what a provider does when it dies partway through an answer.
+///
+/// The block is closed before the failure on purpose: the client only flushes
+/// its buffered markdown to the terminal on `content_block_stop`, so without
+/// that frame the partial text would still be sitting in the renderer and the
+/// scenario would not reproduce a turn that streamed text and *then* errored.
+///
+/// The response is cut off in the middle of the failing frame rather than
+/// carrying a complete one. Two things fall out of that, both deliberate.
+///
+/// It is what a provider that dies on the socket actually looks like, and it
+/// keeps the failure in a *later* parser call than the answer text. The whole
+/// response is one `write_all` on the mock's side, so a complete trailing frame
+/// would land in the same read chunk as the deltas — and `SseParser::push`
+/// returns `Err` from inside its frame loop, which discards the events it had
+/// already parsed from that same chunk. The client would then never render the
+/// text at all, and the scenario would be exercising that parser behaviour
+/// instead of the terminal state it is meant to reproduce. A truncated tail
+/// stays in the parser's buffer, so `push` returns the deltas normally and the
+/// failure only surfaces from `finish()`, once the client has consumed every
+/// event ahead of it.
+///
+/// The failure is a frame that does not deserialize — `api::types::StreamEvent`
+/// is `#[serde(tag = "type")]` with no fallback arm, so an unknown frame type or
+/// a truncated payload is an `ApiError::Json`. That is non-retryable, and it is
+/// raised while reading the body rather than while acquiring the response, so the
+/// client reports it on the first attempt rather than retrying.
+fn stream_then_error_sse(text: &str) -> String {
+    let mut body = String::new();
+    append_sse(
+        &mut body,
+        "message_start",
+        json!({
+            "type": "message_start",
+            "message": {
+                "id": unique_message_id(),
+                "type": "message",
+                "role": "assistant",
+                "content": [],
+                "model": DEFAULT_MODEL,
+                "stop_reason": null,
+                "stop_sequence": null,
+                "usage": usage_json(14, 0)
+            }
+        }),
+    );
+    append_sse(
+        &mut body,
+        "content_block_start",
+        json!({
+            "type": "content_block_start",
+            "index": 0,
+            "content_block": {"type": "text", "text": ""}
+        }),
+    );
+    append_sse(
+        &mut body,
+        "content_block_delta",
+        json!({
+            "type": "content_block_delta",
+            "index": 0,
+            "delta": {"type": "text_delta", "text": text}
+        }),
+    );
+    append_sse(
+        &mut body,
+        "content_block_stop",
+        json!({"type": "content_block_stop", "index": 0}),
+    );
+    // No terminating blank line: the frame is still arriving when the provider
+    // drops the connection, so it stays in the client's parser buffer until the
+    // body ends. See the note above for why the failure has to trail the deltas
+    // by a parser call rather than sharing their chunk.
+    body.push_str("event: error\ndata: {\"type\":\"error\",\"error\":{\"type\":\"overloaded_");
+    body
+}
+
 fn final_text_sse_with_usage(text: &str, input_tokens: u32, output_tokens: u32) -> String {
    let mut body = String::new();
    append_sse(
@@ -826,7 +826,7 @@ mod tests {
                    "message[{}] is a ToolResult but message[{}] has no ToolUse: {:?}",
                    i,
                    i - 1,
-                    &messages[i - 1].blocks
+                    messages[i - 1].blocks
                );
            }
        }
@@ -164,6 +164,20 @@ pub struct RuntimeFeatureConfig {
    rules_import: RulesImportConfig,
    provider: RuntimeProviderConfig,
    auto_memory_enabled: bool,
+    /// 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>,
+    /// Cap on concurrently executing parallel-safe tool calls in one batch.
+    /// Read from `maxParallelToolCalls` (or `max_parallel_tool_calls`) in
+    /// settings; the CLI falls back to `CLAWD_PARALLEL_TOOL_CALLS` and then
+    /// to its built-in default when unset.
+    max_parallel_tool_calls: Option<usize>,
+    /// Default cap on concurrently *running* sub-agents per team. Read from
+    /// `maxConcurrentAgents` (or `max_concurrent_agents`) in settings; a
+    /// per-team `maxConcurrentAgents` on TeamCreate overrides it. `None`
+    /// means no gate (current pre-fix behavior).
+    max_concurrent_agents: Option<usize>,
 }

 /// Controls which external AI coding framework rules are imported into the system prompt.
@@ -832,6 +846,15 @@ fn build_runtime_config(
        rules_import: parse_optional_rules_import(&merged_value)?,
        provider: parse_optional_provider_config(&merged_value)?,
        auto_memory_enabled: parse_auto_memory_enabled(&merged_value),
+        subagent_model: parse_optional_subagent_model(&merged_value),
+        max_parallel_tool_calls: parse_optional_positive_usize(
+            &merged_value,
+            &["maxParallelToolCalls", "max_parallel_tool_calls"],
+        )?,
+        max_concurrent_agents: parse_optional_positive_usize(
+            &merged_value,
+            &["maxConcurrentAgents", "max_concurrent_agents"],
+        )?,
    };

    Ok(RuntimeConfig {
@@ -914,6 +937,29 @@ 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()
+    }
+
+    /// Cap on concurrently executing parallel-safe tool calls in one batch.
+    /// Read from `maxParallelToolCalls` in settings; `None` means the CLI
+    /// falls back to `CLAWD_PARALLEL_TOOL_CALLS` and then its built-in default.
+    #[must_use]
+    pub fn max_parallel_tool_calls(&self) -> Option<usize> {
+        self.feature_config.max_parallel_tool_calls
+    }
+
+    /// Default cap on concurrently running sub-agents per team. Read from
+    /// `maxConcurrentAgents` in settings; `None` means the built-in default
+    /// applies. A per-team `maxConcurrentAgents` on TeamCreate overrides it.
+    #[must_use]
+    pub fn max_concurrent_agents(&self) -> Option<usize> {
+        self.feature_config.max_concurrent_agents
+    }
+
    #[must_use]
    pub fn aliases(&self) -> &BTreeMap<String, String> {
        &self.feature_config.aliases
@@ -974,6 +1020,20 @@ impl RuntimeFeatureConfig {
        &self.provider
    }

+    /// Cap on concurrently executing parallel-safe tool calls in one batch.
+    /// `None` means fall back to env/default.
+    #[must_use]
+    pub fn max_parallel_tool_calls(&self) -> Option<usize> {
+        self.max_parallel_tool_calls
+    }
+
+    /// Default per-team cap on concurrently running sub-agents; `None`
+    /// means unlimited (pre-fix behavior).
+    #[must_use]
+    pub fn max_concurrent_agents(&self) -> Option<usize> {
+        self.max_concurrent_agents
+    }
+
    #[must_use]
    pub fn with_hooks(mut self, hooks: RuntimeHookConfig) -> Self {
        self.hooks = hooks;
@@ -1756,6 +1816,51 @@ 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())
+}
+
+/// Reads the first present key from `keys` as a positive integer.
+/// Absent, null, or non-positive values parse to `None` so callers fall
+/// back to their own defaults rather than silently disabling a cap via a
+/// `0` typo. Accepts JSON numbers or numeric strings.
+fn parse_optional_positive_usize(
+    root: &JsonValue,
+    keys: &[&str],
+) -> Result<Option<usize>, ConfigError> {
+    let Some(object) = root.as_object() else {
+        return Ok(None);
+    };
+    for key in keys {
+        let Some(value) = object.get(*key) else {
+            continue;
+        };
+        if matches!(value, JsonValue::Null) {
+            continue;
+        }
+        let parsed = value
+            .as_i64()
+            .or_else(|| value.as_str().and_then(|s| s.trim().parse::<i64>().ok()))
+            .ok_or_else(|| ConfigError::Parse(format!("{key} must be a positive integer")))?;
+        if parsed <= 0 {
+            return Ok(None);
+        }
+        return Ok(usize::try_from(parsed).ok());
+    }
+    Ok(None)
+}
+
 fn parse_optional_aliases(root: &JsonValue) -> Result<BTreeMap<String, String>, ConfigError> {
    let Some(object) = root.as_object() else {
        return Ok(BTreeMap::new());
@@ -2627,6 +2732,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::{
@@ -3988,4 +4136,151 @@ mod tests {

        fs::remove_dir_all(root).expect("cleanup temp dir");
    }
+
+    #[test]
+    fn subagent_model_reads_camel_case_config_key() {
+        let root = temp_dir();
+        let cwd = root.join("project");
+        let home = root.join("home").join(".claw");
+        fs::create_dir_all(&home).expect("home config dir");
+        fs::create_dir_all(&cwd).expect("project dir");
+        fs::write(
+            home.join("settings.json"),
+            "{\n  \"subagentModel\": \"custom/openclaw\"\n}\n",
+        )
+        .expect("write settings");
+
+        let config = ConfigLoader::new(&cwd, &home)
+            .load()
+            .expect("config should load");
+        assert_eq!(
+            config.subagent_model(),
+            Some("custom/openclaw"),
+            "subagentModel camelCase key should be read end-to-end"
+        );
+
+        fs::remove_dir_all(root).expect("cleanup temp dir");
+    }
+
+    #[test]
+    fn subagent_model_reads_snake_case_config_key() {
+        let root = temp_dir();
+        let cwd = root.join("project");
+        let home = root.join("home").join(".claw");
+        fs::create_dir_all(&home).expect("home config dir");
+        fs::create_dir_all(&cwd).expect("project dir");
+        fs::write(
+            home.join("settings.json"),
+            "{\n  \"subagent_model\": \"qwen3.6-35b-fast\"\n}\n",
+        )
+        .expect("write settings");
+
+        let config = ConfigLoader::new(&cwd, &home)
+            .load()
+            .expect("config should load");
+        assert_eq!(
+            config.subagent_model(),
+            Some("qwen3.6-35b-fast"),
+            "subagent_model snake_case key should be read end-to-end"
+        );
+
+        fs::remove_dir_all(root).expect("cleanup temp dir");
+    }
+
+    #[test]
+    fn subagent_model_blank_value_returns_none() {
+        let root = temp_dir();
+        let cwd = root.join("project");
+        let home = root.join("home").join(".claw");
+        fs::create_dir_all(&home).expect("home config dir");
+        fs::create_dir_all(&cwd).expect("project dir");
+        fs::write(
+            home.join("settings.json"),
+            "{\n  \"subagentModel\": \"  \"\n}\n",
+        )
+        .expect("write settings");
+
+        let config = ConfigLoader::new(&cwd, &home)
+            .load()
+            .expect("config should load");
+        assert_eq!(
+            config.subagent_model(),
+            None,
+            "blank subagentModel should fall back to None"
+        );
+
+        fs::remove_dir_all(root).expect("cleanup temp dir");
+    }
+
+    #[test]
+    fn parallel_and_agent_caps_read_camel_and_snake_case_keys() {
+        let root = temp_dir();
+        let cwd = root.join("project");
+        let home = root.join("home").join(".claw");
+        fs::create_dir_all(&home).expect("home config dir");
+        fs::create_dir_all(&cwd).expect("project dir");
+        fs::write(
+            home.join("settings.json"),
+            "{\n  \"maxParallelToolCalls\": 4,\n  \"max_concurrent_agents\": \"6\"\n}\n",
+        )
+        .expect("write settings");
+
+        let config = ConfigLoader::new(&cwd, &home)
+            .load()
+            .expect("config should load");
+        assert_eq!(
+            config.max_parallel_tool_calls(),
+            Some(4),
+            "maxParallelToolCalls camelCase key should parse"
+        );
+        assert_eq!(
+            config.max_concurrent_agents(),
+            Some(6),
+            "max_concurrent_agents snake_case key should parse numeric strings"
+        );
+
+        fs::remove_dir_all(root).expect("cleanup temp dir");
+    }
+
+    #[test]
+    fn parallel_and_agent_caps_reject_nonpositive_and_malformed() {
+        let root = temp_dir();
+        let cwd = root.join("project");
+        let home = root.join("home").join(".claw");
+        fs::create_dir_all(&home).expect("home config dir");
+        fs::create_dir_all(&cwd).expect("project dir");
+        fs::write(
+            home.join("settings.json"),
+            "{\n  \"maxParallelToolCalls\": 0\n}\n",
+        )
+        .expect("write settings");
+
+        let config = ConfigLoader::new(&cwd, &home)
+            .load()
+            .expect("zero cap should parse as unset");
+        assert_eq!(config.max_parallel_tool_calls(), None);
+        assert_eq!(config.max_concurrent_agents(), None);
+        fs::remove_dir_all(&root).expect("cleanup temp dir");
+
+        let root = temp_dir();
+        let cwd = root.join("project");
+        let home = root.join("home").join(".claw");
+        fs::create_dir_all(&home).expect("home config dir");
+        fs::create_dir_all(&cwd).expect("project dir");
+        fs::write(
+            home.join("settings.json"),
+            "{\n  \"maxParallelToolCalls\": \"lots\"\n}\n",
+        )
+        .expect("write settings");
+
+        let error = ConfigLoader::new(&cwd, &home)
+            .load()
+            .expect_err("non-numeric cap should be a config error");
+        assert!(
+            error.to_string().contains("maxParallelToolCalls"),
+            "error should name the offending key: {error}"
+        );
+
+        fs::remove_dir_all(root).expect("cleanup temp dir");
+    }
 }
@@ -61,6 +61,40 @@ pub trait ApiClient {
 /// Trait implemented by tool dispatchers that execute model-requested tools.
 pub trait ToolExecutor {
    fn execute(&mut self, tool_name: &str, input: &str) -> Result<String, ToolError>;
+
+    /// Execute a batch of tool calls, potentially in parallel.
+    /// Returns results in the same order as the input calls.
+    /// The default implementation executes sequentially via `execute`.
+    /// Override this to provide parallel execution for read-only tools.
+    fn execute_batch(&mut self, calls: Vec<ToolCall>) -> Vec<ToolResult> {
+        calls
+            .into_iter()
+            .map(|call| {
+                let result = self.execute(&call.tool_name, &call.input);
+                ToolResult {
+                    tool_use_id: call.tool_use_id,
+                    tool_name: call.tool_name,
+                    result,
+                }
+            })
+            .collect()
+    }
+}
+
+/// A single tool call to execute.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ToolCall {
+    pub tool_use_id: String,
+    pub tool_name: String,
+    pub input: String,
+}
+
+/// The result of executing a tool call.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ToolResult {
+    pub tool_use_id: String,
+    pub tool_name: String,
+    pub result: Result<String, ToolError>,
 }

 /// Error returned when a tool invocation fails locally.
@@ -86,6 +120,22 @@ impl Display for ToolError {

 impl std::error::Error for ToolError {}

+/// Callback trait for reporting tool execution progress during a turn.
+/// Implementations can post progress to a team inbox, log to stderr, etc.
+/// Called after each tool call completes (success or failure).
+pub trait TurnProgressReporter: Send + Sync {
+    /// Called after a tool execution completes.
+    /// `iteration` is 1-based index of the tool call within this turn.
+    fn on_tool_result(
+        &self,
+        iteration: usize,
+        max_iterations: usize,
+        tool_name: &str,
+        input: &str,
+        result: Result<&str, &str>,
+    );
+}
+
 /// Error returned when a conversation turn cannot be completed.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct RuntimeError {
@@ -140,6 +190,7 @@ pub struct ConversationRuntime<C, T> {
    hook_abort_signal: HookAbortSignal,
    hook_progress_reporter: Option<Box<dyn HookProgressReporter>>,
    session_tracer: Option<SessionTracer>,
+    turn_progress_reporter: Option<Box<dyn TurnProgressReporter>>,
 }

 impl<C, T> ConversationRuntime<C, T>
@@ -194,6 +245,7 @@ where
            hook_abort_signal: HookAbortSignal::default(),
            hook_progress_reporter: None,
            session_tracer: None,
+            turn_progress_reporter: None,
        }
    }

@@ -237,6 +289,11 @@ where
        self
    }

+    pub fn with_turn_progress_reporter(mut self, reporter: Box<dyn TurnProgressReporter>) -> Self {
+        self.turn_progress_reporter = Some(reporter);
+        self
+    }
+
    fn run_pre_tool_use_hook(&mut self, tool_name: &str, input: &str) -> HookRunResult {
        if let Some(reporter) = self.hook_progress_reporter.as_mut() {
            self.hook_runner.run_pre_tool_use_with_context(
@@ -420,11 +477,24 @@ where
                break;
            }

-            for (tool_use_id, tool_name, input) in pending_tool_uses {
-                let pre_hook_result = self.run_pre_tool_use_hook(&tool_name, &input);
+            // Phase 1: Pre-hooks and permission checks (sequential).
+            // Hooks may mutate state and must run in order.
+            struct PendingTool {
+                tool_use_id: String,
+                tool_name: String,
+                effective_input: String,
+                pre_hook_messages: Vec<String>,
+                allowed: bool,
+                deny_reason: Option<String>,
+            }
+
+            let mut pending = Vec::with_capacity(pending_tool_uses.len());
+            for (tool_use_id, tool_name, input) in &pending_tool_uses {
+                let pre_hook_result = self.run_pre_tool_use_hook(tool_name, input);
                let effective_input = pre_hook_result
                    .updated_input()
                    .map_or_else(|| input.clone(), ToOwned::to_owned);
+                let pre_hook_messages = pre_hook_result.messages().to_vec();
                let permission_context = PermissionContext::new(
                    pre_hook_result.permission_override(),
                    pre_hook_result.permission_reason().map(ToOwned::to_owned),
@@ -453,71 +523,157 @@ where
                    }
                } else if let Some(prompt) = prompter.as_mut() {
                    self.permission_policy.authorize_with_context(
-                        &tool_name,
+                        tool_name,
                        &effective_input,
                        &permission_context,
                        Some(*prompt),
                    )
                } else {
                    self.permission_policy.authorize_with_context(
-                        &tool_name,
+                        tool_name,
                        &effective_input,
                        &permission_context,
                        None,
                    )
                };

-                let result_message = match permission_outcome {
+                match permission_outcome {
                    PermissionOutcome::Allow => {
-                        self.record_tool_started(iterations, &tool_name);
-                        let (mut output, mut is_error) =
-                            match self.tool_executor.execute(&tool_name, &effective_input) {
-                                Ok(output) => (output, false),
-                                Err(error) => (error.to_string(), true),
-                            };
-                        output = merge_hook_feedback(pre_hook_result.messages(), output, false);
-
-                        let post_hook_result = if is_error {
-                            self.run_post_tool_use_failure_hook(
-                                &tool_name,
-                                &effective_input,
-                                &output,
-                            )
-                        } else {
-                            self.run_post_tool_use_hook(
-                                &tool_name,
-                                &effective_input,
-                                &output,
-                                false,
-                            )
-                        };
-                        if post_hook_result.is_denied()
-                            || post_hook_result.is_failed()
-                            || post_hook_result.is_cancelled()
-                        {
-                            is_error = true;
-                        }
-                        output = merge_hook_feedback(
-                            post_hook_result.messages(),
-                            output,
-                            post_hook_result.is_denied()
-                                || post_hook_result.is_failed()
-                                || post_hook_result.is_cancelled(),
-                        );
-
-                        ConversationMessage::tool_result(tool_use_id, tool_name, output, is_error)
+                        pending.push(PendingTool {
+                            tool_use_id: tool_use_id.clone(),
+                            tool_name: tool_name.clone(),
+                            effective_input,
+                            pre_hook_messages,
+                            allowed: true,
+                            deny_reason: None,
+                        });
                    }
-                    PermissionOutcome::Deny { reason } => ConversationMessage::tool_result(
-                        tool_use_id,
-                        tool_name,
-                        merge_hook_feedback(pre_hook_result.messages(), reason, true),
+                    PermissionOutcome::Deny { reason } => {
+                        pending.push(PendingTool {
+                            tool_use_id: tool_use_id.clone(),
+                            tool_name: tool_name.clone(),
+                            effective_input: String::new(),
+                            pre_hook_messages,
+                            allowed: false,
+                            deny_reason: Some(reason),
+                        });
+                    }
+                }
+            }
+
+            // Phase 2: Execute allowed tools (batch, may run in parallel).
+            let allowed_calls: Vec<ToolCall> = pending
+                .iter()
+                .filter(|p| p.allowed)
+                .map(|p| {
+                    self.record_tool_started(iterations, &p.tool_name);
+                    ToolCall {
+                        tool_use_id: p.tool_use_id.clone(),
+                        tool_name: p.tool_name.clone(),
+                        input: p.effective_input.clone(),
+                    }
+                })
+                .collect();
+            let batch_results = self.tool_executor.execute_batch(allowed_calls);
+            let mut batch_index = 0;
+
+            // Phase 3: Post-hooks and session updates (sequential, original order).
+            for p in &pending {
+                // Capture progress data for the reporter.
+                let (
+                    progress_tool_name,
+                    progress_input,
+                    progress_output,
+                    progress_is_error,
+                    result_message,
+                ) = if p.allowed {
+                    let batch_result = &batch_results[batch_index];
+                    batch_index += 1;
+                    let (mut output, mut is_error) = match &batch_result.result {
+                        Ok(output) => (output.clone(), false),
+                        Err(error) => (error.to_string(), true),
+                    };
+                    output = merge_hook_feedback(&p.pre_hook_messages, output, false);
+
+                    let post_hook_result = if is_error {
+                        self.run_post_tool_use_failure_hook(
+                            &p.tool_name,
+                            &p.effective_input,
+                            &output,
+                        )
+                    } else {
+                        self.run_post_tool_use_hook(
+                            &p.tool_name,
+                            &p.effective_input,
+                            &output,
+                            false,
+                        )
+                    };
+                    if post_hook_result.is_denied()
+                        || post_hook_result.is_failed()
+                        || post_hook_result.is_cancelled()
+                    {
+                        is_error = true;
+                    }
+                    output = merge_hook_feedback(
+                        post_hook_result.messages(),
+                        output,
+                        post_hook_result.is_denied()
+                            || post_hook_result.is_failed()
+                            || post_hook_result.is_cancelled(),
+                    );
+                    let progress_output = output.clone();
+                    let result_message = ConversationMessage::tool_result(
+                        p.tool_use_id.clone(),
+                        p.tool_name.clone(),
+                        output,
+                        is_error,
+                    );
+                    (
+                        p.tool_name.clone(),
+                        p.effective_input.clone(),
+                        progress_output,
+                        is_error,
+                        result_message,
+                    )
+                } else {
+                    let denied_output = merge_hook_feedback(
+                        &p.pre_hook_messages,
+                        p.deny_reason.clone().unwrap_or_default(),
                        true,
-                    ),
+                    );
+                    let result_message = ConversationMessage::tool_result(
+                        p.tool_use_id.clone(),
+                        p.tool_name.clone(),
+                        denied_output,
+                        true,
+                    );
+                    (
+                        p.tool_name.clone(),
+                        String::new(),
+                        String::new(),
+                        true,
+                        result_message,
+                    )
                };
                self.session
                    .push_message(result_message.clone())
                    .map_err(|error| RuntimeError::new(error.to_string()))?;
                self.record_tool_finished(iterations, &result_message);
+                if let Some(ref reporter) = self.turn_progress_reporter {
+                    let report_result = if progress_is_error {
+                        Err(progress_output.as_str())
+                    } else {
+                        Ok(progress_output.as_str())
+                    };
+                    reporter.on_tool_result(
+                        iterations,
+                        self.max_iterations,
+                        &progress_tool_name,
+                        &progress_input,
+                        report_result,
+                    );
+                }
                tool_results.push(result_message);
            }
        }
@@ -66,15 +66,16 @@ pub use compact::{
    get_compact_continuation_message, should_compact, CompactionConfig, CompactionResult,
 };
 pub use config::{
-    clear_user_provider_settings, default_config_home, save_user_provider_settings,
-    suppress_config_warnings_for_json_mode, ApiTimeoutConfig, ConfigEntry, ConfigError,
-    ConfigFileReport, ConfigFileStatus, ConfigInspection, ConfigLoader, ConfigSource,
-    McpConfigCollection, McpInvalidServerConfig, McpManagedProxyServerConfig, McpOAuthConfig,
-    McpRemoteServerConfig, McpSdkServerConfig, McpServerConfig, McpStdioServerConfig, McpTransport,
-    McpWebSocketServerConfig, OAuthConfig, ProviderFallbackConfig, ResolvedPermissionMode,
-    RulesImportConfig, RuntimeConfig, RuntimeFeatureConfig, RuntimeHookCommand, RuntimeHookConfig,
-    RuntimeInvalidHookConfig, RuntimePermissionRuleConfig, RuntimePluginConfig,
-    RuntimeProviderConfig, ScopedMcpServerConfig, CLAW_SETTINGS_SCHEMA_NAME,
+    clear_user_provider_settings, default_config_home, inject_config_as_env_fallbacks,
+    save_user_provider_settings, suppress_config_warnings_for_json_mode, ApiTimeoutConfig,
+    ConfigEntry, ConfigError, ConfigFileReport, ConfigFileStatus, ConfigInspection, ConfigLoader,
+    ConfigSource, McpConfigCollection, McpInvalidServerConfig, McpManagedProxyServerConfig,
+    McpOAuthConfig, McpRemoteServerConfig, McpSdkServerConfig, McpServerConfig,
+    McpStdioServerConfig, McpTransport, McpWebSocketServerConfig, OAuthConfig,
+    ProviderFallbackConfig, ResolvedPermissionMode, RulesImportConfig, RuntimeConfig,
+    RuntimeFeatureConfig, RuntimeHookCommand, RuntimeHookConfig, RuntimeInvalidHookConfig,
+    RuntimePermissionRuleConfig, RuntimePluginConfig, RuntimeProviderConfig, ScopedMcpServerConfig,
+    CLAW_SETTINGS_SCHEMA_NAME,
 };
 pub use config_validate::{
    check_unsupported_format, format_diagnostics, validate_config_file, ConfigDiagnostic,
@@ -82,8 +83,8 @@ pub use config_validate::{
 };
 pub use conversation::{
    auto_compaction_threshold_from_env, ApiClient, ApiRequest, AssistantEvent, AutoCompactionEvent,
-    ConversationRuntime, PromptCacheEvent, RuntimeError, StaticToolExecutor, ToolError,
-    ToolExecutor, TurnSummary,
+    ConversationRuntime, PromptCacheEvent, RuntimeError, StaticToolExecutor, ToolCall, ToolError,
+    ToolExecutor, ToolResult, TurnProgressReporter, TurnSummary,
 };
 pub use file_ops::{
    edit_file, edit_file_in_workspace, glob_search, glob_search_in_workspace, grep_search,
@@ -29,7 +29,7 @@ impl Default for TridentConfig {
 }

 /// Statistics from a Trident compaction run.
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, Default)]
 pub struct TridentStats {
    pub superseded_count: usize,
    pub collapsed_chains: usize,
@@ -41,21 +41,6 @@ pub struct TridentStats {
    pub final_message_count: usize,
 }

-impl Default for TridentStats {
-    fn default() -> Self {
-        Self {
-            superseded_count: 0,
-            collapsed_chains: 0,
-            messages_collapsed: 0,
-            clusters_found: 0,
-            messages_clustered: 0,
-            tokens_saved_estimate: 0,
-            original_message_count: 0,
-            final_message_count: 0,
-        }
-    }
-}
-
 impl TridentStats {
    pub fn format_report(&self) -> String {
        let compression = if self.final_message_count > 0 {
@@ -192,7 +177,7 @@ fn stage1_supersede(messages: &[ConversationMessage]) -> (Vec<ConversationMessag

    let mut obsolete_indices: BTreeSet<usize> = BTreeSet::new();

-    for (_path, ops) in &file_ops {
+    for ops in file_ops.values() {
        if ops.len() < 2 {
            continue;
        }
@@ -205,9 +190,9 @@ fn stage1_supersede(messages: &[ConversationMessage]) -> (Vec<ConversationMessag

        if let Some(last_write) = last_write_idx {
            for op in ops {
-                if op.op_type == FileOp::Read && op.index < last_write {
-                    obsolete_indices.insert(op.index);
-                } else if (op.op_type == FileOp::Write || op.op_type == FileOp::Edit)
+                if (op.op_type == FileOp::Read
+                    || op.op_type == FileOp::Write
+                    || op.op_type == FileOp::Edit)
                    && op.index < last_write
                {
                    obsolete_indices.insert(op.index);
@@ -325,7 +310,7 @@ fn stage2_collapse(
                    usage: None,
                });
            } else {
-                result.extend(buffer.drain(..));
+                result.append(&mut buffer);
            }
            buffer.clear();
            result.push(msg.clone());
@@ -476,7 +461,7 @@ fn stage3_cluster(
    }

    let total_clustered: usize = cluster_assignments.len();
-    let clusters_found = cluster_id as usize;
+    let clusters_found = cluster_id;

    let mut result: Vec<ConversationMessage> = Vec::new();
    let mut cluster_buffers: BTreeMap<usize, Vec<usize>> = BTreeMap::new();
@@ -677,7 +662,7 @@ fn truncate_text(text: &str, max_chars: usize) -> String {
 mod tests {
    use super::*;
    use crate::compact::CompactionConfig;
-    use crate::session::{ContentBlock, ConversationMessage, MessageRole, Session};
+    use crate::session::{ContentBlock, ConversationMessage, Session};

    #[test]
    fn stage1_removes_obsolete_file_reads() {
@@ -736,7 +721,7 @@ mod tests {
    fn stage2_collapses_chatty_messages() {
        let mut messages = vec![];
        for i in 0..6 {
-            messages.push(ConversationMessage::user_text(&format!("ok {i}")));
+            messages.push(ConversationMessage::user_text(format!("ok {i}")));
            messages.push(ConversationMessage::assistant(vec![ContentBlock::Text {
                text: format!("got {i}"),
            }]));
@@ -767,9 +752,9 @@ mod tests {
                },
            ]));
            messages.push(ConversationMessage::tool_result(
-                &format!("read_{i}"),
+                format!("read_{i}"),
                "read_file",
-                &format!(r#"{{"path":"src/{i}.rs","content":"data {i}"}}"#),
+                format!(r#"{{"path":"src/{i}.rs","content":"data {i}"}}"#),
                false,
            ));
        }
@@ -14,6 +14,7 @@ api = { path = "../api" }
 commands = { path = "../commands" }
 crossterm = "0.28"
 pulldown-cmark = "0.13"
+once_cell = "1"
 rustyline = "15"
 runtime = { path = "../runtime" }
 plugins = { path = "../plugins" }
@@ -25,8 +26,15 @@ tools = { path = "../tools" }
 log = "0.4"


-[lints]
-workspace = true
+[lints.rust]
+unsafe_code = "allow"
+
+[lints.clippy]
+all = { level = "warn", priority = -1 }
+pedantic = { level = "allow", priority = -1 }
+module_name_repetitions = "allow"
+missing_panics_doc = "allow"
+missing_errors_doc = "allow"

 [dev-dependencies]
 mock-anthropic-service = { path = "../mock-anthropic-service" }
@@ -18,6 +18,8 @@ pub enum ReadOutcome {
    Submit(String),
    Cancel,
    Exit,
+    ProviderSwap,
+    TeamToggle,
 }

 struct SlashCommandHelper {
@@ -86,12 +88,19 @@ impl Hinter for SlashCommandHelper {
 impl Highlighter for SlashCommandHelper {
    fn highlight<'l>(&self, line: &'l str, _pos: usize) -> Cow<'l, str> {
        self.set_current_line(line);
-        Cow::Borrowed(line)
+        // When sentinel is present, show visible prompt instead of invisible char
+        if line.contains('\x01') {
+            let display = line.replace('\x01', "\x1b[36m[Provider Swap]\x1b[0m ");
+            Cow::Owned(display)
+        } else {
+            Cow::Borrowed(line)
+        }
    }

    fn highlight_char(&self, line: &str, _pos: usize, _kind: CmdKind) -> bool {
        self.set_current_line(line);
-        false
+        // Re-highlight when sentinel is present to show the prompt
+        line.contains('\x01')
    }
 }

@@ -115,6 +124,18 @@ impl LineEditor {
        editor.set_helper(Some(SlashCommandHelper::new(completions)));
        editor.bind_sequence(KeyEvent(KeyCode::Char('J'), Modifiers::CTRL), Cmd::Newline);
        editor.bind_sequence(KeyEvent(KeyCode::Enter, Modifiers::SHIFT), Cmd::Newline);
+        // Ctrl+P inserts a sentinel character that triggers provider swap.
+        // The sentinel is invisible but the highlighter shows "[Provider Swap]" prompt.
+        // User must press Enter to confirm (rustyline cannot chain commands).
+        editor.bind_sequence(
+            KeyEvent(KeyCode::Char('P'), Modifiers::CTRL),
+            Cmd::SelfInsert(1, '\x01'),
+        );
+        // Ctrl+T inserts a sentinel character that toggles agent teams mode.
+        editor.bind_sequence(
+            KeyEvent(KeyCode::Char('T'), Modifiers::CTRL),
+            Cmd::SelfInsert(1, '\x02'),
+        );

        Self {
            prompt: prompt.into(),
@@ -147,7 +168,18 @@ impl LineEditor {
        }

        match self.editor.readline(&self.prompt) {
-            Ok(line) => Ok(ReadOutcome::Submit(line)),
+            Ok(line) => {
+                // Ctrl+P inserts \x01 sentinel — triggers provider swap wizard.
+                // The sentinel is stripped and we return ProviderSwap to the REPL loop.
+                if line.contains('\x01') {
+                    return Ok(ReadOutcome::ProviderSwap);
+                }
+                // Ctrl+T inserts \x02 sentinel — toggles team mode.
+                if line.contains('\x02') {
+                    return Ok(ReadOutcome::TeamToggle);
+                }
+                Ok(ReadOutcome::Submit(line))
+            }
            Err(ReadlineError::Interrupted) => {
                let has_input = !self.current_line().is_empty();
                self.finish_interrupted_read()?;
@@ -7,7 +7,9 @@ use std::process::{Command, Output, Stdio};
 use std::sync::atomic::{AtomicU64, Ordering};
 use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};

-use mock_anthropic_service::{MockAnthropicService, SCENARIO_PREFIX};
+use mock_anthropic_service::{
+    MockAnthropicService, CONTEXT_WINDOW_RETRY_TEXT, SCENARIO_PREFIX, STREAM_THEN_ERROR_TEXT,
+};
 use serde_json::Value;

 static TEMP_COUNTER: AtomicU64 = AtomicU64::new(0);
@@ -189,6 +191,199 @@ fn text_prompt_mode_streams_assistant_text_once_before_spinner_completion() {
    fs::remove_dir_all(&workspace).expect("workspace cleanup should succeed");
 }

+#[test]
+fn text_prompt_mode_emits_the_response_body_exactly_once() {
+    // given a workspace pointed at the mock Anthropic service running the
+    // streaming_text scenario, which emits a single assistant text block
+    let runtime = tokio::runtime::Runtime::new().expect("tokio runtime should build");
+    let server = runtime
+        .block_on(MockAnthropicService::spawn())
+        .expect("mock service should start");
+    let base_url = server.base_url();
+
+    let workspace = unique_temp_dir("text-prompt-once");
+    let config_home = workspace.join("config-home");
+    let home = workspace.join("home");
+    fs::create_dir_all(&workspace).expect("workspace should exist");
+    fs::create_dir_all(&config_home).expect("config home should exist");
+    fs::create_dir_all(&home).expect("home should exist");
+
+    // when we invoke claw in normal text prompt mode
+    let prompt = format!("{SCENARIO_PREFIX}streaming_text");
+    let output = run_claw(
+        &workspace,
+        &config_home,
+        &home,
+        &base_url,
+        &[
+            "--model",
+            "sonnet",
+            "--permission-mode",
+            "read-only",
+            &prompt,
+        ],
+    );
+
+    // then the response body reaches stdout exactly once: the emitter owns the
+    // terminal while the turn runs, so the caller must not print the assistant
+    // text a second time
+    assert!(
+        output.status.success(),
+        "text prompt run should succeed\nstdout:\n{}\n\nstderr:\n{}",
+        String::from_utf8_lossy(&output.stdout),
+        String::from_utf8_lossy(&output.stderr),
+    );
+    let stdout = String::from_utf8(output.stdout).expect("stdout should be utf8");
+    let plain_stdout = strip_ansi_codes(&stdout);
+    assert_eq!(
+        plain_stdout
+            .matches("Mock streaming says hello from the parity harness.")
+            .count(),
+        1,
+        "text prompt stdout should carry the response body exactly once ({stdout:?})"
+    );
+
+    fs::remove_dir_all(&workspace).expect("workspace cleanup should succeed");
+}
+
+#[test]
+fn text_prompt_mode_emits_retried_body_once_after_auto_compact() {
+    // given a mock service whose first answer to this scenario is a context
+    // window rejection and whose answer to the retry is a streamed response
+    let runtime = tokio::runtime::Runtime::new().expect("tokio runtime should build");
+    let server = runtime
+        .block_on(MockAnthropicService::spawn())
+        .expect("mock service should start");
+    let base_url = server.base_url();
+
+    let workspace = unique_temp_dir("text-prompt-auto-compact-retry");
+    let config_home = workspace.join("config-home");
+    let home = workspace.join("home");
+    fs::create_dir_all(&workspace).expect("workspace should exist");
+    fs::create_dir_all(&config_home).expect("config home should exist");
+    fs::create_dir_all(&home).expect("home should exist");
+
+    // when claw is rejected for context window overflow and recovers by
+    // compacting the session and retrying the same prompt
+    let prompt = format!("{SCENARIO_PREFIX}context_window_retry");
+    let output = run_claw(
+        &workspace,
+        &config_home,
+        &home,
+        &base_url,
+        &[
+            "--model",
+            "sonnet",
+            "--permission-mode",
+            "read-only",
+            &prompt,
+        ],
+    );
+
+    // then the retry succeeds and its response body is on stdout exactly once.
+    // The recovery path builds a fresh runtime with its own terminal tail, so
+    // this is where a tail that only tracked the first attempt would leave the
+    // streamed line unterminated and let `spinner.finish` clear it.
+    assert!(
+        output.status.success(),
+        "auto-compact retry should succeed\nstdout:\n{}\n\nstderr:\n{}",
+        String::from_utf8_lossy(&output.stdout),
+        String::from_utf8_lossy(&output.stderr),
+    );
+    let stdout = String::from_utf8(output.stdout).expect("stdout should be utf8");
+    let plain_stdout = strip_ansi_codes(&stdout);
+    assert_eq!(
+        plain_stdout.matches(CONTEXT_WINDOW_RETRY_TEXT).count(),
+        1,
+        "auto-compact retry stdout should carry the response body exactly once ({stdout:?})"
+    );
+    assert!(
+        plain_stdout
+            .lines()
+            .any(|line| line == CONTEXT_WINDOW_RETRY_TEXT),
+        "the retried response body should land on its own line ({stdout:?})"
+    );
+    assert!(
+        plain_stdout.contains("✨ Done (after auto-compact)"),
+        "the retry should report the auto-compact completion ({stdout:?})"
+    );
+
+    // and the scenario really was requested twice, so the retry path ran
+    let captured = runtime.block_on(server.captured_requests());
+    let messages: Vec<_> = captured
+        .iter()
+        .filter(|request| request.path == "/v1/messages")
+        .collect();
+    assert!(
+        messages.len() >= 2,
+        "the scenario should be requested twice so the retry is exercised ({captured:?})"
+    );
+
+    fs::remove_dir_all(&workspace).expect("workspace cleanup should succeed");
+}
+
+#[test]
+fn text_prompt_mode_keeps_streamed_text_when_the_turn_fails() {
+    // given a mock service that streams part of an answer and then fails the
+    // response, so the turn ends with text already rendered on the terminal
+    let runtime = tokio::runtime::Runtime::new().expect("tokio runtime should build");
+    let server = runtime
+        .block_on(MockAnthropicService::spawn())
+        .expect("mock service should start");
+    let base_url = server.base_url();
+
+    let workspace = unique_temp_dir("text-prompt-stream-then-error");
+    let config_home = workspace.join("config-home");
+    let home = workspace.join("home");
+    fs::create_dir_all(&workspace).expect("workspace should exist");
+    fs::create_dir_all(&config_home).expect("config home should exist");
+    fs::create_dir_all(&home).expect("home should exist");
+
+    // when the turn fails after the emitter already streamed a partial line
+    let prompt = format!("{SCENARIO_PREFIX}stream_then_error");
+    let output = run_claw(
+        &workspace,
+        &config_home,
+        &home,
+        &base_url,
+        &[
+            "--model",
+            "sonnet",
+            "--permission-mode",
+            "read-only",
+            &prompt,
+        ],
+    );
+
+    // then the failed turn is reported...
+    assert!(
+        !output.status.success(),
+        "a mid-stream failure should fail the run\nstdout:\n{}\n\nstderr:\n{}",
+        String::from_utf8_lossy(&output.stdout),
+        String::from_utf8_lossy(&output.stderr),
+    );
+    let stdout = String::from_utf8(output.stdout).expect("stdout should be utf8");
+    let plain_stdout = strip_ansi_codes(&stdout);
+
+    // ...and the text the emitter already streamed survives the failure banner.
+    // `spinner.fail` moves to column 0 and clears the current line, so a caller
+    // that does not know a partial line is pending erases that text instead of
+    // printing the banner underneath it. This is the failure arm of the same
+    // ownership rule the success arm follows.
+    assert!(
+        plain_stdout
+            .lines()
+            .any(|line| line == STREAM_THEN_ERROR_TEXT),
+        "the streamed text should keep its own line despite the failure ({stdout:?})"
+    );
+    assert!(
+        plain_stdout.contains("Request failed"),
+        "the failure banner should still be reported ({stdout:?})"
+    );
+
+    fs::remove_dir_all(&workspace).expect("workspace cleanup should succeed");
+}
+
 #[test]
 fn compact_flag_with_json_output_emits_structured_json() {
    let runtime = tokio::runtime::Runtime::new().expect("tokio runtime should build");
@@ -0,0 +1,118 @@
+# Multi-Tool Execution & Sub-Agent Delegation
+
+Two complementary features that dramatically reduce latency and token usage when the model needs to perform multiple operations or gather context.
+
+## Feature 1: Parallel Tool Execution
+
+When the model returns multiple tool_use blocks in a single response, read-only tools now execute concurrently instead of sequentially.
+
+### How it works
+
+The `run_turn` loop is refactored into 3 phases:
+
+1. **Pre-hooks + permission checks** (sequential — hooks may mutate state)
+2. **Tool execution** (batch — parallel for read-only tools via `std::thread::scope`)
+3. **Post-hooks + session updates** (sequential — preserves original ordering)
+
+### Parallel-safe tools
+
+These tools are safe to run concurrently because they only read state and dispatch through the stateless tool registry:
+
+- `read_file`, `glob_search`, `grep_search`
+- `WebFetch`, `WebSearch`
+- `ToolSearch`, `Skill`
+- `LSP`
+- `GitStatus`, `GitDiff`, `GitLog`, `GitShow`, `GitBlame`
+
+### Sequential-only tools
+
+Tools that require `&mut self` or have side effects continue to run one at a time:
+
+- `bash`, `write_file`, `edit_file` (side effects)
+- `MCP`, `McpAuth`, `RemoteTrigger` (network state)
+- `Agent`, `TaskCreate`, `WorkerCreate` (stateful)
+- `NotebookEdit`, `REPL`, `PowerShell` (side effects)
+
+### Safety guarantees
+
+- Pre/post hooks always run sequentially
+- Permission checks complete before any tool executes
+- Tool results are pushed to the session in the original model order
+- Falls back to sequential for single-tool batches
+- Thread scopes ensure all parallel work completes before `execute_batch` returns
+
+### Impact
+
+For a response with 5 `read_file` calls: **~5x faster** execution. The main model still sees all results in order.
+
+---
+
+## Feature 2: SubAgent Delegation
+
+A `SubAgent` tool that lets the main model delegate multi-step tasks to a fast sub-agent. The sub-agent runs autonomously with its own `ConversationRuntime`, making multiple tool calls without round-tripping through the main model.
+
+### Tool parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `prompt` | string | yes | Task description for the sub-agent |
+| `task_type` | string | no | `Explore` (default), `Plan`, or `Verify` |
+| `model` | string | no | Override the sub-agent model |
+
+### Task types
+
+| Type | Available tools | Use for |
+|------|----------------|---------|
+| `Explore` | read_file, glob_search, grep_search, WebFetch, WebSearch, ToolSearch, StructuredOutput | Searching code, reading files, gathering context |
+| `Plan` | Explore + TodoWrite | Planning approaches with structured todo output |
+| `Verify` | Plan + bash | Running tests, checking builds, verifying changes |
+
+### Configuration
+
+Set the sub-agent model in `~/.claw/settings.json`:
+
+```json
+{
+  "model": "openai/glm-5.1-fast",
+  "subagentModel": "openai/qwen3.6-35b-fast"
+}
+```
+
+If `subagentModel` is not set, the sub-agent uses the same model as the main session (or the `model` override parameter on the tool call).
+
+### Example
+
+Main model prompt: "Find all Rust files that import `ConversationRuntime` and list their paths"
+
+Without SubAgent: 5–10 sequential tool calls (grep → read each file → summarize)
+With SubAgent: 1 SubAgent call → sub-agent does all the work autonomously → returns summary
+
+**Result**: ~10x fewer tokens consumed by the main model, faster overall completion.
+
+### Architecture
+
+The sub-agent reuses the same building blocks as the existing `Agent` tool:
+
+- `ProviderRuntimeClient` — API client with fallback chain
+- `SubagentToolExecutor` — filtered tool access with permission enforcement
+- `ConversationRuntime` — full conversation loop with hooks and compaction
+- `agent_permission_policy()` — auto-approve read-only, deny write tools
+
+Key differences from the `Agent` tool:
+- **Synchronous** — blocks until complete, returns result directly
+- **Lighter** — fewer default tools, focused on the task type
+- **Configurable model** — uses `subagentModel` or the tool's `model` param
+- **Structured output** — returns `result`, `tool_calls`, and `iterations`
+
+---
+
+## Changed files
+
+| File | Changes |
+|------|---------|
+| `rust/crates/runtime/src/conversation.rs` | `ToolCall`, `ToolResult` types; `execute_batch` on `ToolExecutor`; 3-phase `run_turn` |
+| `rust/crates/runtime/src/lib.rs` | Exports for `ToolCall`, `ToolResult` |
+| `rust/crates/runtime/src/config.rs` | `subagent_model` field, `parse_optional_subagent_model()`, accessor |
+| `rust/crates/runtime/src/config_validate.rs` | `subagentModel` field spec |
+| `rust/crates/rusty-claude-cli/src/main.rs` | `CliToolExecutor::execute_batch` with parallel-safe classification |
+| `rust/crates/tools/src/lib.rs` | `SubAgent` tool spec, `SubAgentInput`, `run_sub_agent()`, `load_subagent_model_from_config()`, `build_sub_agent_system_prompt()` |
@@ -116,6 +116,8 @@ mod tests {
            lane_events: vec![],
            derived_state: "working".to_string(),
            current_blocker: None,
+            team_id: None,
+            task_id: None,
            error: None,
        }
    }
Author	SHA1	Message	Date
clawdbot	590f5a2e09	fix(clippy): resolve new lint violations in trident, compact, and claw-rag-service - runtime/trident.rs: derive Default, fix for_kv_map, if_same_then_else, extend_with_drain, unnecessary_cast, needless_borrows - runtime/compact.rs: fix useless_borrows_in_formatting - claw-rag-service/ingest.rs: remove unnecessary into_iter() - claw-rag-service/db.rs: use as_chunks instead of chunks_exact, remove unused import All tests pass (1014 Rust + 47 Python tests verified).	2026-10-12 23:01:12 +00:00
TheArchitectit	0403fe8867	fix(cli): order parallel tool results by call index and cap fan-out execute_batch already keyed results to original call slots; this makes that airtight: panicking worker threads resolve to their own index via a fallback tuple instead of colliding with slot 0, and results are asserted to follow call order with a regression test that mixes a workspace-escape read among valid reads at cap=2. Adds the fan-out bound: parallel-safe calls run in waves of at most maxParallelToolCalls (default 8, CLAWD_PARALLEL_TOOL_CALLS env, or the new setting applied via with_max_parallel_tool_calls at runtime build). Sequential behavior is preserved: allowed_tools checks still run before dispatch, and ToolSearch stays off the parallel path.	2026-10-12 23:01:12 +00:00
TheArchitectit	407f0be972	feat(teams): bound per-team sub-agent concurrency with AgentGate TeamCreate resolves maxConcurrentAgents from the per-team input, then the maxConcurrentAgents setting, then unlimited (pre-fix behavior). The cap is persisted in the manifest and registered on a process-wide gate; agent threads still spawn immediately but block on an RAII slot before entering their run loop, so manifest/task-claim semantics are unchanged. TeamDelete forgets the gate so queued agents drain and no stale team entries accumulate. Includes a gate regression test.	2026-10-12 23:01:12 +00:00
TheArchitectit	98c45990db	feat(config): parse maxParallelToolCalls and maxConcurrentAgents settings Adds optional positive-integer parsing for the two new fan-out caps next to subagentModel, in both camelCase and snake_case forms. Zero parses as unset; non-numeric values are a named config error. Covered by three regression tests mirroring the subagentModel test style.	2026-10-12 23:01:12 +00:00
TheArchitectitandClaw	beb5595551	fix: restore workspace unsafe_code=forbid, fix TaskClaim TOCTOU, remove TUI deps Review fixes for PR #3250: 1. Restore workspace-level unsafe_code = "forbid" (was downgraded to "warn" for TUI support). The per-crate [lints.rust] unsafe_code = "allow" on rusty-claude-cli already overrides it where needed. 2. Fix TaskClaim TOCTOU race in claim_task(). Replace exists()-then-write with OpenOptions::create_new(true) which atomically fails if the lock file already exists, eliminating the race window between the check and the write. 3. Remove TUI scaffolding deps (ratatui, tui-textarea, gag, crossbeam-channel, libc, unicode-width) and the /tui slash command spec — these belong in a future TUI PR and are unused in the current source. Also updates the provider chain precedence test to reflect the new behavior where the caller's resolved model is the chain primary. Co-Authored-By: Claw <noreply@openclaw.ai>	2026-10-12 23:01:12 +00:00
TheArchitectit	05fb4d5f2f	test: add subagentModel accessor chain tests Adds 3 unit tests covering the original silent-drop bug: - camelCase 'subagentModel' key reads end-to-end - snake_case 'subagent_model' key reads end-to-end - blank value returns None (falls back to default model) Requested by @1716775457damn in PR review.	2026-10-12 23:01:12 +00:00
TheArchitectit	c6820b8f2f	fix: model_token_limit catch-all returns None for unknown models Restores the fix from @Offwhite-Del that was lost during rebase. Unknown models now return None so preflight skips the context-window check and lets the API enforce its own limits.	2026-10-12 23:01:12 +00:00
TheArchitectit	1e96b1643a	cargo fmt	2026-10-12 23:00:54 +00:00
TheArchitectitandClaude Fable 5	53b3e63d99	feat(team): team enhancements, subagentModel, parallel tool exec Port the agent-team enhancement layer onto upstream/main so the model can spin up coordinated sub-agent teams for parallel work. subagentModel config wiring (fix): - Add subagent_model field to RuntimeFeatureConfig + RuntimeConfig::subagent_model() accessor so the subagentModel setting (already validated by config_validate.rs) is now actually read and stored. - Agent tool's resolve_agent_model falls back to subagentModel from config when no explicit model is passed. Provider namespace separation: - New 'custom-openai' provider kind with dedicated env vars (CLAWCUSTOMOPENAI_API_KEY / CLAWCUSTOMOPENAI_BASE_URL) - /setup wizard saves kind: 'custom-openai' for option 5 - Bare model name normalized to 'custom/' prefix to avoid proxy 404s - Sub-agents inherit /setup-saved provider config via inject_config_as_env_fallbacks Parallel tool execution: - Override execute_batch to classify read-only tools as parallel-safe and run them concurrently via std::thread::scope - Results return in original model order Team coordination layer: - AgentMessage, TaskClaim, TeamStatus tools + shared mailbox directory - Mode presets (tiny/1x ... mega/6x) + enriched TeamCreate/Agent descriptions - Background team watcher - /team slash command: on/off/status/toggle Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-10-12 23:00:40 +00:00
bellmanandOmX	0cf2c751a6	Document provider compatibility diagnostics and passthrough Explain the provider compatibility behavior that now has executable coverage so future changes preserve routing, custom gateway slugs, diagnostics, and extra-body passthrough semantics. Constraint: Task 2 requires docs/status evidence while leader owns Ultragoal checkpoints and .omx/ultragoal remains untouched. Rejected: Add a new CLI status command \| broader than the assigned provider compatibility documentation/status surface. Confidence: high Scope-risk: narrow Directive: Keep docs aligned with provider_diagnostics_for_model, MessageRequest::extra_body, and OpenAI-compatible slash-model tests. Tested: cargo test --manifest-path rust/Cargo.toml -p api custom_openai_gateway_preserves_slash_model_ids_and_extra_body_params; cargo test --manifest-path rust/Cargo.toml -p api provider_diagnostics_explain_openai_compatible_capabilities; cargo check --manifest-path rust/Cargo.toml -p api Not-tested: Live provider calls requiring external credentials. Co-authored-by: OmX <omx@local>	2026-10-12 22:59:26 +00:00
bellmanandOmX	22b30c4557	Keep G007 mock parity references executable The follow-up docs gate needed the parity manifest reference string that the mock parity diff checker requires, so this records the verified map-only repair after leader integration. Constraint: Task 11 scope allowed only PARITY.md, rust/MOCK_PARITY_HARNESS.md, and docs/g007-plugin-mcp-verification-map.md; only PARITY.md needed a change. Rejected: Editing harness code or .omx/ultragoal \| checks proved the remaining gap was docs-map text only and Ultragoal state is leader-owned. Confidence: high Scope-risk: narrow Directive: Keep auto_compact_triggered parity_refs synchronized with PARITY.md when mock parity scenarios change. Tested: cd rust && python3 scripts/run_mock_parity_diff.py; python3 scripts/validate_cc2_board.py --board .omx/cc2/board.json; rg -n auto_compact_triggered token_cost_reporting auto_compaction threshold from env G007 Plugin/MCP G007-plugin-mcp 12 scripted scenarios 21 captured PARITY.md rust/MOCK_PARITY_HARNESS.md docs/g007-plugin-mcp-verification-map.md; git diff --check Not-tested: Full workspace suite; Task 11 was a docs/parity-map follow-up with focused executable map validation. Co-authored-by: OmX <omx@oh-my-codex.dev>	2026-10-12 22:59:26 +00:00
bellmanandOmX	5f08341d1a	Document G007 mock parity verification boundaries Record the W4 verification map and parity-doc alignment so plugin/MCP lifecycle mock coverage can be audited without scraping stale harness prose. Constraint: Task 9 owns mock integration and regression verification/docs mapping, not parser fixes or leader-owned Ultragoal state. Rejected: Editing .omx/ultragoal or duplicating Worker-4 plugin command fallthrough fixes \| leader checkpointing and parser implementation are separate lanes. Confidence: high Scope-risk: narrow Directive: Keep rust/mock_parity_scenarios.json, rust/MOCK_PARITY_HARNESS.md, PARITY.md, and mock_parity_harness.rs aligned when adding scenarios. Tested: cd rust && python3 scripts/run_mock_parity_diff.py --no-run; cd rust && ./scripts/run_mock_parity_harness.sh; cd rust && python3 scripts/run_mock_parity_diff.py; cargo test --manifest-path rust/Cargo.toml -p rusty-claude-cli build_runtime_plugin_state -- --nocapture; cargo test --manifest-path rust/Cargo.toml -p rusty-claude-cli build_runtime_runs_plugin_lifecycle_init_and_shutdown -- --nocapture; cargo test --manifest-path rust/Cargo.toml -p plugins plugin_registry_runs_initialize_and_shutdown_for_enabled_plugins -- --nocapture; cargo fmt --manifest-path rust/Cargo.toml --all -- --check; cargo check --manifest-path rust/Cargo.toml -p rusty-claude-cli -p mock-anthropic-service; git diff --check Not-tested: Full workspace test suite; W4 scope is docs/mock verification map and focused plugin/MCP lifecycle regression evidence. Co-authored-by: OmX <omx@oh-my-codex.dev>	2026-10-12 22:59:26 +00:00
Bellman	95f797f5e2	Merge pull request #3316 from ultraworkers/fix/release-sha256-macos fix(ci): use cross-platform sha256 for macOS and Linux release artifacts	2026-10-13 07:32:17 +09:00
clawdbot	ff515c9aeb	fix(ci): use cross-platform sha256 for macOS and Linux release artifacts	2026-10-12 22:29:43 +00:00
Bellmanandclawdbot	0f1a69659c	chore: remove accidentally committed .gjc session state and ignore .gjc/ (#3315 ) Co-authored-by: clawdbot <clawdbot@ultraworkers.dev>	2026-10-13 07:22:41 +09:00
Bellman 黄云龙 gaebal-gajae	990cc33c19	test(runtime): expand json module unit tests [formatting fix] (#3308 ) * test(runtime): expand json module unit tests The hand-rolled JsonValue parser/renderer in runtime had only two tests covering a self-contained JSON parser, renderer, accessor set, and error type. Add focused unit tests covering primitive rendering, sorted object keys, escape handling (quotes, backslashes, control chars), signed-integer and whitespace-tolerant parsing, nested structures, render->parse round-tripping, malformed-input rejection, i64 overflow rejection, accessor variant mismatches, and JsonError Display. * style: format json.rs tests to match rustfmt standards --------- Co-authored-by: 黄云龙 <76432572+nankingjing@users.noreply.github.com> Co-authored-by: gaebal-gajae <clawdbot@users.noreply.github.com>	2026-10-13 07:22:31 +09:00
黄云龙	8d2c7b78b2	refactor(cli): let the emitter report the output tail it leaves behind (#3304 ) refactor(cli): let the emitter report the output tail it leaves behind Two places believed they owned terminal output: consume_stream streams assistant deltas live while emit_output = true, and run_turn decided whether to emit a separating newline before spinner.finish by guessing from final_assistant_text(&summary). That guess agrees with reality only because every other writer happens to terminate its output with a newline — tool results go through stream_markdown (which appends one), thinking summaries are written with a trailing newline, and tool-call headers use writeln! — so the assistant text path is the only one that can leave a partial line. That is a property of the current renderers rather than of the streaming protocol, and it is not enforced anywhere. TerminalTail is state the emitter records into as it writes: both live writers (AnthropicRuntimeClient::consume_stream and the tool-result blocks in CliToolExecutor::execute) now push bytes through a TailTrackingWriter that reports the last byte written, and the caller that ends a turn asks where the emitter stopped instead of inferring it. The heuristic also left the failure arm unguarded. A turn that streamed text and then errored called spinner.fail on a partial line, which the line clear then erased; that arm now carries the same guard. Also gate the animated spinner.tick frame on is_terminal(). That frame is pure cursor control (save, rewrite line, restore) and emits no newline, so down a pipe it leaves an unterminated banner that the first streamed delta then continues on the same physical line. — [repo owner's gaebal-gajae (clawdbot) 🦞]	2026-10-13 07:18:12 +09:00
				`@@ -0,0 +1 @@`
				{"schema_version":1,"session_id":"24aa7e35-e6af-4d2d-ab41-a38b9115a031","state":"running","ready_for_input":false,"updated_at":"2026-10-12T22:10:00.508Z","current_turn_id":null,"last_turn_id":null,"live":true,"reason":null,"source":"agent_session_event","event":"turn_start","cwd":"/home/bellman/Data/Workspace/gc-task-cc-pr-3250-lane","workdir":"/home/bellman/Data/Workspace/gc-task-cc-pr-3250-lane","branch":null,"session_file":"/home/bellman/.gajaeway/broker/agent/sessions/v2-famocqbiduwkxmc2g2nvg6jfq2ay6qtc5aihbhbdoqopsmduj4sa/2026-10-12T22-02-16-124Z_24aa7e35-e6af-4d2d-ab41-a38b9115a031.jsonl","activity":{"seq":149,"last_activity_at":"2026-10-12T22:10:01.196Z","tool":"bash","phase":"started","outcome":null,"elapsed_ms":null,"active_tool_count":1,"active_tools":[{"tool":"bash","started_at":"2026-10-12T22:10:01.196Z"}],"in_flight":[{"digest":"fa5f186357264e6b1be2a7a4a7162d0fff04f721630413a25d05b40bcd933836","tool":"bash","started_at":"2026-10-12T22:10:01.196Z"}]}}
				`@@ -0,0 +1 @@`
				`{"pid":1,"start_time":"unknown","token":"8389ee99-c41c-47dd-9615-e76a5268967c","owner_host_id":"7af2fb0e8e37bd543e3d0bda6f205b56f30077b5a9b77e83208e94ae441315ac","released":true}`
				`@@ -1 +0,0 @@`
				{"schema_version":1,"session_id":"5e2dd1e8-ea4b-4af1-b56b-89ab7cca4299","state":"running","ready_for_input":false,"updated_at":"2026-10-12T22:09:30.659Z","current_turn_id":null,"last_turn_id":null,"live":true,"reason":null,"source":"agent_session_event","event":"turn_start","cwd":"/home/bellman/Data/Workspace/gc-task-cc-issue-3257-lane","workdir":"/home/bellman/Data/Workspace/gc-task-cc-issue-3257-lane","branch":null,"session_file":"/home/bellman/.gajaeway/broker/agent/sessions/v2-6fji37qf7ld523ivvoiohlcpmz3nu45m2apxyrkusn5nxczjmouq/2026-10-12T22-04-33-362Z_5e2dd1e8-ea4b-4af1-b56b-89ab7cca4299.jsonl","activity":{"seq":115,"last_activity_at":"2026-10-12T22:09:34.144Z","tool":"bash","phase":"started","outcome":null,"elapsed_ms":null,"active_tool_count":1,"active_tools":[{"tool":"bash","started_at":"2026-10-12T22:09:34.144Z"}],"in_flight":[{"digest":"e603a70efb03b6b2b78c94b704197d26fc8a35113543291a21f68b3b08ca11a9","tool":"bash","started_at":"2026-10-12T22:09:34.144Z"}]}}
				`@@ -0,0 +1 @@`
				`{"effectMarker":"7b92c148-d616-4eb5-95e8-4e95084bebe9","incarnation":"linux:159085489","pid":177576}`
				`@@ -1 +0,0 @@`
				`{"effectMarker":"f441857a-f591-474b-b34a-6d89b2bf9feb","incarnation":"linux:159099652","pid":487360}`