fix: resolve merge conflicts and test compatibility

- Resolve .gitignore conflict: include both nix entries and .claude/
- Update AnthropicRuntimeClient::new() test calls to match new signature
- Fix explicit_model_provider_hint test to unset OPENAI_BASE_URL env var

.gitignore

@@ -15,6 +15,7 @@ status-help.txt
 .port_sessions/
 # Local agent session state
 .gjc/
+.claude/
 # Nix build outputs and direnv
 .envrc.local
 result

.gjc/_session-24aa7e35-e6af-4d2d-ab41-a38b9115a031/runtime/runtime-state.json

@@ -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"}]}}

.gjc/_session-24aa7e35-e6af-4d2d-ab41-a38b9115a031/runtime/runtime-state.json.lock

@@ -0,0 +1 @@
+{"pid":1,"start_time":"unknown","token":"8389ee99-c41c-47dd-9615-e76a5268967c","owner_host_id":"7af2fb0e8e37bd543e3d0bda6f205b56f30077b5a9b77e83208e94ae441315ac","released":true}

.gjc/_session-24aa7e35-e6af-4d2d-ab41-a38b9115a031/runtime/runtime-state.json.lock.transition.owner

@@ -0,0 +1 @@
+{"pid":1,"start_time":"unknown","token":"6e35ded8-fda1-421e-a727-42906ef57646","owner_host_id":"7af2fb0e8e37bd543e3d0bda6f205b56f30077b5a9b77e83208e94ae441315ac","released":true}

.gjc/state/sdk/24aa7e35-e6af-4d2d-ab41-a38b9115a031.json

@@ -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
+}

.gjc/state/sdk/24aa7e35-e6af-4d2d-ab41-a38b9115a031.lifecycle.json

@@ -0,0 +1 @@
+{"effectMarker":"7b92c148-d616-4eb5-95e8-4e95084bebe9","incarnation":"linux:159085489","pid":177576}

.gjc/state/sdk/24aa7e35-e6af-4d2d-ab41-a38b9115a031.lifecycle.ready.json

@@ -0,0 +1 @@
+{"effectMarker":"7b92c148-d616-4eb5-95e8-4e95084bebe9","incarnation":"linux:159085489","pid":177576}

CHANGELOG.md

@@ -5,6 +5,44 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.4] - 2026-10-13
+
+### Added
+
+- GJC-compatible line range selectors for read_file tool (`:50-200`, `:50+150` syntax)
+- GJC-compatible `:conflicts` selector for git merge conflict detection
+- SDK wire transport with WebSocket support
+- Nix flake development environment
+- `/status`, `/cost`, and `/version` slash commands
+- Persistent provider configuration loading
+- Pagination support for large read_file results
+- Comprehensive GJC compatibility documentation and analysis
+
+### Fixed
+
+- Windows path containment checks for security boundary enforcement
+- Git bash detection on Windows with proper probe caching
+- Unresolvable path denial to prevent escape attempts
+- Auto-compaction context window measurement
+- Tool result preservation on failed turns
+- Model stall recovery without tool calls
+- Streaming markdown formatting with preserved block separators
+- Local model validation bypass generalization beyond Ollama
+- Release artifact checksums on macOS and Linux
+- Duplicate assistant text rendering
+- Workspace slash command wire-up
+
+### Changed
+
+- Enhanced path scope validation for multiple Windows path spellings
+- Improved error handling and configuration defaults
+- Upgraded GitHub Actions to immutable commit SHAs for CI security
+
+### Known Limitations
+
+- ACP / Zed integration is not yet implemented (status stub available via `claw acp`)
+- Python porting workspace is for reference only, not used in production
+
 ## [0.1.3] - 2026-10-13
 
 This is the first public binary release of Claw Code.

docs/gjc-compat/tool-semantics-phase1.md

@@ -222,7 +222,7 @@ pub fn read_file_in_workspace(
 **Missing**:
 - ✗ Line range selectors (`:L-L+N` syntax)
 - ✗ Raw mode (`:raw`)
-- ✗ Git merge conflict extraction (`:conflicts`)
+- ✓ Git merge conflict extraction (`:conflicts`)
 - ✗ Truncation footers with recovery hints
 - ✗ Structural summarization (collapse braces)
 - ✗ Archive/SQLite support
@@ -272,7 +272,8 @@ pub fn read_file_in_workspace(
 
 ### Batch 1: READ Tool (Priority P0)
 - Add line range selector parsing
-- Implement `:raw` and `:conflicts` modes
+- Implement `:raw` mode
+- ✓ Implement `:conflicts` mode
 - Add truncation footers with recovery hints
 - Implement structural summarization
 - Add tests for all selector combinations

rust/AGENTS.md

@@ -41,7 +41,7 @@ TUI rule: formatting fns take `&mut impl Write`, never stdout directly. Never mi
 
 Library crates don't carry the `claw-` prefix. Binary crates do (except legacy `rusty-claude-cli`).
 
-Workspace version is `0.1.3`, `publish = false`, MIT license.
+Workspace version is `0.1.4`, `publish = false`, MIT license.
 
 No rust-toolchain file, no MSRV. CI pins `dtolnay/rust-toolchain@stable`.
 

rust/Cargo.toml

@@ -3,7 +3,7 @@ members = ["crates/*"]
 resolver = "2"
 
 [workspace.package]
-version = "0.1.3"
+version = "0.1.4"
 edition = "2021"
 license = "MIT"
 publish = false

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

@@ -30,8 +30,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

@@ -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,
     }
 }

rust/crates/api/tests/client_integration.rs

@@ -82,7 +82,7 @@ async fn send_message_posts_json_and_parses_response() {
     );
     assert_eq!(
         request.headers.get("user-agent").map(String::as_str),
-        Some("claude-code/0.1.3")
+        Some("claude-code/0.1.4")
     );
     assert_eq!(
         request.headers.get("anthropic-beta").map(String::as_str),

rust/crates/claw-rag-service/src/db.rs

@@ -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)
 }

rust/crates/claw-rag-service/src/ingest.rs

@@ -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)?;

rust/crates/commands/src/lib.rs

@@ -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 {
@@ -1191,10 +1191,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)]
@@ -1516,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()),
     }))
 }
@@ -5297,60 +5304,6 @@ fn mcp_server_json(name: &str, server: &ScopedMcpServerConfig) -> Value {
     })
 }
 
-fn render_session_status(session: &Session) -> String {
-    let message_count = session.messages.len();
-    let mut total_input = 0u32;
-    let mut total_output = 0u32;
-    for msg in &session.messages {
-        if let Some(usage) = msg.usage {
-            total_input = total_input.saturating_add(usage.input_tokens);
-            total_output = total_output.saturating_add(usage.output_tokens);
-        }
-    }
-    format!(
-        "Session {}: {} messages, {} input tokens, {} output tokens",
-        &session.session_id[0..8],
-        message_count,
-        total_input,
-        total_output
-    )
-}
-
-fn render_token_cost(session: &Session) -> String {
-    let mut total_input = 0u32;
-    let mut total_output = 0u32;
-    let mut cache_creation = 0u32;
-    let mut cache_read = 0u32;
-    for msg in &session.messages {
-        if let Some(usage) = msg.usage {
-            total_input = total_input.saturating_add(usage.input_tokens);
-            total_output = total_output.saturating_add(usage.output_tokens);
-            cache_creation = cache_creation.saturating_add(usage.cache_creation_input_tokens);
-            cache_read = cache_read.saturating_add(usage.cache_read_input_tokens);
-        }
-    }
-    format!(
-        "Cumulative token usage for this session:
-  Input tokens: {}
-  Output tokens: {}
-  Cache creation tokens: {}
-  Cache read tokens: {}
-  Total input: {}",
-        total_input,
-        total_output,
-        cache_creation,
-        cache_read,
-        total_input
-            .saturating_add(cache_creation)
-            .saturating_add(cache_read)
-    )
-}
-
-fn render_version_info() -> String {
-    let version = env!("CARGO_PKG_VERSION");
-    format!("claw-code version {}", version)
-}
-
 #[must_use]
 pub fn handle_slash_command(
     input: &str,
@@ -5388,19 +5341,8 @@ pub fn handle_slash_command(
             message: render_slash_command_help(),
             session: session.clone(),
         }),
-        SlashCommand::Status => Some(SlashCommandResult {
-            message: render_session_status(session),
-            session: session.clone(),
-        }),
-        SlashCommand::Cost => Some(SlashCommandResult {
-            message: render_token_cost(session),
-            session: session.clone(),
-        }),
-        SlashCommand::Version => Some(SlashCommandResult {
-            message: render_version_info(),
-            session: session.clone(),
-        }),
-        SlashCommand::Bughunter { .. }
+        SlashCommand::Status
+        | SlashCommand::Bughunter { .. }
         | SlashCommand::Commit
         | SlashCommand::Pr { .. }
         | SlashCommand::Issue { .. }
@@ -5411,6 +5353,7 @@ pub fn handle_slash_command(
         | SlashCommand::Model { .. }
         | SlashCommand::Permissions { .. }
         | SlashCommand::Clear { .. }
+        | SlashCommand::Cost
         | SlashCommand::Resume { .. }
         | SlashCommand::Config { .. }
         | SlashCommand::Workspace { .. }
@@ -5418,6 +5361,7 @@ pub fn handle_slash_command(
         | SlashCommand::Memory
         | SlashCommand::Init
         | SlashCommand::Diff
+        | SlashCommand::Version
         | SlashCommand::Export { .. }
         | SlashCommand::Session { .. }
         | SlashCommand::Plugins { .. }
@@ -5464,6 +5408,7 @@ pub fn handle_slash_command(
         | SlashCommand::OutputStyle { .. }
         | SlashCommand::AddDir { .. }
         | SlashCommand::History { .. }
+        | SlashCommand::Lsp { .. }
         | SlashCommand::Team { .. }
         | SlashCommand::Setup
         | SlashCommand::Unknown(_) => None,
@@ -5596,6 +5541,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))
@@ -6256,6 +6211,7 @@ mod tests {
     fn ignores_unknown_or_runtime_bound_slash_commands() {
         let session = Session::new();
         assert!(handle_slash_command("/unknown", &session, CompactionConfig::default()).is_none());
+        assert!(handle_slash_command("/status", &session, CompactionConfig::default()).is_none());
         assert!(handle_slash_command("/sandbox", &session, CompactionConfig::default()).is_none());
         assert!(
             handle_slash_command("/bughunter", &session, CompactionConfig::default()).is_none()
@@ -6287,6 +6243,7 @@ mod tests {
             handle_slash_command("/clear --confirm", &session, CompactionConfig::default())
                 .is_none()
         );
+        assert!(handle_slash_command("/cost", &session, CompactionConfig::default()).is_none());
         assert!(handle_slash_command(
             "/resume session.json",
             &session,
@@ -6305,6 +6262,7 @@ mod tests {
         );
         assert!(handle_slash_command("/mcp list", &session, CompactionConfig::default()).is_none());
         assert!(handle_slash_command("/diff", &session, CompactionConfig::default()).is_none());
+        assert!(handle_slash_command("/version", &session, CompactionConfig::default()).is_none());
         assert!(
             handle_slash_command("/export note.txt", &session, CompactionConfig::default())
                 .is_none()
@@ -7266,79 +7224,4 @@ mod tests {
         let _ = fs::remove_dir_all(config_home);
         let _ = fs::remove_dir_all(bundled_root);
     }
-
-    #[test]
-    fn status_command_shows_session_info() {
-        use runtime::TokenUsage;
-
-        let mut session = Session::new();
-        session.messages.push(ConversationMessage {
-            role: MessageRole::User,
-            blocks: vec![ContentBlock::Text {
-                text: "hello".to_string(),
-            }],
-            usage: Some(TokenUsage {
-                input_tokens: 10,
-                output_tokens: 20,
-                cache_creation_input_tokens: 0,
-                cache_read_input_tokens: 0,
-            }),
-        });
-        session.messages.push(ConversationMessage {
-            role: MessageRole::Assistant,
-            blocks: vec![ContentBlock::Text {
-                text: "response".to_string(),
-            }],
-            usage: Some(TokenUsage {
-                input_tokens: 5,
-                output_tokens: 15,
-                cache_creation_input_tokens: 0,
-                cache_read_input_tokens: 0,
-            }),
-        });
-
-        let result = handle_slash_command("/status", &session, CompactionConfig::default())
-            .expect("/status should be handled");
-        assert!(result.message.contains("2 messages"));
-        assert!(result.message.contains("15 input tokens"));
-        assert!(result.message.contains("35 output tokens"));
-        assert_eq!(result.session, session);
-    }
-
-    #[test]
-    fn cost_command_shows_token_usage() {
-        use runtime::TokenUsage;
-
-        let mut session = Session::new();
-        session.messages.push(ConversationMessage {
-            role: MessageRole::User,
-            blocks: vec![ContentBlock::Text {
-                text: "hello".to_string(),
-            }],
-            usage: Some(TokenUsage {
-                input_tokens: 100,
-                output_tokens: 200,
-                cache_creation_input_tokens: 50,
-                cache_read_input_tokens: 25,
-            }),
-        });
-
-        let result = handle_slash_command("/cost", &session, CompactionConfig::default())
-            .expect("/cost should be handled");
-        assert!(result.message.contains("100"));
-        assert!(result.message.contains("200"));
-        assert!(result.message.contains("50"));
-        assert!(result.message.contains("25"));
-        assert!(result.message.contains("Cumulative token usage"));
-        assert_eq!(result.session, session);
-    }
-
-    #[test]
-    fn version_command_shows_version() {
-        let session = Session::new();
-        let result = handle_slash_command("/version", &session, CompactionConfig::default())
-            .expect("/version should be handled");
-        assert!(result.message.contains("claw-code version"));
-        assert_eq!(result.session, session);
-    }
 }

rust/crates/runtime/src/compact.rs

@@ -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
                 );
             }
         }

rust/crates/runtime/src/config.rs

@@ -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.
@@ -837,6 +851,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 {
@@ -919,6 +942,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
@@ -979,6 +1025,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;
@@ -1761,6 +1821,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());
@@ -2632,6 +2737,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::{
@@ -4029,4 +4177,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");
+    }
 }

rust/crates/runtime/src/conversation.rs

@@ -1,9 +1,5 @@
 use std::collections::BTreeMap;
 use std::fmt::{Display, Formatter};
-use std::sync::{
-    atomic::{AtomicBool, Ordering},
-    Arc,
-};
 
 use serde_json::{Map, Value};
 use telemetry::SessionTracer;
@@ -57,41 +53,6 @@ pub struct PromptCacheEvent {
     pub token_drop: u32,
 }
 
-/// Shared flag used to request graceful interruption of a running turn.
-///
-/// Cloning shares the underlying flag, mirroring
-/// [`HookAbortSignal`](crate::hooks::HookAbortSignal). An input listener
-/// (e.g. Esc or Ctrl+C handling in the CLI) sets the flag while the
-/// conversation loop and the streaming API client poll it at safe points.
-/// When the flag is observed, the turn winds down without treating the
-/// stop as a failure: pending tool calls receive synthesized error
-/// results so the session stays consistent, and [`TurnSummary`] reports
-/// `interrupted: true`.
-#[derive(Debug, Clone, Default)]
-pub struct TurnInterruptSignal {
-    interrupted: Arc<AtomicBool>,
-}
-
-impl TurnInterruptSignal {
-    #[must_use]
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    pub fn interrupt(&self) {
-        self.interrupted.store(true, Ordering::SeqCst);
-    }
-
-    #[must_use]
-    pub fn is_interrupted(&self) -> bool {
-        self.interrupted.load(Ordering::SeqCst)
-    }
-
-    pub fn reset(&self) {
-        self.interrupted.store(false, Ordering::SeqCst);
-    }
-}
-
 /// Minimal streaming API contract required by [`ConversationRuntime`].
 pub trait ApiClient {
     fn stream(&mut self, request: ApiRequest) -> Result<Vec<AssistantEvent>, RuntimeError>;
@@ -100,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.
@@ -125,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 {
@@ -157,7 +168,6 @@ pub struct TurnSummary {
     pub iterations: usize,
     pub usage: TokenUsage,
     pub auto_compaction: Option<AutoCompactionEvent>,
-    pub interrupted: bool,
 }
 
 /// Details about automatic session compaction applied during a turn.
@@ -178,9 +188,9 @@ pub struct ConversationRuntime<C, T> {
     hook_runner: HookRunner,
     auto_compaction_input_tokens_threshold: u32,
     hook_abort_signal: HookAbortSignal,
-    turn_interrupt_signal: TurnInterruptSignal,
     hook_progress_reporter: Option<Box<dyn HookProgressReporter>>,
     session_tracer: Option<SessionTracer>,
+    turn_progress_reporter: Option<Box<dyn TurnProgressReporter>>,
 }
 
 impl<C, T> ConversationRuntime<C, T>
@@ -233,9 +243,9 @@ where
             hook_runner,
             auto_compaction_input_tokens_threshold: auto_compaction_threshold_from_env(),
             hook_abort_signal: HookAbortSignal::default(),
-            turn_interrupt_signal: TurnInterruptSignal::default(),
             hook_progress_reporter: None,
             session_tracer: None,
+            turn_progress_reporter: None,
         }
     }
 
@@ -264,15 +274,6 @@ where
         self
     }
 
-    #[must_use]
-    pub fn with_turn_interrupt_signal(
-        mut self,
-        turn_interrupt_signal: TurnInterruptSignal,
-    ) -> Self {
-        self.turn_interrupt_signal = turn_interrupt_signal;
-        self
-    }
-
     #[must_use]
     pub fn with_hook_progress_reporter(
         mut self,
@@ -288,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(
@@ -406,14 +412,8 @@ where
         let mut prompt_cache_events = Vec::new();
         let mut iterations = 0;
         let mut auto_compaction = None;
-        let mut interrupted = false;
 
         loop {
-            if self.turn_interrupt_signal.is_interrupted() {
-                self.record_turn_interrupted(iterations, "before_request");
-                interrupted = true;
-                break;
-            }
             iterations += 1;
             if iterations > self.max_iterations {
                 let error = RuntimeError::new(
@@ -430,14 +430,6 @@ where
             let events = match self.api_client.stream(request) {
                 Ok(events) => events,
                 Err(error) => {
-                    if self.turn_interrupt_signal.is_interrupted() {
-                        // The client aborted because the user interrupted the
-                        // turn; any partial response is discarded and the stop
-                        // is reported as an interruption rather than a failure.
-                        self.record_turn_interrupted(iterations, "during_request");
-                        interrupted = true;
-                        break;
-                    }
                     self.record_turn_failed(iterations, &error);
                     return Err(error);
                 }
@@ -485,30 +477,24 @@ where
                 break;
             }
 
-            for (tool_use_id, tool_name, input) in pending_tool_uses {
-                if interrupted || self.turn_interrupt_signal.is_interrupted() {
-                    // Every pending tool_use must still receive a tool_result
-                    // so the session stays valid for the next request.
-                    if !interrupted {
-                        self.record_turn_interrupted(iterations, "before_tool");
-                        interrupted = true;
-                    }
-                    let result_message = ConversationMessage::tool_result(
-                        tool_use_id,
-                        tool_name,
-                        "Interrupted by user before this tool could run.",
-                        true,
-                    );
-                    self.session
-                        .push_message(result_message.clone())
-                        .map_err(|error| RuntimeError::new(error.to_string()))?;
-                    tool_results.push(result_message);
-                    continue;
-                }
-                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),
@@ -537,77 +523,159 @@ 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);
             }
-
-            if interrupted {
-                break;
-            }
         }
 
         let summary = TurnSummary {
@@ -617,11 +685,8 @@ where
             iterations,
             usage: self.usage_tracker.cumulative_usage(),
             auto_compaction,
-            interrupted,
         };
-        if !interrupted {
-            self.record_turn_completed(&summary);
-        }
+        self.record_turn_completed(&summary);
 
         Ok(summary)
     }
@@ -785,17 +850,6 @@ where
         session_tracer.record("turn_completed", attributes);
     }
 
-    fn record_turn_interrupted(&self, iteration: usize, phase: &str) {
-        let Some(session_tracer) = &self.session_tracer else {
-            return;
-        };
-
-        let mut attributes = Map::new();
-        attributes.insert("iteration".to_string(), Value::from(iteration as u64));
-        attributes.insert("phase".to_string(), Value::String(phase.to_string()));
-        session_tracer.record("turn_interrupted", attributes);
-    }
-
     fn record_turn_failed(&self, iteration: usize, error: &RuntimeError) {
         let Some(session_tracer) = &self.session_tracer else {
             return;
@@ -957,8 +1011,7 @@ mod tests {
     use super::{
         build_assistant_message, parse_auto_compaction_threshold, ApiClient, ApiRequest,
         AssistantEvent, AutoCompactionEvent, ConversationRuntime, PromptCacheEvent, RuntimeError,
-        StaticToolExecutor, ToolExecutor, TurnInterruptSignal,
-        DEFAULT_AUTO_COMPACTION_INPUT_TOKENS_THRESHOLD,
+        StaticToolExecutor, ToolExecutor, DEFAULT_AUTO_COMPACTION_INPUT_TOKENS_THRESHOLD,
     };
     use crate::compact::CompactionConfig;
     use crate::config::{RuntimeFeatureConfig, RuntimeHookConfig};
@@ -2059,165 +2112,4 @@ mod tests {
         // then
         assert_eq!(error.to_string(), "upstream failed");
     }
-
-    #[test]
-    fn interrupt_before_first_request_skips_the_api_call() {
-        struct UnreachableApi;
-
-        impl ApiClient for UnreachableApi {
-            fn stream(
-                &mut self,
-                _request: ApiRequest,
-            ) -> Result<Vec<AssistantEvent>, RuntimeError> {
-                unreachable!("interrupted turn must not reach the API")
-            }
-        }
-
-        // given
-        let interrupt = TurnInterruptSignal::new();
-        interrupt.interrupt();
-        let mut runtime = ConversationRuntime::new(
-            Session::new(),
-            UnreachableApi,
-            StaticToolExecutor::new(),
-            PermissionPolicy::new(PermissionMode::DangerFullAccess),
-            vec!["system".to_string()],
-        )
-        .with_turn_interrupt_signal(interrupt);
-
-        // when
-        let summary = runtime
-            .run_turn("hello", None)
-            .expect("interruption should not be reported as a failure");
-
-        // then
-        assert!(summary.interrupted);
-        assert_eq!(summary.iterations, 0);
-        assert!(summary.assistant_messages.is_empty());
-        assert!(summary.tool_results.is_empty());
-        assert_eq!(summary.auto_compaction, None);
-        assert_eq!(runtime.session().messages.len(), 1);
-        assert_eq!(runtime.session().messages[0].role, MessageRole::User);
-    }
-
-    #[test]
-    fn interrupt_after_stream_synthesizes_results_for_pending_tools() {
-        struct ToolUseApi {
-            interrupt: TurnInterruptSignal,
-        }
-
-        impl ApiClient for ToolUseApi {
-            fn stream(
-                &mut self,
-                _request: ApiRequest,
-            ) -> Result<Vec<AssistantEvent>, RuntimeError> {
-                // Simulate the user pressing Esc while the response streams in.
-                self.interrupt.interrupt();
-                Ok(vec![
-                    AssistantEvent::TextDelta("Running the tool.".to_string()),
-                    AssistantEvent::ToolUse {
-                        id: "tool-1".to_string(),
-                        name: "add".to_string(),
-                        input: "2,2".to_string(),
-                    },
-                    AssistantEvent::MessageStop,
-                ])
-            }
-        }
-
-        // given
-        let interrupt = TurnInterruptSignal::new();
-        let mut runtime = ConversationRuntime::new(
-            Session::new(),
-            ToolUseApi {
-                interrupt: interrupt.clone(),
-            },
-            StaticToolExecutor::new()
-                .register("add", |_input| panic!("interrupted tool must not run")),
-            PermissionPolicy::new(PermissionMode::DangerFullAccess),
-            vec!["system".to_string()],
-        )
-        .with_turn_interrupt_signal(interrupt);
-
-        // when
-        let summary = runtime
-            .run_turn("what is 2 + 2?", None)
-            .expect("interruption should not be reported as a failure");
-
-        // then
-        assert!(summary.interrupted);
-        assert_eq!(summary.iterations, 1);
-        assert_eq!(summary.assistant_messages.len(), 1);
-        assert_eq!(summary.tool_results.len(), 1);
-        assert!(matches!(
-            &summary.tool_results[0].blocks[0],
-            ContentBlock::ToolResult {
-                tool_use_id,
-                is_error: true,
-                output,
-                ..
-            } if tool_use_id == "tool-1" && output.contains("Interrupted by user")
-        ));
-        // user text, assistant tool_use, synthesized tool_result
-        assert_eq!(runtime.session().messages.len(), 3);
-        assert!(matches!(
-            runtime.session().messages[2].blocks[0],
-            ContentBlock::ToolResult { is_error: true, .. }
-        ));
-    }
-
-    #[test]
-    fn stream_error_during_interrupt_is_reported_as_interruption() {
-        struct AbortedApi {
-            interrupt: TurnInterruptSignal,
-        }
-
-        impl ApiClient for AbortedApi {
-            fn stream(
-                &mut self,
-                _request: ApiRequest,
-            ) -> Result<Vec<AssistantEvent>, RuntimeError> {
-                // Simulate the streaming client aborting the connection after
-                // observing the interrupt flag mid-stream.
-                self.interrupt.interrupt();
-                Err(RuntimeError::new("request aborted"))
-            }
-        }
-
-        // given
-        let sink = Arc::new(MemoryTelemetrySink::default());
-        let tracer = SessionTracer::new("session-interrupt", sink.clone());
-        let interrupt = TurnInterruptSignal::new();
-        let mut runtime = ConversationRuntime::new(
-            Session::new(),
-            AbortedApi {
-                interrupt: interrupt.clone(),
-            },
-            StaticToolExecutor::new(),
-            PermissionPolicy::new(PermissionMode::DangerFullAccess),
-            vec!["system".to_string()],
-        )
-        .with_turn_interrupt_signal(interrupt)
-        .with_session_tracer(tracer);
-
-        // when
-        let summary = runtime
-            .run_turn("hello", None)
-            .expect("interrupt-driven aborts should not surface as errors");
-
-        // then
-        assert!(summary.interrupted);
-        assert!(summary.assistant_messages.is_empty());
-        let trace_names = sink
-            .events()
-            .iter()
-            .filter_map(|event| match event {
-                TelemetryEvent::SessionTrace(trace) => Some(trace.name.clone()),
-                _ => None,
-            })
-            .collect::<Vec<_>>();
-        assert!(trace_names.iter().any(|name| name == "turn_interrupted"));
-        assert!(!trace_names.iter().any(|name| name == "turn_failed"));
-        assert!(!trace_names.iter().any(|name| name == "turn_completed"));
-    }
 }

rust/crates/runtime/src/file_ops.rs

@@ -247,6 +247,34 @@ pub fn read_file_with_selector(
     let lines: Vec<&str> = content.lines().collect();
     let total_lines = lines.len();
 
+    // Special handling for conflicts selector
+    if selector == Some("conflicts") {
+        let conflicts = extract_merge_conflicts(&lines);
+        let (selected, num_lines) = if conflicts.is_empty() {
+            (format!("No unresolved git merge conflicts in {}.", path), 1)
+        } else {
+            let display_path = absolute_path
+                .file_name()
+                .and_then(|n| n.to_str())
+                .unwrap_or(path);
+            let summary = format_conflict_summary(&conflicts, display_path);
+            let summary_lines = summary.lines().count();
+            (summary, summary_lines)
+        };
+
+        return Ok(ReadFileOutput {
+            kind: String::from("text"),
+            file: TextFilePayload {
+                file_path: absolute_path.to_string_lossy().into_owned(),
+                content: selected,
+                num_lines,
+                start_line: 1,
+                total_lines,
+            },
+            truncation_footer: None,
+        });
+    }
+
     // Determine which lines to select
     let (start_index, end_index, truncation_footer) = if let Some(sel) = selector {
         // Parse and apply selector
@@ -281,6 +309,195 @@ pub fn read_file_with_selector(
     })
 }
 
+/// Represents a merge conflict block in a file.
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct ConflictBlock {
+    start_line: usize,        // 1-based line number where <<<<<<< starts
+    separator_line: usize,    // 1-based line number where ======= is
+    end_line: usize,          // 1-based line number where >>>>>>> is
+    base_line: Option<usize>, // 1-based line number where ||||||| is (for 3-way)
+    ours_label: Option<String>,
+    base_label: Option<String>,
+    theirs_label: Option<String>,
+}
+
+/// Scans lines for unresolved git merge conflict blocks.
+fn extract_merge_conflicts(lines: &[&str]) -> Vec<ConflictBlock> {
+    let mut blocks = Vec::new();
+    let mut i = 0;
+
+    const OURS_PREFIX: &str = "<<<<<<<";
+    const BASE_PREFIX: &str = "|||||||";
+    const SEPARATOR: &str = "=======";
+    const THEIRS_PREFIX: &str = ">>>>>>>";
+
+    while i < lines.len() {
+        let line = lines[i];
+
+        // Check for start of conflict block
+        if let Some(label) = extract_marker_label(line, OURS_PREFIX) {
+            let ours_label = if label.is_empty() {
+                None
+            } else {
+                Some(label.to_string())
+            };
+            let start_line = i + 1; // Convert to 1-based
+            let mut separator_line = None;
+            let mut base_line = None;
+            let mut base_label = None;
+            let mut end_line = None;
+            let mut theirs_label = None;
+            let mut j = i + 1;
+
+            // Look for separator, optional base marker, and end marker
+            while j < lines.len() {
+                let current = lines[j];
+
+                // Check for base marker (3-way)
+                if let Some(label) = extract_marker_label(current, BASE_PREFIX) {
+                    if base_line.is_none() {
+                        base_line = Some(j + 1);
+                        base_label = if label.is_empty() {
+                            None
+                        } else {
+                            Some(label.to_string())
+                        };
+                        j += 1;
+                        continue;
+                    }
+                }
+
+                // Check for separator
+                if current.trim() == SEPARATOR {
+                    if separator_line.is_none() {
+                        separator_line = Some(j + 1);
+                        j += 1;
+                        continue;
+                    }
+                }
+
+                // Check for end marker
+                if let Some(label) = extract_marker_label(current, THEIRS_PREFIX) {
+                    if separator_line.is_some() {
+                        end_line = Some(j + 1);
+                        theirs_label = if label.is_empty() {
+                            None
+                        } else {
+                            Some(label.to_string())
+                        };
+                        j += 1;
+                        break;
+                    }
+                }
+
+                j += 1;
+            }
+
+            // Only add if we found both separator and end marker
+            if let (Some(sep_line), Some(end)) = (separator_line, end_line) {
+                blocks.push(ConflictBlock {
+                    start_line,
+                    separator_line: sep_line,
+                    end_line: end,
+                    base_line,
+                    ours_label,
+                    base_label,
+                    theirs_label,
+                });
+                i = j;
+                continue;
+            }
+        }
+
+        i += 1;
+    }
+
+    blocks
+}
+
+/// Extract the optional label from a marker line.
+/// Returns the label text (stripped of leading/trailing spaces) if the line matches the prefix,
+/// or None otherwise.
+fn extract_marker_label<'a>(line: &'a str, prefix: &str) -> Option<&'a str> {
+    if line.starts_with(prefix) {
+        let rest = &line[prefix.len()..];
+        // Accept either just the prefix or prefix + single space + label
+        if rest.is_empty() {
+            Some("")
+        } else if rest.starts_with(' ') {
+            Some(rest[1..].trim())
+        } else {
+            None
+        }
+    } else {
+        None
+    }
+}
+
+/// Format conflict blocks as a summary index, like GJC's implementation.
+fn format_conflict_summary(conflicts: &[ConflictBlock], display_path: &str) -> String {
+    let mut output = Vec::new();
+    let total = conflicts.len();
+    let word = if total == 1 { "conflict" } else { "conflicts" };
+
+    output.push(format!(
+        "⚠ {} unresolved {} in {}",
+        total, word, display_path
+    ));
+
+    // Extract labels for header
+    let ours_label = conflicts.iter().find_map(|c| c.ours_label.as_ref());
+    let theirs_label = conflicts.iter().find_map(|c| c.theirs_label.as_ref());
+    let base_label = conflicts.iter().find_map(|c| c.base_label.as_ref());
+    let any_base = conflicts.iter().any(|c| c.base_line.is_some());
+
+    if let Some(label) = ours_label {
+        output.push(format!("- ours = {}", label));
+    }
+    if let Some(label) = theirs_label {
+        output.push(format!("- theirs = {}", label));
+    }
+    if any_base {
+        let base_name = base_label
+            .map(|l| l.to_string())
+            .unwrap_or_else(|| "(no label)".to_string());
+        output.push(format!("- base = {}", base_name));
+    }
+
+    output.push(
+        "NOTICE: Bulk-resolve with `write({ path: \"conflict://*\", content })`, or address a single block with `write({ path: \"conflict://<N>\", content })`. Inspect a block by reading `conflict://<N>` (add `/ours` / `/theirs` / `/base` for a single side).".to_string()
+    );
+    output.push(
+        "`content` shorthand: `@ours` / `@theirs` / `@base` / `@both` lines expand to the recorded sections; `@both` = ours-then-theirs. Non-token lines pass through verbatim.".to_string()
+    );
+    output.push(String::new());
+
+    // Format each conflict as a one-liner index
+    let id_width = total.to_string().len();
+    for (idx, conflict) in conflicts.iter().enumerate() {
+        let id = idx + 1;
+        let range = if conflict.start_line == conflict.end_line {
+            format!("L{}", conflict.start_line)
+        } else {
+            format!("L{}-{}", conflict.start_line, conflict.end_line)
+        };
+        let kind = if conflict.base_line.is_some() {
+            "  (3-way)"
+        } else {
+            ""
+        };
+        output.push(format!(
+            "#{:>width$}  {}{}",
+            id,
+            range,
+            kind,
+            width = id_width
+        ));
+    }
+
+    output.join("\n")
+}
+
 /// Apply a parsed line selector to file lines and return the selected range.
 ///
 /// Returns (start_index, end_index, truncation_footer).
@@ -295,7 +512,7 @@ fn apply_line_selector(
             (0, lines.len(), None)
         }
         LineRangeSelector::Conflicts => {
-            // For now, return entire file (git merge conflict extraction would go here)
+            // Conflicts are handled specially in read_file_with_selector, so this shouldn't be reached
             (0, lines.len(), None)
         }
         LineRangeSelector::Lines(ranges) => {
@@ -1400,4 +1617,74 @@ mod tests {
         );
         assert!(result.is_err());
     }
+
+    #[test]
+    fn read_with_selector_conflicts_no_conflicts() {
+        let path = temp_path("conflicts-none.txt");
+        write_file(
+            path.to_string_lossy().as_ref(),
+            "const a = 1;\nconst b = 2;\n",
+        )
+        .expect("write should succeed");
+
+        let output = super::read_file_with_selector(
+            path.to_string_lossy().as_ref(),
+            None,
+            None,
+            Some("conflicts"),
+        )
+        .expect("read with conflicts selector should succeed");
+        assert!(output
+            .file
+            .content
+            .contains("No unresolved git merge conflicts"));
+    }
+
+    #[test]
+    fn read_with_selector_conflicts_two_way() {
+        let path = temp_path("conflicts-two-way.txt");
+        let content = "<<<<<<< A\na-ours\n=======\na-theirs\n>>>>>>> A\nmiddle\n<<<<<<< B\nb-ours\n=======\nb-theirs\n>>>>>>> B\ntail";
+        write_file(path.to_string_lossy().as_ref(), content).expect("write should succeed");
+
+        let output = super::read_file_with_selector(
+            path.to_string_lossy().as_ref(),
+            None,
+            None,
+            Some("conflicts"),
+        )
+        .expect("read with conflicts selector should succeed");
+
+        let text = &output.file.content;
+        // Should report 2 conflicts
+        assert!(text.contains("2 unresolved conflicts"), "text: {}", text);
+        // Should have indices for both blocks
+        assert!(text.contains("#1"), "missing #1: {}", text);
+        assert!(text.contains("#2"), "missing #2: {}", text);
+        // Should have line ranges
+        assert!(text.contains("L1-5"), "missing L1-5: {}", text);
+        assert!(text.contains("L7-11"), "missing L7-11: {}", text);
+    }
+
+    #[test]
+    fn read_with_selector_conflicts_three_way() {
+        let path = temp_path("conflicts-three-way.txt");
+        let content = "head\n<<<<<<< HEAD\nours body\n||||||| common ancestor\nbase body\n=======\ntheirs body\n>>>>>>> feat\ntail";
+        write_file(path.to_string_lossy().as_ref(), content).expect("write should succeed");
+
+        let output = super::read_file_with_selector(
+            path.to_string_lossy().as_ref(),
+            None,
+            None,
+            Some("conflicts"),
+        )
+        .expect("read with conflicts selector should succeed");
+
+        let text = &output.file.content;
+        // Should report 1 conflict
+        assert!(text.contains("1 unresolved conflict"), "text: {}", text);
+        // Should mark as 3-way
+        assert!(text.contains("3-way"), "missing 3-way marker: {}", text);
+        // Should show line range
+        assert!(text.contains("L2-8"), "missing L2-8: {}", text);
+    }
 }

rust/crates/runtime/src/lib.rs

@@ -67,15 +67,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,
@@ -83,8 +84,8 @@ pub use config_validate::{
 };
 pub use conversation::{
     auto_compaction_threshold_from_env, ApiClient, ApiRequest, AssistantEvent, AutoCompactionEvent,
-    ConversationRuntime, PromptCacheEvent, RuntimeError, StaticToolExecutor, ToolError,
-    ToolExecutor, TurnInterruptSignal, 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,

rust/crates/runtime/src/trident.rs

@@ -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,
             ));
         }

rust/crates/runtime/src/worker_boot.rs

@@ -34,9 +34,6 @@ pub enum WorkerStatus {
     ToolPermissionRequired,
     ReadyForPrompt,
     Running,
-    /// The user stopped the turn mid-run (e.g. Esc or Ctrl+C); the worker
-    /// is back at the prompt with the session intact.
-    Interrupted,
     Finished,
     Failed,
 }
@@ -49,7 +46,6 @@ impl std::fmt::Display for WorkerStatus {
             Self::ToolPermissionRequired => write!(f, "tool_permission_required"),
             Self::ReadyForPrompt => write!(f, "ready_for_prompt"),
             Self::Running => write!(f, "running"),
-            Self::Interrupted => write!(f, "interrupted"),
             Self::Finished => write!(f, "finished"),
             Self::Failed => write!(f, "failed"),
         }
@@ -86,7 +82,6 @@ pub enum WorkerEventKind {
     PromptMisdelivery,
     PromptReplayArmed,
     Running,
-    Interrupted,
     Restarted,
     Finished,
     Failed,
@@ -1466,23 +1461,6 @@ mod tests {
     use std::fs;
     use std::process::Command;
 
-    #[test]
-    fn interrupted_status_serializes_and_displays_as_snake_case() {
-        assert_eq!(WorkerStatus::Interrupted.to_string(), "interrupted");
-        assert_eq!(
-            serde_json::to_string(&WorkerStatus::Interrupted).expect("should serialize"),
-            "\"interrupted\""
-        );
-        assert_eq!(
-            serde_json::from_str::<WorkerStatus>("\"interrupted\"").expect("should deserialize"),
-            WorkerStatus::Interrupted
-        );
-        assert_eq!(
-            serde_json::to_string(&WorkerEventKind::Interrupted).expect("should serialize"),
-            "\"interrupted\""
-        );
-    }
-
     #[test]
     fn allowlisted_trust_prompt_auto_resolves_then_reaches_ready_state() {
         let registry = WorkerRegistry::new();

rust/crates/rusty-claude-cli/Cargo.toml

@@ -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" }
@@ -24,11 +25,16 @@ tokio = { version = "1", features = ["rt-multi-thread", "signal", "time"] }
 tools = { path = "../tools" }
 log = "0.4"
 
-[target.'cfg(unix)'.dependencies]
-nix = { version = "0.29", features = ["term", "poll"] }
 
-[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" }

rust/crates/rusty-claude-cli/src/input.rs

@@ -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()?;

rust/crates/rusty-claude-cli/src/interrupt.rs

@@ -1,280 +0,0 @@
-//! Esc-key interruption for running turns.
-//!
-//! While a turn runs, the main thread is blocked inside the conversation
-//! loop, so rustyline is not reading the keyboard. This module spawns a
-//! listener thread that switches stdin to a minimal non-canonical mode
-//! (line buffering and echo off; signal handling and output processing
-//! stay enabled, unlike full raw mode) and watches for a lone Escape
-//! byte. When one arrives it trips the shared [`TurnInterruptSignal`],
-//! which the conversation loop and the streaming API client poll to wind
-//! the turn down gracefully.
-//!
-//! Permission prompts read whole lines from stdin mid-turn, so stdin
-//! ownership is coordinated through [`StdinPromptGate`]: while a prompt
-//! holds a lease, the listener restores canonical mode and stops
-//! consuming bytes.
-
-use std::io::IsTerminal;
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{Arc, Mutex, PoisonError};
-use std::thread::JoinHandle;
-
-use runtime::TurnInterruptSignal;
-
-/// Terminal-mode bookkeeping guarded by the gate mutex. `saved` holds the
-/// canonical-mode termios while non-canonical mode is active.
-#[derive(Default)]
-struct TtyMode {
-    #[cfg(unix)]
-    saved: Option<nix::sys::termios::Termios>,
-}
-
-#[derive(Default)]
-struct GateState {
-    /// True while a permission prompt owns stdin.
-    busy: AtomicBool,
-    /// Tells the listener thread to exit at the end of the turn.
-    stop: AtomicBool,
-    /// Serializes stdin reads and terminal-mode flips.
-    mode: Mutex<TtyMode>,
-}
-
-/// Classification of one chunk of bytes read from the terminal.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum EscClassification {
-    /// A bare ESC byte: the user pressed the Escape key.
-    LoneEscape,
-    /// ESC followed by more bytes: the prefix of a terminal escape
-    /// sequence such as an arrow or function key.
-    EscapeSequence,
-    /// Anything else (regular type-ahead, control characters, ...).
-    Other,
-}
-
-#[cfg_attr(not(unix), allow(dead_code))]
-fn classify_escape_chunk(bytes: &[u8]) -> EscClassification {
-    match bytes {
-        [0x1b] => EscClassification::LoneEscape,
-        [0x1b, ..] => EscClassification::EscapeSequence,
-        _ => EscClassification::Other,
-    }
-}
-
-/// Hands exclusive stdin ownership to interactive prompts while the
-/// Esc listener is running.
-#[derive(Clone)]
-pub struct StdinPromptGate {
-    shared: Arc<GateState>,
-}
-
-impl StdinPromptGate {
-    /// Takes stdin away from the Esc listener for the lifetime of the
-    /// returned lease: the terminal returns to canonical mode so a
-    /// line-based prompt (e.g. the permission approval prompt) behaves
-    /// normally. Listening resumes when the lease is dropped.
-    pub fn lease(&self) -> StdinPromptLease<'_> {
-        self.shared.busy.store(true, Ordering::SeqCst);
-        // Wait for the listener's current poll cycle to release the
-        // terminal, then restore canonical mode for line input.
-        #[allow(unused_mut)]
-        let mut mode = self
-            .shared
-            .mode
-            .lock()
-            .unwrap_or_else(PoisonError::into_inner);
-        #[cfg(unix)]
-        tty::restore(&mut mode);
-        drop(mode);
-        StdinPromptLease {
-            shared: &self.shared,
-        }
-    }
-}
-
-/// RAII lease returned by [`StdinPromptGate::lease`].
-pub struct StdinPromptLease<'a> {
-    shared: &'a GateState,
-}
-
-impl Drop for StdinPromptLease<'_> {
-    fn drop(&mut self) {
-        self.shared.busy.store(false, Ordering::SeqCst);
-    }
-}
-
-/// Background listener that maps a lone Esc keypress to
-/// [`TurnInterruptSignal::interrupt`].
-pub struct EscapeInterruptMonitor {
-    shared: Arc<GateState>,
-    join_handle: Option<JoinHandle<()>>,
-}
-
-impl EscapeInterruptMonitor {
-    /// Spawns the listener for the duration of one turn. Returns `None`
-    /// when stdin is not an interactive terminal or the platform does not
-    /// support terminal-mode switching; Ctrl+C interruption still works
-    /// in those cases.
-    pub fn spawn(signal: TurnInterruptSignal) -> Option<(Self, StdinPromptGate)> {
-        if !std::io::stdin().is_terminal() {
-            return None;
-        }
-
-        #[cfg(not(unix))]
-        {
-            let _ = signal;
-            None
-        }
-
-        #[cfg(unix)]
-        {
-            let shared = Arc::new(GateState::default());
-            let thread_shared = Arc::clone(&shared);
-            let join_handle = std::thread::spawn(move || listener_loop(&thread_shared, &signal));
-            let gate = StdinPromptGate {
-                shared: Arc::clone(&shared),
-            };
-            Some((
-                Self {
-                    shared,
-                    join_handle: Some(join_handle),
-                },
-                gate,
-            ))
-        }
-    }
-
-    /// Stops the listener and restores the terminal before control
-    /// returns to the line editor.
-    pub fn stop(mut self) {
-        self.shared.stop.store(true, Ordering::SeqCst);
-        if let Some(join_handle) = self.join_handle.take() {
-            let _ = join_handle.join();
-        }
-    }
-}
-
-#[cfg(unix)]
-fn listener_loop(shared: &GateState, signal: &TurnInterruptSignal) {
-    let mut buffer = [0u8; 64];
-
-    while !shared.stop.load(Ordering::SeqCst) {
-        if shared.busy.load(Ordering::SeqCst) {
-            std::thread::sleep(std::time::Duration::from_millis(25));
-            continue;
-        }
-
-        let mut mode = shared.mode.lock().unwrap_or_else(PoisonError::into_inner);
-        if shared.busy.load(Ordering::SeqCst) || shared.stop.load(Ordering::SeqCst) {
-            continue;
-        }
-        if !tty::enable_noncanonical(&mut mode) {
-            // Terminal refused the mode switch; Esc support is
-            // unavailable for this turn but Ctrl+C still works.
-            return;
-        }
-        if !tty::wait_readable(100) {
-            continue;
-        }
-
-        let count = tty::read_pending(&mut buffer);
-        if classify_escape_chunk(&buffer[..count]) == EscClassification::LoneEscape {
-            // A slow terminal may split an escape sequence across reads;
-            // only treat ESC as the Esc key when nothing follows it.
-            if tty::wait_readable(50) {
-                let _ = tty::read_pending(&mut buffer);
-                continue;
-            }
-            signal.interrupt();
-        }
-        // Other bytes are intentionally swallowed: type-ahead is not
-        // preserved while a turn is running.
-    }
-
-    let mut mode = shared.mode.lock().unwrap_or_else(PoisonError::into_inner);
-    tty::restore(&mut mode);
-}
-
-#[cfg(unix)]
-mod tty {
-    use std::os::fd::{AsFd, AsRawFd};
-
-    use nix::poll::{poll, PollFd, PollFlags, PollTimeout};
-    use nix::sys::termios::{self, LocalFlags, SetArg, SpecialCharacterIndices};
-
-    use super::TtyMode;
-
-    /// Disables line buffering and echo while leaving signal generation
-    /// (ISIG) and output post-processing (OPOST) untouched, so Ctrl+C and
-    /// streamed output keep working. No-op when already active.
-    pub(super) fn enable_noncanonical(mode: &mut TtyMode) -> bool {
-        if mode.saved.is_some() {
-            return true;
-        }
-        let stdin = std::io::stdin();
-        let Ok(saved) = termios::tcgetattr(&stdin) else {
-            return false;
-        };
-        let mut noncanonical = saved.clone();
-        noncanonical.local_flags &= !(LocalFlags::ICANON | LocalFlags::ECHO);
-        noncanonical.control_chars[SpecialCharacterIndices::VMIN as usize] = 0;
-        noncanonical.control_chars[SpecialCharacterIndices::VTIME as usize] = 0;
-        if termios::tcsetattr(&stdin, SetArg::TCSANOW, &noncanonical).is_err() {
-            return false;
-        }
-        mode.saved = Some(saved);
-        true
-    }
-
-    pub(super) fn restore(mode: &mut TtyMode) {
-        if let Some(saved) = mode.saved.take() {
-            let _ = termios::tcsetattr(std::io::stdin(), SetArg::TCSANOW, &saved);
-        }
-    }
-
-    pub(super) fn wait_readable(timeout_ms: u16) -> bool {
-        let stdin = std::io::stdin();
-        let mut fds = [PollFd::new(stdin.as_fd(), PollFlags::POLLIN)];
-        matches!(poll(&mut fds, PollTimeout::from(timeout_ms)), Ok(ready) if ready > 0)
-            && fds[0]
-                .revents()
-                .is_some_and(|revents| revents.contains(PollFlags::POLLIN))
-    }
-
-    pub(super) fn read_pending(buffer: &mut [u8]) -> usize {
-        nix::unistd::read(std::io::stdin().as_raw_fd(), buffer).unwrap_or(0)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{classify_escape_chunk, EscClassification};
-
-    #[test]
-    fn lone_escape_byte_is_the_esc_key() {
-        assert_eq!(
-            classify_escape_chunk(&[0x1b]),
-            EscClassification::LoneEscape
-        );
-    }
-
-    #[test]
-    fn escape_followed_by_more_bytes_is_a_sequence() {
-        // Up arrow: ESC [ A
-        assert_eq!(
-            classify_escape_chunk(&[0x1b, 0x5b, 0x41]),
-            EscClassification::EscapeSequence
-        );
-        // Alt+f style: ESC f
-        assert_eq!(
-            classify_escape_chunk(&[0x1b, b'f']),
-            EscClassification::EscapeSequence
-        );
-    }
-
-    #[test]
-    fn regular_bytes_are_ignored() {
-        assert_eq!(classify_escape_chunk(b"hello"), EscClassification::Other);
-        assert_eq!(classify_escape_chunk(&[]), EscClassification::Other);
-        assert_eq!(classify_escape_chunk(&[0x03]), EscClassification::Other);
-    }
-}

rust/crates/rusty-claude-cli/src/render.rs

@@ -249,16 +249,6 @@ impl TerminalRenderer {
 
     #[must_use]
     pub fn render_markdown(&self, markdown: &str) -> String {
-        self.render_markdown_raw(markdown).trim_end().to_string()
-    }
-
-    /// Render markdown to ANSI without trimming trailing whitespace.
-    ///
-    /// Block-level events (paragraphs, headings, lists, code blocks) emit their
-    /// trailing newline separators here. `render_markdown` trims them for
-    /// one-shot output, while streaming keeps them so that successive chunks
-    /// stay on their own lines instead of running together.
-    fn render_markdown_raw(&self, markdown: &str) -> String {
         let normalized = normalize_nested_fences(markdown);
         let mut output = String::new();
         let mut state = RenderState::default();
@@ -277,7 +267,30 @@ impl TerminalRenderer {
             );
         }
 
-        output
+        output.trim_end().to_string()
+    }
+
+    /// Ensures the output ends with at least `required` newlines.
+    /// This is idempotent: calling it multiple times with the same output
+    /// will not add extra newlines beyond what is needed.
+    /// The function is crucial for streaming rendering where chunks may
+    /// split at block boundaries, causing the parser to lose newlines
+    /// that normally separate blocks.
+    fn ensure_newlines(output: &mut String, required: usize) {
+        if output.is_empty() {
+            // Don't start with blank lines
+            return;
+        }
+
+        // Count trailing newlines
+        let trailing_newlines = output.chars().rev().take_while(|&c| c == '\n').count();
+
+        // Add newlines if we don't have enough
+        if trailing_newlines < required {
+            for _ in 0..(required - trailing_newlines) {
+                output.push('\n');
+            }
+        }
     }
 
     #[must_use]
@@ -285,18 +298,6 @@ impl TerminalRenderer {
         self.render_markdown(markdown)
     }
 
-    /// Stream-friendly variant of `markdown_to_ansi` that preserves trailing
-    /// block separators (such as a paragraph's closing newlines).
-    ///
-    /// `MarkdownStreamState::push` writes each rendered chunk directly to the
-    /// terminal with no separator of its own, so the trailing newlines must
-    /// survive here to keep a paragraph from sticking to the block that follows
-    /// it. The final `flush` still uses `markdown_to_ansi` to trim the tail.
-    #[must_use]
-    pub fn markdown_to_ansi_stream(&self, markdown: &str) -> String {
-        self.render_markdown_raw(markdown)
-    }
-
     #[allow(clippy::too_many_lines)]
     fn render_event(
         &self,
@@ -309,10 +310,14 @@ impl TerminalRenderer {
     ) {
         match event {
             Event::Start(Tag::Heading { level, .. }) => {
+                Self::ensure_newlines(output, 1);
                 Self::start_heading(state, level as u8, output);
             }
             Event::End(TagEnd::Paragraph) => output.push_str("\n\n"),
-            Event::Start(Tag::BlockQuote(..)) => self.start_quote(state, output),
+            Event::Start(Tag::BlockQuote(..)) => {
+                Self::ensure_newlines(output, 1);
+                self.start_quote(state, output);
+            }
             Event::End(TagEnd::BlockQuote(..)) => {
                 state.quote = state.quote.saturating_sub(1);
                 output.push('\n');
@@ -325,6 +330,7 @@ impl TerminalRenderer {
                 state.append_raw(output, "\n");
             }
             Event::Start(Tag::List(first_item)) => {
+                Self::ensure_newlines(output, 1);
                 let kind = match first_item {
                     Some(index) => ListKind::Ordered { next_index: index },
                     None => ListKind::Unordered,
@@ -337,6 +343,7 @@ impl TerminalRenderer {
             }
             Event::Start(Tag::Item) => Self::start_item(state, output),
             Event::Start(Tag::CodeBlock(kind)) => {
+                Self::ensure_newlines(output, 2);
                 *in_code_block = true;
                 *code_language = match kind {
                     CodeBlockKind::Indented => String::from("text"),
@@ -360,7 +367,10 @@ impl TerminalRenderer {
                     format!("{}", format!("`{code}`").with(self.color_theme.inline_code));
                 state.append_raw(output, &rendered);
             }
-            Event::Rule => output.push_str("---\n"),
+            Event::Rule => {
+                Self::ensure_newlines(output, 1);
+                output.push_str("---\n");
+            }
             Event::Text(text) => {
                 self.push_text(text.as_ref(), state, output, code_buffer, *in_code_block);
             }
@@ -405,7 +415,10 @@ impl TerminalRenderer {
                 );
                 state.append_raw(output, &rendered);
             }
-            Event::Start(Tag::Table(..)) => state.table = Some(TableState::default()),
+            Event::Start(Tag::Table(..)) => {
+                Self::ensure_newlines(output, 1);
+                state.table = Some(TableState::default());
+            }
             Event::End(TagEnd::Table) => {
                 if let Some(table) = state.table.take() {
                     output.push_str(&self.render_table(&table));
@@ -619,9 +632,21 @@ impl TerminalRenderer {
     }
 }
 
-#[derive(Debug, Default, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct MarkdownStreamState {
     pending: String,
+    /// Track whether the last emitted output ended with a newline.
+    /// Used to ensure proper spacing when resuming from a buffer.
+    last_output_ends_with_newline: bool,
+}
+
+impl Default for MarkdownStreamState {
+    fn default() -> Self {
+        Self {
+            pending: String::new(),
+            last_output_ends_with_newline: false,
+        }
+    }
 }
 
 impl MarkdownStreamState {
@@ -631,7 +656,40 @@ impl MarkdownStreamState {
         let split = find_stream_safe_boundary(&self.pending)?;
         let ready = self.pending[..split].to_string();
         self.pending.drain(..split);
-        Some(renderer.markdown_to_ansi_stream(&ready))
+
+        let mut rendered = renderer.markdown_to_ansi(&ready);
+        let stripped = strip_ansi(&rendered);
+
+        // If the previous output didn't end with a newline and this chunk starts
+        // with a block-level element, ensure proper spacing before it.
+        if !self.last_output_ends_with_newline && !rendered.is_empty() {
+            if stripped.starts_with("\u{256d}\u{2500}")
+                || stripped.starts_with("```")
+                || stripped.starts_with("|")
+                || stripped.starts_with("• ")
+                || stripped.starts_with("1. ")
+                || stripped.starts_with("-")
+            {
+                rendered = format!("\n\n{}", rendered);
+            }
+        }
+
+        // When markdown ends with a code block closing marker or other block-level element,
+        // render_markdown() trims the trailing newlines that finish_code_block() added.
+        // For streaming, we need to restore these newlines so proper spacing is preserved
+        // when chunks are combined. This is critical for idempotence across re-renders.
+        if stripped.ends_with("\u{2570}\u{2500}")
+            || stripped.ends_with("---")
+            || stripped.ends_with("|")
+        {
+            // Block element that should have trailing spacing
+            if !rendered.ends_with('\n') {
+                rendered.push_str("\n\n");
+            }
+        }
+
+        self.last_output_ends_with_newline = rendered.ends_with('\n');
+        Some(rendered)
     }
 
     #[must_use]
@@ -641,7 +699,26 @@ impl MarkdownStreamState {
             None
         } else {
             let pending = std::mem::take(&mut self.pending);
-            Some(renderer.markdown_to_ansi(&pending))
+            let mut rendered = renderer.markdown_to_ansi(&pending);
+
+            // If the previous output didn't end with a newline and this output
+            // starts with a block-level element, ensure proper spacing.
+            if !self.last_output_ends_with_newline && !rendered.is_empty() {
+                // Check if output starts with a block element by looking for common markers
+                let stripped = strip_ansi(&rendered);
+                if stripped.starts_with("\u{256d}\u{2500}")
+                    || stripped.starts_with("```")
+                    || stripped.starts_with("|")
+                    || stripped.starts_with("• ")
+                    || stripped.starts_with("1. ")
+                    || stripped.starts_with("-")
+                {
+                    rendered = format!("\n\n{}", rendered);
+                }
+            }
+
+            self.last_output_ends_with_newline = rendered.ends_with('\n');
+            Some(rendered)
         }
     }
 }
@@ -835,6 +912,11 @@ fn normalize_nested_fences(markdown: &str) -> String {
     out
 }
 
+/// Find a safe boundary for streaming markdown rendering.
+/// Safe boundaries are:
+/// - After a closing fence line (when fence is closed)
+/// - After an empty line
+/// This function returns the position of the last safe boundary found.
 fn find_stream_safe_boundary(markdown: &str) -> Option<usize> {
     let mut open_fence: Option<FenceMarker> = None;
     let mut last_boundary = None;
@@ -1074,34 +1156,6 @@ mod tests {
         assert!(plain_text.contains("fn nested()"));
     }
 
-    #[test]
-    fn stream_rendering_preserves_block_separators() {
-        let renderer = TerminalRenderer::new();
-
-        // The stream variant keeps the paragraph-ending newlines that the
-        // one-shot variant trims, so consecutive streamed chunks do not run
-        // into each other when written back-to-back to the terminal.
-        let streamed = renderer.markdown_to_ansi_stream("Intro paragraph.\n\n");
-        assert!(streamed.ends_with('\n'));
-        assert!(!renderer
-            .markdown_to_ansi("Intro paragraph.\n\n")
-            .ends_with('\n'));
-
-        let mut state = MarkdownStreamState::default();
-        let first = state
-            .push(&renderer, "Intro paragraph.\n\n")
-            .expect("blank line closes the paragraph block");
-        let second = state
-            .push(&renderer, "1. first item\n\n")
-            .expect("blank line closes the list block");
-
-        let combined = strip_ansi(&format!("{first}{second}"));
-        assert!(combined.contains("Intro paragraph."));
-        assert!(combined.contains("1. first item"));
-        // The two blocks stay on separate lines instead of sticking together.
-        assert!(!combined.contains("Intro paragraph.1."));
-    }
-
     #[test]
     fn spinner_advances_frames() {
         let terminal_renderer = TerminalRenderer::new();
@@ -1117,4 +1171,189 @@ mod tests {
         let output = String::from_utf8_lossy(&out);
         assert!(output.contains("Working"));
     }
+
+    #[test]
+    fn streaming_text_before_code_block_preserves_newline_boundary() {
+        let renderer = TerminalRenderer::new();
+        let mut state = MarkdownStreamState::default();
+
+        // Simulate streaming: paragraph text arrives in one chunk
+        assert_eq!(
+            state.push(&renderer, "This is some text."),
+            None,
+            "incomplete paragraph should not flush"
+        );
+
+        // Then code block arrives in the next chunk
+        let rendered = state
+            .push(&renderer, "\n\n```rust\nfn main() {}\n```\n")
+            .expect("fenced block should trigger flush");
+        let plain_text = strip_ansi(&rendered);
+
+        // Verify the paragraph text and code block are present
+        assert!(plain_text.contains("This is some text."));
+        assert!(plain_text.contains("fn main()"));
+
+        // The critical check: there should be a blank line between the paragraph and code block
+        // The paragraph ends, then there should be newlines before the code block marker
+        let lines: Vec<&str> = plain_text.lines().collect();
+        let text_line_idx = lines
+            .iter()
+            .position(|line| line.contains("This is some text."))
+            .expect("find text line");
+        // Skip past the text line and find the code block
+        let code_marker_idx = lines[text_line_idx + 1..]
+            .iter()
+            .position(|line| line.contains("╭─ rust"))
+            .map(|i| i + text_line_idx + 1);
+
+        // There should be at least one empty line between the text and the code block marker
+        if let Some(code_idx) = code_marker_idx {
+            assert!(
+                code_idx > text_line_idx + 1,
+                "there should be spacing between paragraph and code block"
+            );
+        }
+    }
+
+    #[test]
+    fn rendering_paragraph_immediately_before_code_block_has_blank_line() {
+        let renderer = TerminalRenderer::new();
+        let markdown = "This is a paragraph.\n\n```rust\nfn main() {}\n```";
+        let output = renderer.markdown_to_ansi(markdown);
+        let plain_text = strip_ansi(&output);
+        let lines: Vec<&str> = plain_text.lines().collect();
+
+        // Find the paragraph and code block
+        let text_idx = lines
+            .iter()
+            .position(|l| l.contains("This is a paragraph."))
+            .expect("find paragraph");
+        let code_idx = lines[text_idx + 1..]
+            .iter()
+            .position(|l| l.contains("╭─ rust"))
+            .map(|i| i + text_idx + 1)
+            .expect("find code block");
+
+        // There should be at least one blank line between them
+        assert!(
+            code_idx > text_idx + 1,
+            "code block should not immediately follow paragraph"
+        );
+    }
+
+    #[test]
+    fn code_block_ending_with_trailing_text_preserves_spacing() {
+        let renderer = TerminalRenderer::new();
+        let markdown = "```rust\nfn main() {}\n```\n\nText after.";
+        let output = renderer.markdown_to_ansi(markdown);
+        let plain_text = strip_ansi(&output);
+
+        // The code block should end with "╰─" followed by blank lines, then text
+        assert!(
+            plain_text.contains("\u{256d}\u{2500}"),
+            "should contain code block close marker"
+        );
+        assert!(
+            plain_text.contains("\n\nText"),
+            "should have blank line before text"
+        );
+    }
+
+    #[test]
+    fn streaming_code_block_preserves_trailing_newlines() {
+        let renderer = TerminalRenderer::new();
+        let mut state = MarkdownStreamState::default();
+        let markdown = "Text before.\n\n```rust\nfn test() {}\n```\n\nText after.";
+
+        // Debug: let's check what the code block part alone renders to
+        let code_part = "```rust\nfn test() {}\n```\n\nText after.";
+        let code_rendered = strip_ansi(&renderer.markdown_to_ansi(code_part));
+
+        // Simulate the streaming at split position 1
+        let r1 = state.push(&renderer, "T").map(|s| strip_ansi(&s));
+        let r2 = state
+            .push(
+                &renderer,
+                "ext before.\n\n```rust\nfn test() {}\n```\n\nText after.",
+            )
+            .map(|s| strip_ansi(&s));
+
+        // After r2, the pending should contain the code block part
+        let pending_before_r3 = state.pending.clone();
+
+        let r3 = state.flush(&renderer).map(|s| strip_ansi(&s));
+
+        // Combine the results
+        let mut full_streamed = String::new();
+        if let Some(s) = &r1 {
+            full_streamed.push_str(s);
+        }
+        if let Some(s) = &r2 {
+            full_streamed.push_str(s);
+        }
+        if let Some(s) = &r3 {
+            full_streamed.push_str(s);
+        }
+
+        let full_rendered = strip_ansi(&renderer.markdown_to_ansi(markdown));
+
+        assert_eq!(full_streamed, full_rendered,
+            "Streaming mismatch.\n\nCode part alone renders to: {:?}\nPending before r3: {:?}\n\nBreakdown:\n  r1: {:?}\n  r2: {:?}\n  r3: {:?}\n\nExpected:\n{:?}\n\nGot:\n{:?}",
+            code_rendered, pending_before_r3, r1, r2, r3, full_rendered, full_streamed);
+    }
+
+    #[test]
+    fn streaming_with_split_at_every_byte_position_produces_consistent_output() {
+        let renderer = TerminalRenderer::new();
+        let markdown = "Text before.\n\n```rust\nfn test() {}\n```\n\nText after.";
+
+        // First, render the full document
+        let full_output = renderer.markdown_to_ansi(markdown);
+        let full_plain = strip_ansi(&full_output);
+
+        // Now simulate streaming by splitting at different positions
+        for split_pos in 1..markdown.len() {
+            let mut state = MarkdownStreamState::default();
+            let part1 = &markdown[..split_pos];
+            let part2 = &markdown[split_pos..];
+
+            // Try to push both parts
+            let r1 = state.push(&renderer, part1);
+            let r2 = state.push(&renderer, part2);
+            let final_r = state.flush(&renderer);
+
+            // Reconstruct the streamed output
+            let mut streamed_output = String::new();
+            if let Some(out) = r1 {
+                streamed_output.push_str(&out);
+            }
+            if let Some(out) = r2 {
+                streamed_output.push_str(&out);
+            }
+            if let Some(out) = final_r {
+                streamed_output.push_str(&out);
+            }
+
+            let streamed_plain = strip_ansi(&streamed_output);
+
+            if streamed_plain != full_plain {
+                eprintln!("\n=== MISMATCH at split position {} ===", split_pos);
+                eprintln!("Part 1: {:?}", part1);
+                eprintln!("Part 2: {:?}", part2);
+                eprintln!("\nExpected (full):");
+                eprintln!("{:?}", full_plain);
+                eprintln!("\nGot (streamed):");
+                eprintln!("{:?}", streamed_plain);
+                eprintln!("\nStreamed rendered output:");
+                eprintln!("{:?}", streamed_output);
+            }
+
+            assert_eq!(
+                streamed_plain, full_plain,
+                "streaming with split at position {} produces different output",
+                split_pos
+            );
+        }
+    }
 }

rust/crates/sdk/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sdk"
-version = "0.1.0"
+version = "0.1.4"
 edition = "2021"
 publish = false
 

rust/crates/tools/MULTI_TOOL_README.md

@@ -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()` |

rust/crates/tools/src/lane_completion.rs

@@ -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,
         }
     }