feat: integrate custom-openai provider namespace with separate env vars

- Add 'custom-openai' provider kind to setup_wizard.rs with distinct env namespace - Add CustomOpenAi variant to ProviderConfigKind enum in api/client.rs - Implement OpenAiCompatConfig::custom_openai() for custom-openai endpoint - Update explicit_provider_kind_for_model() to handle 'custom-openai/' prefix - Add tests for custom-openai configuration persistence across runtime boundary Co-authored-by: TheArchitectit <thearchitectit@users.noreply.github.com> Fixes #3248
2026-10-20 00:00:17 +08:00 · 2026-10-13 00:07:22 +00:00
35 changed files with 1514 additions and 4302 deletions
@@ -15,7 +15,6 @@ status-help.txt
 .port_sessions/
 # Local agent session state
 .gjc/
-.claude/
 # Nix build outputs and direnv
 .envrc.local
 result
@@ -1 +0,0 @@
-{"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"}]}}
@@ -1 +0,0 @@
-{"pid":1,"start_time":"unknown","token":"8389ee99-c41c-47dd-9615-e76a5268967c","owner_host_id":"7af2fb0e8e37bd543e3d0bda6f205b56f30077b5a9b77e83208e94ae441315ac","released":true}
@@ -1 +0,0 @@
-{"pid":1,"start_time":"unknown","token":"6e35ded8-fda1-421e-a727-42906ef57646","owner_host_id":"7af2fb0e8e37bd543e3d0bda6f205b56f30077b5a9b77e83208e94ae441315ac","released":true}
@@ -1,12 +0,0 @@
-{
-  "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
-}
@@ -1 +0,0 @@
-{"effectMarker":"7b92c148-d616-4eb5-95e8-4e95084bebe9","incarnation":"linux:159085489","pid":177576}
@@ -1 +0,0 @@
-{"effectMarker":"7b92c148-d616-4eb5-95e8-4e95084bebe9","incarnation":"linux:159085489","pid":177576}
@@ -5,44 +5,6 @@ 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.
@@ -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.4`, `publish = false`, MIT license.
+Workspace version is `0.1.3`, `publish = false`, MIT license.

 No rust-toolchain file, no MSRV. CI pins `dtolnay/rust-toolchain@stable`.

@@ -3,7 +3,7 @@ members = ["crates/*"]
 resolver = "2"

 [workspace.package]
-version = "0.1.4"
+version = "0.1.3"
 edition = "2021"
 license = "MIT"
 publish = false
@@ -15,13 +15,15 @@ pub enum ProviderClient {

 /// Provider selected explicitly by persisted/runtime configuration.
 ///
-/// This is intentionally separate from `ProviderKind`: DashScope speaks the
-/// OpenAI-compatible wire protocol but remains a distinct configured provider.
+/// This is intentionally separate from `ProviderKind`: Custom OpenAI and
+/// DashScope speak the OpenAI-compatible wire protocol but remain distinct
+/// configured providers.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum ProviderConfigKind {
    Anthropic,
    Xai,
    OpenAi,
+    CustomOpenAi,
    DashScope,
 }

@@ -96,9 +98,12 @@ impl ProviderClient {

                Ok(Self::Xai(client))
            }
-            ProviderConfigKind::OpenAi | ProviderConfigKind::DashScope => {
+            ProviderConfigKind::OpenAi
+            | ProviderConfigKind::CustomOpenAi
+            | ProviderConfigKind::DashScope => {
                let compat = match config.kind {
                    ProviderConfigKind::OpenAi => OpenAiCompatConfig::openai(),
+                    ProviderConfigKind::CustomOpenAi => OpenAiCompatConfig::custom_openai(),
                    ProviderConfigKind::DashScope => OpenAiCompatConfig::dashscope(),
                    _ => unreachable!("non-OpenAI provider reached compatibility path"),
                };
@@ -403,6 +408,56 @@ mod tests {
        }
    }

+    #[test]
+    fn persisted_custom_openai_uses_its_own_environment_namespace() {
+        let _lock = env_lock();
+        let _custom_key = EnvVarGuard::set("CLAWCUSTOMOPENAI_API_KEY", Some("custom-key"));
+        let _custom_url = EnvVarGuard::set(
+            "CLAWCUSTOMOPENAI_BASE_URL",
+            Some("https://custom.example/v1"),
+        );
+        let _openai_key = EnvVarGuard::set("OPENAI_API_KEY", Some("openai-key"));
+        let _openai_url = EnvVarGuard::set("OPENAI_BASE_URL", Some("https://openai.example/v1"));
+        let _ollama = EnvVarGuard::set("OLLAMA_HOST", Some("http://localhost:11434"));
+
+        let config = ProviderConfig {
+            kind: ProviderConfigKind::CustomOpenAi,
+            model: "qwen-plus".to_string(),
+            api_key: None,
+            base_url: None,
+        };
+
+        match ProviderClient::from_config(&config).expect("custom OpenAI config should succeed") {
+            ProviderClient::OpenAi(client) => {
+                assert_eq!(client.base_url(), "https://custom.example/v1");
+            }
+            other => panic!("Expected custom OpenAI provider, got: {other:?}"),
+        }
+    }
+
+    #[test]
+    fn persisted_custom_openai_does_not_reuse_openai_credentials() {
+        let _lock = env_lock();
+        let _custom_key = EnvVarGuard::set("CLAWCUSTOMOPENAI_API_KEY", None);
+        let _custom_url = EnvVarGuard::set(
+            "CLAWCUSTOMOPENAI_BASE_URL",
+            Some("https://custom.example/v1"),
+        );
+        let _openai_key = EnvVarGuard::set("OPENAI_API_KEY", Some("openai-key"));
+        let _ollama = EnvVarGuard::set("OLLAMA_HOST", Some("http://localhost:11434"));
+
+        let config = ProviderConfig {
+            kind: ProviderConfigKind::CustomOpenAi,
+            model: "gpt-5".to_string(),
+            api_key: None,
+            base_url: None,
+        };
+
+        let error = ProviderClient::from_config(&config)
+            .expect_err("custom OpenAI must require its own credentials");
+        assert!(error.to_string().contains("CLAWCUSTOMOPENAI_API_KEY"));
+    }
+
    #[test]
    fn dashscope_model_uses_dashscope_config_not_openai() {
        // Regression: qwen-plus was being routed to OpenAiCompatConfig::openai()
@@ -180,49 +180,6 @@ 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 {
@@ -30,9 +30,8 @@ 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, model_token_limit,
-    provider_diagnostics_for_model, resolve_model_alias, ModelTokenLimit, ProviderDiagnostics,
-    ProviderKind,
+    model_family_identity_for, model_family_identity_for_kind, provider_diagnostics_for_model,
+    resolve_model_alias, ProviderDiagnostics, ProviderKind,
 };
 pub use sse::{parse_frame, SseParser};
 pub use types::{
@@ -683,15 +683,13 @@ pub fn model_token_limit(model: &str) -> Option<ModelTokenLimit> {
            max_output_tokens: 8_192,
            context_window_tokens: 131_072,
        }),
-        // 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,
+        "qwen-max" => 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,
+        "qwen-plus" => Some(ModelTokenLimit {
+            max_output_tokens: 8_192,
+            context_window_tokens: 131_072,
        }),
        // Groq compound systems are exposed through an OpenAI-compatible API
        // but cap completions at 8,192 output tokens. Without this metadata
@@ -701,8 +699,6 @@ 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,
    }
 }
@@ -42,6 +42,7 @@ pub struct OpenAiCompatConfig {

 const XAI_ENV_VARS: &[&str] = &["XAI_API_KEY"];
 const OPENAI_ENV_VARS: &[&str] = &["OPENAI_API_KEY"];
+const CUSTOM_OPENAI_ENV_VARS: &[&str] = &["CLAWCUSTOMOPENAI_API_KEY"];
 const DASHSCOPE_ENV_VARS: &[&str] = &["DASHSCOPE_API_KEY"];

 // Provider-specific request body size limits in bytes
@@ -80,6 +81,18 @@ impl OpenAiCompatConfig {
        }
    }

+    /// OpenAI-compatible endpoint with its own environment namespace and no default URL.
+    #[must_use]
+    pub const fn custom_openai() -> Self {
+        Self {
+            provider_name: "Custom OpenAI",
+            api_key_env: "CLAWCUSTOMOPENAI_API_KEY",
+            base_url_env: "CLAWCUSTOMOPENAI_BASE_URL",
+            default_base_url: "",
+            max_request_body_bytes: OPENAI_MAX_REQUEST_BODY_BYTES,
+        }
+    }
+
    /// Alibaba `DashScope` compatible-mode endpoint (Qwen family models).
    /// Uses the OpenAI-compatible REST shape at /compatible-mode/v1.
    /// Requested via Discord #clawcode-get-help: native Alibaba API for
@@ -100,6 +113,7 @@ impl OpenAiCompatConfig {
        match self.provider_name {
            "xAI" => XAI_ENV_VARS,
            "OpenAI" => OPENAI_ENV_VARS,
+            "Custom OpenAI" => CUSTOM_OPENAI_ENV_VARS,
            "DashScope" => DASHSCOPE_ENV_VARS,
            _ => &[],
        }
@@ -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.4")
+        Some("claude-code/0.1.3")
    );
    assert_eq!(
        request.headers.get("anthropic-beta").map(String::as_str),
@@ -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.as_chunks::<4>().0 {
-        v.push(f32::from_le_bytes(*chunk));
+    for chunk in blob.chunks_exact(4) {
+        v.push(f32::from_le_bytes([chunk[0], chunk[1], chunk[2], chunk[3]]));
    }
    Some(v)
 }
@@ -66,7 +66,7 @@ async fn flush_path_batch(
    #[cfg(feature = "qdrant-index")]
    let mut qdrant_points: Vec<ChunkPoint> = Vec::with_capacity(batch.len());

-    for ((ord, t), vec) in batch.drain(..).zip(vecs) {
+    for ((ord, t), vec) in batch.drain(..).zip(vecs.into_iter()) {
        let dim = vec.len();
        let cid = insert_chunk(conn, path, ord, &t)?;
        insert_embedding(conn, cid, dim, &vec)?;
@@ -808,7 +808,7 @@ const SLASH_COMMAND_SPECS: &[SlashCommandSpec] = &[
        name: "team",
        aliases: &[],
        summary: "Manage agent teams",
-        argument_hint: Some("[on|off|status]"),
+        argument_hint: Some("[list|create|delete]"),
        resume_supported: true,
    },
    SlashCommandSpec {
@@ -1191,14 +1191,10 @@ pub enum SlashCommand {
    History {
        count: Option<String>,
    },
-    Lsp {
-        action: Option<String>,
-        target: Option<String>,
-    },
+    Unknown(String),
    Team {
        action: Option<String>,
    },
-    Unknown(String),
 }

 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -1520,9 +1516,6 @@ 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()),
    }))
 }
@@ -5304,6 +5297,60 @@ 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,
@@ -5341,8 +5388,19 @@ pub fn handle_slash_command(
            message: render_slash_command_help(),
            session: session.clone(),
        }),
-        SlashCommand::Status
-        | SlashCommand::Bughunter { .. }
+        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::Commit
        | SlashCommand::Pr { .. }
        | SlashCommand::Issue { .. }
@@ -5353,7 +5411,6 @@ pub fn handle_slash_command(
        | SlashCommand::Model { .. }
        | SlashCommand::Permissions { .. }
        | SlashCommand::Clear { .. }
-        | SlashCommand::Cost
        | SlashCommand::Resume { .. }
        | SlashCommand::Config { .. }
        | SlashCommand::Workspace { .. }
@@ -5361,7 +5418,6 @@ pub fn handle_slash_command(
        | SlashCommand::Memory
        | SlashCommand::Init
        | SlashCommand::Diff
-        | SlashCommand::Version
        | SlashCommand::Export { .. }
        | SlashCommand::Session { .. }
        | SlashCommand::Plugins { .. }
@@ -5408,7 +5464,6 @@ pub fn handle_slash_command(
        | SlashCommand::OutputStyle { .. }
        | SlashCommand::AddDir { .. }
        | SlashCommand::History { .. }
-        | SlashCommand::Lsp { .. }
        | SlashCommand::Team { .. }
        | SlashCommand::Setup
        | SlashCommand::Unknown(_) => None,
@@ -5541,16 +5596,6 @@ 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))
@@ -6211,7 +6256,6 @@ 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()
@@ -6243,7 +6287,6 @@ 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,
@@ -6262,7 +6305,6 @@ 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()
@@ -7224,4 +7266,79 @@ 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);
+    }
 }
@@ -826,7 +826,7 @@ mod tests {
                    "message[{}] is a ToolResult but message[{}] has no ToolUse: {:?}",
                    i,
                    i - 1,
-                    messages[i - 1].blocks
+                    &messages[i - 1].blocks
                );
            }
        }
@@ -164,20 +164,6 @@ 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.
@@ -851,15 +837,6 @@ 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 {
@@ -942,29 +919,6 @@ 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
@@ -1025,20 +979,6 @@ 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;
@@ -1821,51 +1761,6 @@ 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());
@@ -2737,49 +2632,6 @@ 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::{
@@ -4177,151 +4029,4 @@ mod tests {

        fs::remove_dir_all(root).expect("cleanup temp dir");
    }
-
-    #[test]
-    fn subagent_model_reads_camel_case_config_key() {
-        let root = temp_dir();
-        let cwd = root.join("project");
-        let home = root.join("home").join(".claw");
-        fs::create_dir_all(&home).expect("home config dir");
-        fs::create_dir_all(&cwd).expect("project dir");
-        fs::write(
-            home.join("settings.json"),
-            "{\n  \"subagentModel\": \"custom/openclaw\"\n}\n",
-        )
-        .expect("write settings");
-
-        let config = ConfigLoader::new(&cwd, &home)
-            .load()
-            .expect("config should load");
-        assert_eq!(
-            config.subagent_model(),
-            Some("custom/openclaw"),
-            "subagentModel camelCase key should be read end-to-end"
-        );
-
-        fs::remove_dir_all(root).expect("cleanup temp dir");
-    }
-
-    #[test]
-    fn subagent_model_reads_snake_case_config_key() {
-        let root = temp_dir();
-        let cwd = root.join("project");
-        let home = root.join("home").join(".claw");
-        fs::create_dir_all(&home).expect("home config dir");
-        fs::create_dir_all(&cwd).expect("project dir");
-        fs::write(
-            home.join("settings.json"),
-            "{\n  \"subagent_model\": \"qwen3.6-35b-fast\"\n}\n",
-        )
-        .expect("write settings");
-
-        let config = ConfigLoader::new(&cwd, &home)
-            .load()
-            .expect("config should load");
-        assert_eq!(
-            config.subagent_model(),
-            Some("qwen3.6-35b-fast"),
-            "subagent_model snake_case key should be read end-to-end"
-        );
-
-        fs::remove_dir_all(root).expect("cleanup temp dir");
-    }
-
-    #[test]
-    fn subagent_model_blank_value_returns_none() {
-        let root = temp_dir();
-        let cwd = root.join("project");
-        let home = root.join("home").join(".claw");
-        fs::create_dir_all(&home).expect("home config dir");
-        fs::create_dir_all(&cwd).expect("project dir");
-        fs::write(
-            home.join("settings.json"),
-            "{\n  \"subagentModel\": \"  \"\n}\n",
-        )
-        .expect("write settings");
-
-        let config = ConfigLoader::new(&cwd, &home)
-            .load()
-            .expect("config should load");
-        assert_eq!(
-            config.subagent_model(),
-            None,
-            "blank subagentModel should fall back to None"
-        );
-
-        fs::remove_dir_all(root).expect("cleanup temp dir");
-    }
-
-    #[test]
-    fn parallel_and_agent_caps_read_camel_and_snake_case_keys() {
-        let root = temp_dir();
-        let cwd = root.join("project");
-        let home = root.join("home").join(".claw");
-        fs::create_dir_all(&home).expect("home config dir");
-        fs::create_dir_all(&cwd).expect("project dir");
-        fs::write(
-            home.join("settings.json"),
-            "{\n  \"maxParallelToolCalls\": 4,\n  \"max_concurrent_agents\": \"6\"\n}\n",
-        )
-        .expect("write settings");
-
-        let config = ConfigLoader::new(&cwd, &home)
-            .load()
-            .expect("config should load");
-        assert_eq!(
-            config.max_parallel_tool_calls(),
-            Some(4),
-            "maxParallelToolCalls camelCase key should parse"
-        );
-        assert_eq!(
-            config.max_concurrent_agents(),
-            Some(6),
-            "max_concurrent_agents snake_case key should parse numeric strings"
-        );
-
-        fs::remove_dir_all(root).expect("cleanup temp dir");
-    }
-
-    #[test]
-    fn parallel_and_agent_caps_reject_nonpositive_and_malformed() {
-        let root = temp_dir();
-        let cwd = root.join("project");
-        let home = root.join("home").join(".claw");
-        fs::create_dir_all(&home).expect("home config dir");
-        fs::create_dir_all(&cwd).expect("project dir");
-        fs::write(
-            home.join("settings.json"),
-            "{\n  \"maxParallelToolCalls\": 0\n}\n",
-        )
-        .expect("write settings");
-
-        let config = ConfigLoader::new(&cwd, &home)
-            .load()
-            .expect("zero cap should parse as unset");
-        assert_eq!(config.max_parallel_tool_calls(), None);
-        assert_eq!(config.max_concurrent_agents(), None);
-        fs::remove_dir_all(&root).expect("cleanup temp dir");
-
-        let root = temp_dir();
-        let cwd = root.join("project");
-        let home = root.join("home").join(".claw");
-        fs::create_dir_all(&home).expect("home config dir");
-        fs::create_dir_all(&cwd).expect("project dir");
-        fs::write(
-            home.join("settings.json"),
-            "{\n  \"maxParallelToolCalls\": \"lots\"\n}\n",
-        )
-        .expect("write settings");
-
-        let error = ConfigLoader::new(&cwd, &home)
-            .load()
-            .expect_err("non-numeric cap should be a config error");
-        assert!(
-            error.to_string().contains("maxParallelToolCalls"),
-            "error should name the offending key: {error}"
-        );
-
-        fs::remove_dir_all(root).expect("cleanup temp dir");
-    }
 }
@@ -61,40 +61,6 @@ 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.
@@ -120,22 +86,6 @@ 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 {
@@ -190,7 +140,6 @@ pub struct ConversationRuntime<C, T> {
    hook_abort_signal: HookAbortSignal,
    hook_progress_reporter: Option<Box<dyn HookProgressReporter>>,
    session_tracer: Option<SessionTracer>,
-    turn_progress_reporter: Option<Box<dyn TurnProgressReporter>>,
 }

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

@@ -289,11 +237,6 @@ 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(
@@ -477,24 +420,11 @@ where
                break;
            }

-            // 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);
+            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),
@@ -523,157 +453,71 @@ 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,
                    )
                };

-                match permission_outcome {
+                let result_message = match permission_outcome {
                    PermissionOutcome::Allow => {
-                        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 } => {
-                        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),
-                        });
-                    }
-                }
-            }
+                        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);

-            // 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()
+                        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(),
-                    );
-                    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(),
+                            || 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)
+                    }
+                    PermissionOutcome::Deny { reason } => ConversationMessage::tool_result(
+                        tool_use_id,
+                        tool_name,
+                        merge_hook_feedback(pre_hook_result.messages(), reason, true),
                        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);
            }
        }
@@ -67,16 +67,15 @@ pub use compact::{
    get_compact_continuation_message, should_compact, CompactionConfig, CompactionResult,
 };
 pub use config::{
-    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,
+    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,
 };
 pub use config_validate::{
    check_unsupported_format, format_diagnostics, validate_config_file, ConfigDiagnostic,
@@ -84,8 +83,8 @@ pub use config_validate::{
 };
 pub use conversation::{
    auto_compaction_threshold_from_env, ApiClient, ApiRequest, AssistantEvent, AutoCompactionEvent,
-    ConversationRuntime, PromptCacheEvent, RuntimeError, StaticToolExecutor, ToolCall, ToolError,
-    ToolExecutor, ToolResult, TurnProgressReporter, TurnSummary,
+    ConversationRuntime, PromptCacheEvent, RuntimeError, StaticToolExecutor, ToolError,
+    ToolExecutor, TurnSummary,
 };
 pub use file_ops::{
    edit_file, edit_file_in_workspace, glob_search, glob_search_in_workspace, grep_search,
@@ -29,7 +29,7 @@ impl Default for TridentConfig {
 }

 /// Statistics from a Trident compaction run.
-#[derive(Debug, Clone, PartialEq, Eq, Default)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct TridentStats {
    pub superseded_count: usize,
    pub collapsed_chains: usize,
@@ -41,6 +41,21 @@ 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 {
@@ -177,7 +192,7 @@ fn stage1_supersede(messages: &[ConversationMessage]) -> (Vec<ConversationMessag

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

-    for ops in file_ops.values() {
+    for (_path, ops) in &file_ops {
        if ops.len() < 2 {
            continue;
        }
@@ -190,9 +205,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.op_type == FileOp::Write
-                    || op.op_type == FileOp::Edit)
+                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)
                    && op.index < last_write
                {
                    obsolete_indices.insert(op.index);
@@ -310,7 +325,7 @@ fn stage2_collapse(
                    usage: None,
                });
            } else {
-                result.append(&mut buffer);
+                result.extend(buffer.drain(..));
            }
            buffer.clear();
            result.push(msg.clone());
@@ -461,7 +476,7 @@ fn stage3_cluster(
    }

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

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

    #[test]
    fn stage1_removes_obsolete_file_reads() {
@@ -721,7 +736,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}"),
            }]));
@@ -752,9 +767,9 @@ mod tests {
                },
            ]));
            messages.push(ConversationMessage::tool_result(
-                format!("read_{i}"),
+                &format!("read_{i}"),
                "read_file",
-                format!(r#"{{"path":"src/{i}.rs","content":"data {i}"}}"#),
+                &format!(r#"{{"path":"src/{i}.rs","content":"data {i}"}}"#),
                false,
            ));
        }
@@ -14,7 +14,6 @@ api = { path = "../api" }
 commands = { path = "../commands" }
 crossterm = "0.28"
 pulldown-cmark = "0.13"
-once_cell = "1"
 rustyline = "15"
 runtime = { path = "../runtime" }
 plugins = { path = "../plugins" }
@@ -26,15 +25,8 @@ tools = { path = "../tools" }
 log = "0.4"


-[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"
+[lints]
+workspace = true

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

 struct SlashCommandHelper {
@@ -88,19 +86,12 @@ 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);
-        // 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)
-        }
+        Cow::Borrowed(line)
    }

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

@@ -124,18 +115,6 @@ 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(),
@@ -168,18 +147,7 @@ impl LineEditor {
        }

        match self.editor.readline(&self.prompt) {
-            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))
-            }
+            Ok(line) => Ok(ReadOutcome::Submit(line)),
            Err(ReadlineError::Interrupted) => {
                let has_input = !self.current_line().is_empty();
                self.finish_interrupted_read()?;
@@ -249,6 +249,16 @@ 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();
@@ -267,30 +277,7 @@ impl TerminalRenderer {
            );
        }

-        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');
-            }
-        }
+        output
    }

    #[must_use]
@@ -298,6 +285,18 @@ 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,
@@ -310,14 +309,10 @@ 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::ensure_newlines(output, 1);
-                self.start_quote(state, output);
-            }
+            Event::Start(Tag::BlockQuote(..)) => self.start_quote(state, output),
            Event::End(TagEnd::BlockQuote(..)) => {
                state.quote = state.quote.saturating_sub(1);
                output.push('\n');
@@ -330,7 +325,6 @@ 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,
@@ -343,7 +337,6 @@ 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"),
@@ -367,10 +360,7 @@ impl TerminalRenderer {
                    format!("{}", format!("`{code}`").with(self.color_theme.inline_code));
                state.append_raw(output, &rendered);
            }
-            Event::Rule => {
-                Self::ensure_newlines(output, 1);
-                output.push_str("---\n");
-            }
+            Event::Rule => output.push_str("---\n"),
            Event::Text(text) => {
                self.push_text(text.as_ref(), state, output, code_buffer, *in_code_block);
            }
@@ -415,10 +405,7 @@ impl TerminalRenderer {
                );
                state.append_raw(output, &rendered);
            }
-            Event::Start(Tag::Table(..)) => {
-                Self::ensure_newlines(output, 1);
-                state.table = Some(TableState::default());
-            }
+            Event::Start(Tag::Table(..)) => state.table = Some(TableState::default()),
            Event::End(TagEnd::Table) => {
                if let Some(table) = state.table.take() {
                    output.push_str(&self.render_table(&table));
@@ -632,21 +619,9 @@ impl TerminalRenderer {
    }
 }

-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Default, 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 {
@@ -656,40 +631,7 @@ impl MarkdownStreamState {
        let split = find_stream_safe_boundary(&self.pending)?;
        let ready = self.pending[..split].to_string();
        self.pending.drain(..split);
-
-        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)
+        Some(renderer.markdown_to_ansi_stream(&ready))
    }

    #[must_use]
@@ -699,26 +641,7 @@ impl MarkdownStreamState {
            None
        } else {
            let pending = std::mem::take(&mut self.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)
+            Some(renderer.markdown_to_ansi(&pending))
        }
    }
 }
@@ -912,11 +835,6 @@ 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;
@@ -1156,6 +1074,34 @@ 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();
@@ -1171,189 +1117,4 @@ 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
-            );
-        }
-    }
 }
@@ -9,7 +9,7 @@ const PROVIDERS: &[(&str, &str, &str)] = &[
    ("2", "xAI / Grok", "xai"),
    ("3", "OpenAI", "openai"),
    ("4", "DashScope (Qwen/Kimi)", "dashscope"),
-    ("5", "Custom (OpenAI-compat)", "openai"),
+    ("5", "Custom (OpenAI-compat)", "custom-openai"),
 ];

 const PROVIDER_MODELS: &[(&str, &[&str])] = &[
@@ -27,6 +27,8 @@ const DEFAULT_BASE_URLS: &[(&str, &str)] = &[
        "dashscope",
        "https://dashscope.aliyuncs.com/compatible-mode/v1",
    ),
+    // Custom OpenAI has no default; user must supply.
+    ("custom-openai", ""),
 ];

 const API_KEY_ENV_VARS: &[(&str, &str)] = &[
@@ -34,6 +36,7 @@ const API_KEY_ENV_VARS: &[(&str, &str)] = &[
    ("xai", "XAI_API_KEY"),
    ("openai", "OPENAI_API_KEY"),
    ("dashscope", "DASHSCOPE_API_KEY"),
+    ("custom-openai", "CLAWCUSTOMOPENAI_API_KEY"),
 ];

 pub fn run_setup_wizard() -> Result<(), Box<dyn std::error::Error>> {
@@ -177,6 +180,7 @@ fn prompt_base_url(
        "xai" => "XAI_BASE_URL",
        "openai" => "OPENAI_BASE_URL",
        "dashscope" => "DASHSCOPE_BASE_URL",
+        "custom-openai" => "CLAWCUSTOMOPENAI_BASE_URL",
        _ => "BASE_URL",
    };
    let env_set = std::env::var(env_var).ok().is_some_and(|v| !v.is_empty());
@@ -214,7 +218,11 @@ fn prompt_model(
    if !aliases.is_empty() {
        println!("    Common: {}", aliases.join(", "));
    }
-    println!("    Or enter any model name (e.g. openai/gpt-4.1-mini for custom routing)");
+    if kind == "custom-openai" {
+        println!("    Or enter any model name (e.g. custom/gpt-4.1 for custom routing)");
+    } else {
+        println!("    Or enter any model name (e.g. openai/gpt-4.1-mini for custom routing)");
+    }

    let input = read_line(&format!("  Model [{current_model}]: "))?;
    if input.trim().is_empty() {
@@ -1,6 +1,6 @@
 [package]
 name = "sdk"
-version = "0.1.4"
+version = "0.1.0"
 edition = "2021"
 publish = false

@@ -1,118 +0,0 @@
-# Multi-Tool Execution & Sub-Agent Delegation
-
-Two complementary features that dramatically reduce latency and token usage when the model needs to perform multiple operations or gather context.
-
-## Feature 1: Parallel Tool Execution
-
-When the model returns multiple tool_use blocks in a single response, read-only tools now execute concurrently instead of sequentially.
-
-### How it works
-
-The `run_turn` loop is refactored into 3 phases:
-
-1. **Pre-hooks + permission checks** (sequential — hooks may mutate state)
-2. **Tool execution** (batch — parallel for read-only tools via `std::thread::scope`)
-3. **Post-hooks + session updates** (sequential — preserves original ordering)
-
-### Parallel-safe tools
-
-These tools are safe to run concurrently because they only read state and dispatch through the stateless tool registry:
-
- `read_file`, `glob_search`, `grep_search`
- `WebFetch`, `WebSearch`
- `ToolSearch`, `Skill`
- `LSP`
- `GitStatus`, `GitDiff`, `GitLog`, `GitShow`, `GitBlame`
-
-### Sequential-only tools
-
-Tools that require `&mut self` or have side effects continue to run one at a time:
-
- `bash`, `write_file`, `edit_file` (side effects)
- `MCP`, `McpAuth`, `RemoteTrigger` (network state)
- `Agent`, `TaskCreate`, `WorkerCreate` (stateful)
- `NotebookEdit`, `REPL`, `PowerShell` (side effects)
-
-### Safety guarantees
-
- Pre/post hooks always run sequentially
- Permission checks complete before any tool executes
- Tool results are pushed to the session in the original model order
- Falls back to sequential for single-tool batches
- Thread scopes ensure all parallel work completes before `execute_batch` returns
-
-### Impact
-
-For a response with 5 `read_file` calls: **~5x faster** execution. The main model still sees all results in order.
-
---
-
-## Feature 2: SubAgent Delegation
-
-A `SubAgent` tool that lets the main model delegate multi-step tasks to a fast sub-agent. The sub-agent runs autonomously with its own `ConversationRuntime`, making multiple tool calls without round-tripping through the main model.
-
-### Tool parameters
-
-| Parameter | Type | Required | Description |
-|-----------|------|----------|-------------|
-| `prompt` | string | yes | Task description for the sub-agent |
-| `task_type` | string | no | `Explore` (default), `Plan`, or `Verify` |
-| `model` | string | no | Override the sub-agent model |
-
-### Task types
-
-| Type | Available tools | Use for |
-|------|----------------|---------|
-| `Explore` | read_file, glob_search, grep_search, WebFetch, WebSearch, ToolSearch, StructuredOutput | Searching code, reading files, gathering context |
-| `Plan` | Explore + TodoWrite | Planning approaches with structured todo output |
-| `Verify` | Plan + bash | Running tests, checking builds, verifying changes |
-
-### Configuration
-
-Set the sub-agent model in `~/.claw/settings.json`:
-
-```json
-{
-  "model": "openai/glm-5.1-fast",
-  "subagentModel": "openai/qwen3.6-35b-fast"
-}
-```
-
-If `subagentModel` is not set, the sub-agent uses the same model as the main session (or the `model` override parameter on the tool call).
-
-### Example
-
-Main model prompt: "Find all Rust files that import `ConversationRuntime` and list their paths"
-
-Without SubAgent: 5–10 sequential tool calls (grep → read each file → summarize)
-With SubAgent: 1 SubAgent call → sub-agent does all the work autonomously → returns summary
-
-**Result**: ~10x fewer tokens consumed by the main model, faster overall completion.
-
-### Architecture
-
-The sub-agent reuses the same building blocks as the existing `Agent` tool:
-
- `ProviderRuntimeClient` — API client with fallback chain
- `SubagentToolExecutor` — filtered tool access with permission enforcement
- `ConversationRuntime` — full conversation loop with hooks and compaction
- `agent_permission_policy()` — auto-approve read-only, deny write tools
-
-Key differences from the `Agent` tool:
- **Synchronous** — blocks until complete, returns result directly
- **Lighter** — fewer default tools, focused on the task type
- **Configurable model** — uses `subagentModel` or the tool's `model` param
- **Structured output** — returns `result`, `tool_calls`, and `iterations`
-
---
-
-## Changed files
-
-| File | Changes |
-|------|---------|
-| `rust/crates/runtime/src/conversation.rs` | `ToolCall`, `ToolResult` types; `execute_batch` on `ToolExecutor`; 3-phase `run_turn` |
-| `rust/crates/runtime/src/lib.rs` | Exports for `ToolCall`, `ToolResult` |
-| `rust/crates/runtime/src/config.rs` | `subagent_model` field, `parse_optional_subagent_model()`, accessor |
-| `rust/crates/runtime/src/config_validate.rs` | `subagentModel` field spec |
-| `rust/crates/rusty-claude-cli/src/main.rs` | `CliToolExecutor::execute_batch` with parallel-safe classification |
-| `rust/crates/tools/src/lib.rs` | `SubAgent` tool spec, `SubAgentInput`, `run_sub_agent()`, `load_subagent_model_from_config()`, `build_sub_agent_system_prompt()` |
@@ -116,8 +116,6 @@ mod tests {
            lane_events: vec![],
            derived_state: "working".to_string(),
            current_blocker: None,
-            team_id: None,
-            task_id: None,
            error: None,
        }
    }
				`@@ -1 +0,0 @@`
				{"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"}]}}
				`@@ -1 +0,0 @@`
				`{"pid":1,"start_time":"unknown","token":"8389ee99-c41c-47dd-9615-e76a5268967c","owner_host_id":"7af2fb0e8e37bd543e3d0bda6f205b56f30077b5a9b77e83208e94ae441315ac","released":true}`
				`@@ -1 +0,0 @@`
				`{"effectMarker":"7b92c148-d616-4eb5-95e8-4e95084bebe9","incarnation":"linux:159085489","pid":177576}`