chore: remove accidentally committed .gjc session state and ignore .gjc/

.github/workflows/release.yml

@@ -57,7 +57,7 @@ jobs:
           mkdir -p dist
           cp "target/release/${{ matrix.bin }}" "dist/${{ matrix.artifact_name }}"
           chmod +x "dist/${{ matrix.artifact_name }}"
-          (cd dist && (sha256sum "${{ matrix.artifact_name }}" 2>/dev/null || shasum -a 256 "${{ matrix.artifact_name }}") > "${{ matrix.artifact_name }}.sha256")
+          (cd dist && sha256sum "${{ matrix.artifact_name }}" > "${{ matrix.artifact_name }}.sha256")
 
       - name: Upload workflow artifact
         uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02

.gitignore

@@ -15,4 +15,3 @@ status-help.txt
 .port_sessions/
 # Local agent session state
 .gjc/
-.claude/

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

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

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

@@ -1 +0,0 @@
-{"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

@@ -1 +0,0 @@
-{"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

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

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

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

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

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

rust/Cargo.lock

@@ -118,15 +118,15 @@ checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
 
 [[package]]
 name = "aspect-core"
-version = "0.1.2"
+version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e94aecae4a10eea63983b608beb48998578925d0660796140d69d8e8276f215"
+checksum = "70188b9bf884266a6c7117e30af44f38229bc5ac56916bd16512b3e49f90fe20"
 
 [[package]]
 name = "aspect-macros"
-version = "0.1.2"
+version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5d56334ff035ccdeed6b6c159b9089ae1baba29f93eb6fa8bd89312e9fa3f136"
+checksum = "176e7db9b6a7bb4f117b8d97054d2d5a7bdc43b95c19c15c751fb8dcb9bc8a5c"
 dependencies = [
  "aspect-core",
  "proc-macro2",
@@ -136,9 +136,9 @@ dependencies = [
 
 [[package]]
 name = "aspect-std"
-version = "0.1.2"
+version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "059c997171f851dcd36d5eb14cf9ec831884ecafa2b753629379ff4b71971008"
+checksum = "ba7d130884fda30ec0acabcadc8f4711267d1cc21edc8f85283e91a011d699fa"
 dependencies = [
  "aspect-core",
  "log",
@@ -591,7 +591,7 @@ dependencies = [
  "clap",
  "criterion-plot",
  "is-terminal",
- "itertools 0.10.5",
+ "itertools",
  "num-traits",
  "once_cell",
  "oorandom",
@@ -612,7 +612,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1"
 dependencies = [
  "cast",
- "itertools 0.10.5",
+ "itertools",
 ]
 
 [[package]]
@@ -1417,15 +1417,6 @@ dependencies = [
  "either",
 ]
 
-[[package]]
-name = "itertools"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
-dependencies = [
- "either",
-]
-
 [[package]]
 name = "itoa"
 version = "1.0.18"
@@ -1803,7 +1794,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8a56d757972c98b346a9b766e3f02746cde6dd1cd1d1d563472929fdd74bec4d"
 dependencies = [
  "anyhow",
- "itertools 0.13.0",
+ "itertools",
  "proc-macro2",
  "quote",
  "syn",
@@ -2201,9 +2192,9 @@ dependencies = [
 
 [[package]]
 name = "rustls-native-certs"
-version = "0.8.4"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dab5152771c58876a2146916e53e35057e1a4dfa2b9df0f0305b07f611fdea4d"
+checksum = "612460d5f7bea540c490b2b6395d8e34a953e52b491accd6c86c8164c5932a63"
 dependencies = [
  "openssl-probe",
  "rustls-pki-types",
@@ -2232,9 +2223,9 @@ dependencies = [
 
 [[package]]
 name = "rustls-webpki"
-version = "0.103.10"
+version = "0.103.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df33b2b81ac578cabaf06b89b0631153a3f416b0a886e8a7a1707fb51abbd1ef"
+checksum = "61c429a8649f110dddef65e2a5ad240f747e85f7758a6bccc7e5777bd33f756e"
 dependencies = [
  "ring",
  "rustls-pki-types",
@@ -2256,7 +2247,6 @@ dependencies = [
  "crossterm",
  "log",
  "mock-anthropic-service",
- "once_cell",
  "plugins",
  "pulldown-cmark",
  "runtime",
@@ -2992,9 +2982,9 @@ checksum = "9629274872b2bfaf8d66f5f15725007f635594914870f65218920345aa11aa8c"
 
 [[package]]
 name = "unicode-width"
-version = "0.2.0"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fc81956842c57dac11422a97c3b8195a1ff727f06e85c84ed2e8aa277c9a0fd"
+checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
 
 [[package]]
 name = "untrusted"

rust/crates/api/src/error.rs

@@ -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 {

rust/crates/api/src/lib.rs

@@ -28,9 +28,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::{

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

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

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

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) {
+    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)?;

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("[on|off|status]"),
+        argument_hint: Some("[list|create|delete]"),
         resume_supported: true,
     },
     SlashCommandSpec {
@@ -1188,14 +1188,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)]
@@ -1513,9 +1509,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()),
     }))
 }
@@ -5400,7 +5393,6 @@ pub fn handle_slash_command(
         | SlashCommand::OutputStyle { .. }
         | SlashCommand::AddDir { .. }
         | SlashCommand::History { .. }
-        | SlashCommand::Lsp { .. }
         | SlashCommand::Team { .. }
         | SlashCommand::Setup
         | SlashCommand::Unknown(_) => None,
@@ -5533,16 +5525,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))

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,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.
@@ -846,15 +832,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 {
@@ -937,29 +914,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
@@ -1020,20 +974,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;
@@ -1816,51 +1756,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());
@@ -2732,49 +2627,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::{
@@ -4136,151 +3988,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");
-    }
 }

rust/crates/runtime/src/conversation.rs

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

rust/crates/runtime/src/json.rs

@@ -49,10 +49,10 @@ impl JsonValue {
                     .join(",");
                 format!("[{rendered}]")
             }
-            Self::Object(map) => {
-                let rendered = map
+            Self::Object(entries) => {
+                let rendered = entries
                     .iter()
-                    .map(|(k, v)| format!("{}:{}", render_string(k), v.render()))
+                    .map(|(key, value)| format!("{}:{}", render_string(key), value.render()))
                     .collect::<Vec<_>>()
                     .join(",");
                 format!("{{{rendered}}}")
@@ -60,26 +60,21 @@ impl JsonValue {
         }
     }
 
-    #[must_use]
-    pub fn as_bool(&self) -> Option<bool> {
-        match self {
-            Self::Bool(b) => Some(*b),
-            _ => None,
+    pub fn parse(source: &str) -> Result<Self, JsonError> {
+        let mut parser = Parser::new(source);
+        let value = parser.parse_value()?;
+        parser.skip_whitespace();
+        if parser.is_eof() {
+            Ok(value)
+        } else {
+            Err(JsonError::new("unexpected trailing content"))
         }
     }
 
     #[must_use]
-    pub fn as_i64(&self) -> Option<i64> {
+    pub fn as_object(&self) -> Option<&BTreeMap<String, JsonValue>> {
         match self {
-            Self::Number(n) => Some(*n),
-            _ => None,
-        }
-    }
-
-    #[must_use]
-    pub fn as_str(&self) -> Option<&str> {
-        match self {
-            Self::String(s) => Some(s),
+            Self::Object(value) => Some(value),
             _ => None,
         }
     }
@@ -87,354 +82,273 @@ impl JsonValue {
     #[must_use]
     pub fn as_array(&self) -> Option<&[JsonValue]> {
         match self {
-            Self::Array(a) => Some(a),
+            Self::Array(value) => Some(value),
             _ => None,
         }
     }
 
     #[must_use]
-    pub fn as_object(&self) -> Option<&BTreeMap<String, JsonValue>> {
+    pub fn as_str(&self) -> Option<&str> {
         match self {
-            Self::Object(o) => Some(o),
+            Self::String(value) => Some(value),
             _ => None,
         }
     }
 
-    pub fn parse(input: &str) -> Result<Self, JsonError> {
-        let mut chars = input.trim().chars().peekable();
-        let value = parse_value(&mut chars)?;
-        if chars.peek().is_some() {
-            return Err(JsonError::new("trailing content"));
+    #[must_use]
+    pub fn as_bool(&self) -> Option<bool> {
+        match self {
+            Self::Bool(value) => Some(*value),
+            _ => None,
+        }
+    }
+
+    #[must_use]
+    pub fn as_i64(&self) -> Option<i64> {
+        match self {
+            Self::Number(value) => Some(*value),
+            _ => None,
+        }
+    }
+}
+
+fn render_string(value: &str) -> String {
+    let mut rendered = String::with_capacity(value.len() + 2);
+    rendered.push('"');
+    for ch in value.chars() {
+        match ch {
+            '"' => rendered.push_str("\\\""),
+            '\\' => rendered.push_str("\\\\"),
+            '\n' => rendered.push_str("\\n"),
+            '\r' => rendered.push_str("\\r"),
+            '\t' => rendered.push_str("\\t"),
+            '\u{08}' => rendered.push_str("\\b"),
+            '\u{0C}' => rendered.push_str("\\f"),
+            control if control.is_control() => push_unicode_escape(&mut rendered, control),
+            plain => rendered.push(plain),
+        }
+    }
+    rendered.push('"');
+    rendered
+}
+
+fn push_unicode_escape(rendered: &mut String, control: char) {
+    const HEX: &[u8; 16] = b"0123456789abcdef";
+
+    rendered.push_str("\\u");
+    let value = u32::from(control);
+    for shift in [12_u32, 8, 4, 0] {
+        let nibble = ((value >> shift) & 0xF) as usize;
+        rendered.push(char::from(HEX[nibble]));
+    }
+}
+
+struct Parser<'a> {
+    chars: Vec<char>,
+    index: usize,
+    _source: &'a str,
+}
+
+impl<'a> Parser<'a> {
+    fn new(source: &'a str) -> Self {
+        Self {
+            chars: source.chars().collect(),
+            index: 0,
+            _source: source,
+        }
+    }
+
+    fn parse_value(&mut self) -> Result<JsonValue, JsonError> {
+        self.skip_whitespace();
+        match self.peek() {
+            Some('n') => self.parse_literal("null", JsonValue::Null),
+            Some('t') => self.parse_literal("true", JsonValue::Bool(true)),
+            Some('f') => self.parse_literal("false", JsonValue::Bool(false)),
+            Some('"') => self.parse_string().map(JsonValue::String),
+            Some('[') => self.parse_array(),
+            Some('{') => self.parse_object(),
+            Some('-' | '0'..='9') => self.parse_number().map(JsonValue::Number),
+            Some(other) => Err(JsonError::new(format!("unexpected character: {other}"))),
+            None => Err(JsonError::new("unexpected end of input")),
+        }
+    }
+
+    fn parse_literal(&mut self, expected: &str, value: JsonValue) -> Result<JsonValue, JsonError> {
+        for expected_char in expected.chars() {
+            if self.next() != Some(expected_char) {
+                return Err(JsonError::new(format!(
+                    "invalid literal: expected {expected}"
+                )));
+            }
         }
         Ok(value)
     }
-}
 
-fn parse_value(chars: &mut std::iter::Peekable<std::str::Chars>) -> Result<JsonValue, JsonError> {
-    match chars.peek() {
-        Some('n') => parse_null(chars),
-        Some('t') | Some('f') => parse_bool(chars),
-        Some('"') => parse_string(chars).map(JsonValue::String),
-        Some('[') => parse_array(chars),
-        Some('{') => parse_object(chars),
-        Some('-') | Some('0'..='9') => parse_number(chars),
-        Some(c) => Err(JsonError::new(format!("unexpected char: {c}"))),
-        None => Err(JsonError::new("empty input")),
-    }
-}
-
-fn parse_null(chars: &mut std::iter::Peekable<std::str::Chars>) -> Result<JsonValue, JsonError> {
-    if consume_literal(chars, "null") {
-        Ok(JsonValue::Null)
-    } else {
-        Err(JsonError::new("invalid null"))
-    }
-}
-
-fn parse_bool(chars: &mut std::iter::Peekable<std::str::Chars>) -> Result<JsonValue, JsonError> {
-    if consume_literal(chars, "true") {
-        return Ok(JsonValue::Bool(true));
-    }
-    if consume_literal(chars, "false") {
-        return Ok(JsonValue::Bool(false));
-    }
-    Err(JsonError::new("invalid bool"))
-}
-
-fn parse_string(chars: &mut std::iter::Peekable<std::str::Chars>) -> Result<String, JsonError> {
-    if chars.next() != Some('"') {
-        return Err(JsonError::new("expected opening quote"));
+    fn parse_string(&mut self) -> Result<String, JsonError> {
+        self.expect('"')?;
+        let mut value = String::new();
+        while let Some(ch) = self.next() {
+            match ch {
+                '"' => return Ok(value),
+                '\\' => value.push(self.parse_escape()?),
+                plain => value.push(plain),
+            }
+        }
+        Err(JsonError::new("unterminated string"))
     }
 
-    let mut result = String::new();
-    loop {
-        match chars.next() {
-            None => return Err(JsonError::new("unterminated string")),
-            Some('"') => return Ok(result),
-            Some('\\') => match chars.next() {
-                Some('"') => result.push('"'),
-                Some('\\') => result.push('\\'),
-                Some('/') => result.push('/'),
-                Some('b') => result.push('\u{08}'),
-                Some('f') => result.push('\u{0C}'),
-                Some('n') => result.push('\n'),
-                Some('r') => result.push('\r'),
-                Some('t') => result.push('\t'),
-                Some('u') => {
-                    let mut hex = String::new();
-                    for _ in 0..4 {
-                        match chars.next() {
-                            Some(c @ '0'..='9') | Some(c @ 'a'..='f') | Some(c @ 'A'..='F') => {
-                                hex.push(c)
-                            }
-                            _ => return Err(JsonError::new("invalid unicode escape")),
-                        }
-                    }
-                    let code = u32::from_str_radix(&hex, 16)
-                        .map_err(|_| JsonError::new("invalid hex code"))?;
-                    if (0xD800..=0xDFFF).contains(&code) {
-                        return Err(JsonError::new("surrogate not allowed"));
-                    }
-                    result.push(
-                        char::from_u32(code).ok_or_else(|| JsonError::new("invalid codepoint"))?,
-                    );
-                }
-                _ => return Err(JsonError::new("invalid escape")),
-            },
-            Some(c) => result.push(c),
+    fn parse_escape(&mut self) -> Result<char, JsonError> {
+        match self.next() {
+            Some('"') => Ok('"'),
+            Some('\\') => Ok('\\'),
+            Some('/') => Ok('/'),
+            Some('b') => Ok('\u{08}'),
+            Some('f') => Ok('\u{0C}'),
+            Some('n') => Ok('\n'),
+            Some('r') => Ok('\r'),
+            Some('t') => Ok('\t'),
+            Some('u') => self.parse_unicode_escape(),
+            Some(other) => Err(JsonError::new(format!("invalid escape sequence: {other}"))),
+            None => Err(JsonError::new("unexpected end of input in escape sequence")),
         }
     }
-}
 
-fn parse_number(chars: &mut std::iter::Peekable<std::str::Chars>) -> Result<JsonValue, JsonError> {
-    let mut num_str = String::new();
-
-    if chars.peek() == Some(&'-') {
-        num_str.push(chars.next().unwrap());
+    fn parse_unicode_escape(&mut self) -> Result<char, JsonError> {
+        let mut value = 0_u32;
+        for _ in 0..4 {
+            let Some(ch) = self.next() else {
+                return Err(JsonError::new("unexpected end of input in unicode escape"));
+            };
+            value = (value << 4)
+                | ch.to_digit(16)
+                    .ok_or_else(|| JsonError::new("invalid unicode escape"))?;
+        }
+        char::from_u32(value).ok_or_else(|| JsonError::new("invalid unicode scalar value"))
     }
 
-    while let Some(&c) = chars.peek() {
-        if c.is_ascii_digit() {
-            num_str.push(chars.next().unwrap());
+    fn parse_array(&mut self) -> Result<JsonValue, JsonError> {
+        self.expect('[')?;
+        let mut values = Vec::new();
+        loop {
+            self.skip_whitespace();
+            if self.try_consume(']') {
+                break;
+            }
+            values.push(self.parse_value()?);
+            self.skip_whitespace();
+            if self.try_consume(']') {
+                break;
+            }
+            self.expect(',')?;
+        }
+        Ok(JsonValue::Array(values))
+    }
+
+    fn parse_object(&mut self) -> Result<JsonValue, JsonError> {
+        self.expect('{')?;
+        let mut entries = BTreeMap::new();
+        loop {
+            self.skip_whitespace();
+            if self.try_consume('}') {
+                break;
+            }
+            let key = self.parse_string()?;
+            self.skip_whitespace();
+            self.expect(':')?;
+            let value = self.parse_value()?;
+            entries.insert(key, value);
+            self.skip_whitespace();
+            if self.try_consume('}') {
+                break;
+            }
+            self.expect(',')?;
+        }
+        Ok(JsonValue::Object(entries))
+    }
+
+    fn parse_number(&mut self) -> Result<i64, JsonError> {
+        let mut value = String::new();
+        if self.try_consume('-') {
+            value.push('-');
+        }
+
+        while let Some(ch @ '0'..='9') = self.peek() {
+            value.push(ch);
+            self.index += 1;
+        }
+
+        if value.is_empty() || value == "-" {
+            return Err(JsonError::new("invalid number"));
+        }
+
+        value
+            .parse::<i64>()
+            .map_err(|_| JsonError::new("number out of range"))
+    }
+
+    fn expect(&mut self, expected: char) -> Result<(), JsonError> {
+        match self.next() {
+            Some(actual) if actual == expected => Ok(()),
+            Some(actual) => Err(JsonError::new(format!(
+                "expected '{expected}', found '{actual}'"
+            ))),
+            None => Err(JsonError::new(format!(
+                "expected '{expected}', found end of input"
+            ))),
+        }
+    }
+
+    fn try_consume(&mut self, expected: char) -> bool {
+        if self.peek() == Some(expected) {
+            self.index += 1;
+            true
         } else {
-            break;
+            false
         }
     }
 
-    if num_str.is_empty() || num_str == "-" {
-        return Err(JsonError::new("invalid number"));
-    }
-
-    num_str
-        .parse::<i64>()
-        .map(JsonValue::Number)
-        .map_err(|_| JsonError::new("number out of range"))
-}
-
-fn parse_array(chars: &mut std::iter::Peekable<std::str::Chars>) -> Result<JsonValue, JsonError> {
-    if chars.next() != Some('[') {
-        return Err(JsonError::new("expected ["));
-    }
-
-    let mut values = Vec::new();
-
-    skip_whitespace(chars);
-    if chars.peek() == Some(&']') {
-        chars.next();
-        return Ok(JsonValue::Array(values));
-    }
-
-    loop {
-        skip_whitespace(chars);
-        values.push(parse_value(chars)?);
-        skip_whitespace(chars);
-
-        match chars.peek() {
-            Some(',') => {
-                chars.next();
-            }
-            Some(']') => {
-                chars.next();
-                return Ok(JsonValue::Array(values));
-            }
-            _ => return Err(JsonError::new("expected , or ]")),
+    fn skip_whitespace(&mut self) {
+        while matches!(self.peek(), Some(' ' | '\n' | '\r' | '\t')) {
+            self.index += 1;
         }
     }
-}
 
-fn parse_object(chars: &mut std::iter::Peekable<std::str::Chars>) -> Result<JsonValue, JsonError> {
-    if chars.next() != Some('{') {
-        return Err(JsonError::new("expected {"));
+    fn peek(&self) -> Option<char> {
+        self.chars.get(self.index).copied()
     }
 
-    let mut map = BTreeMap::new();
-
-    skip_whitespace(chars);
-    if chars.peek() == Some(&'}') {
-        chars.next();
-        return Ok(JsonValue::Object(map));
+    fn next(&mut self) -> Option<char> {
+        let ch = self.peek()?;
+        self.index += 1;
+        Some(ch)
     }
 
-    loop {
-        skip_whitespace(chars);
-
-        if chars.peek() != Some(&'"') {
-            return Err(JsonError::new("expected key string"));
-        }
-        let key = parse_string(chars)?;
-
-        skip_whitespace(chars);
-        if chars.next() != Some(':') {
-            return Err(JsonError::new("expected :"));
-        }
-
-        skip_whitespace(chars);
-        let value = parse_value(chars)?;
-        map.insert(key, value);
-
-        skip_whitespace(chars);
-        match chars.peek() {
-            Some(',') => {
-                chars.next();
-            }
-            Some('}') => {
-                chars.next();
-                return Ok(JsonValue::Object(map));
-            }
-            _ => return Err(JsonError::new("expected , or }")),
-        }
+    fn is_eof(&self) -> bool {
+        self.index >= self.chars.len()
     }
 }
 
-fn consume_literal(chars: &mut std::iter::Peekable<std::str::Chars>, literal: &str) -> bool {
-    let remaining: String = chars.clone().collect();
-    if remaining.starts_with(literal) {
-        for _ in literal.chars() {
-            chars.next();
-        }
-        true
-    } else {
-        false
-    }
-}
-
-fn skip_whitespace(chars: &mut std::iter::Peekable<std::str::Chars>) {
-    while let Some(&c) = chars.peek() {
-        if c.is_whitespace() {
-            chars.next();
-        } else {
-            break;
-        }
-    }
-}
-
-fn render_string(s: &str) -> String {
-    let mut result = String::from('"');
-    for c in s.chars() {
-        match c {
-            '"' => result.push_str("\\\""),
-            '\\' => result.push_str("\\\\"),
-            '\n' => result.push_str("\\n"),
-            '\r' => result.push_str("\\r"),
-            '\t' => result.push_str("\\t"),
-            '\u{08}' => result.push_str("\\b"),
-            '\u{0C}' => result.push_str("\\f"),
-            c if c.is_control() => {
-                let code = c as u32;
-                result.push_str(&format!("\\u{code:04x}"));
-            }
-            c => result.push(c),
-        }
-    }
-    result.push('"');
-    result
-}
-
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use super::{render_string, JsonValue};
+    use std::collections::BTreeMap;
 
     #[test]
-    fn renders_primitive_values() {
-        assert_eq!(JsonValue::Null.render(), "null");
-        assert_eq!(JsonValue::Bool(true).render(), "true");
-        assert_eq!(JsonValue::Bool(false).render(), "false");
-        assert_eq!(JsonValue::Number(42).render(), "42");
-        assert_eq!(JsonValue::Number(-7).render(), "-7");
-        assert_eq!(JsonValue::String("hi".to_string()).render(), "\"hi\"");
-    }
-
-    #[test]
-    fn renders_arrays_and_objects_with_sorted_keys() {
-        assert_eq!(JsonValue::Array(Vec::new()).render(), "[]");
-        assert_eq!(
-            JsonValue::Array(vec![JsonValue::Number(1), JsonValue::Number(2)]).render(),
-            "[1,2]"
-        );
-        assert_eq!(JsonValue::Object(BTreeMap::new()).render(), "{}");
-
+    fn renders_and_parses_json_values() {
         let mut object = BTreeMap::new();
-        object.insert("b".to_string(), JsonValue::Bool(false));
-        object.insert("a".to_string(), JsonValue::Number(1));
-        // A BTreeMap iterates keys in sorted order, so object rendering is
-        // deterministic regardless of insertion order.
-        assert_eq!(JsonValue::Object(object).render(), "{\"a\":1,\"b\":false}");
-    }
-
-    #[test]
-    fn render_string_escapes_quotes_backslashes_and_other_controls() {
-        // Backslash and double-quote are backslash-escaped.
-        assert_eq!(render_string("\"\\"), "\"\\\"\\\\\"");
-        // Carriage return has a dedicated short escape.
-        assert_eq!(render_string("\r"), "\"\\r\"");
-        // Other control characters fall back to the \uXXXX form (U+0001 here).
-        assert_eq!(render_string("\u{1}"), "\"\\u0001\"");
-    }
-
-    #[test]
-    fn parses_primitive_values() {
-        assert_eq!(
-            JsonValue::parse("null").expect("null parses"),
-            JsonValue::Null
-        );
-        assert_eq!(
-            JsonValue::parse("true").expect("true parses"),
-            JsonValue::Bool(true)
-        );
-        assert_eq!(
-            JsonValue::parse("false").expect("false parses"),
-            JsonValue::Bool(false)
-        );
-        assert_eq!(
-            JsonValue::parse("\"hello\"").expect("string parses"),
-            JsonValue::String("hello".to_string())
-        );
-    }
-
-    #[test]
-    fn parses_signed_integers_and_ignores_surrounding_whitespace() {
-        assert_eq!(
-            JsonValue::parse("-42").expect("negative parses").as_i64(),
-            Some(-42)
-        );
-        assert_eq!(
-            JsonValue::parse("  123  ").expect("padded parses").as_i64(),
-            Some(123)
-        );
-    }
-
-    #[test]
-    fn parses_nested_arrays_and_objects() {
-        let value =
-            JsonValue::parse("{\"nums\": [1, 2], \"flag\": true}").expect("nested json parses");
-        let object = value.as_object().expect("top level is an object");
-
-        assert_eq!(object.len(), 2);
-
-        let nums = object
-            .get("nums")
-            .and_then(JsonValue::as_array)
-            .expect("nums is an array");
-        assert_eq!(nums.len(), 2);
-        assert_eq!(nums[0].as_i64(), Some(1));
-
-        assert_eq!(object.get("flag").and_then(JsonValue::as_bool), Some(true));
-    }
-
-    #[test]
-    fn round_trips_rendered_values_through_the_parser() {
-        let mut object = BTreeMap::new();
-        object.insert("name".to_string(), JsonValue::String("clawi".to_string()));
-        object.insert("count".to_string(), JsonValue::Number(-3));
+        object.insert("flag".to_string(), JsonValue::Bool(true));
         object.insert(
-            "tags".to_string(),
-            JsonValue::Array(vec![JsonValue::Bool(true), JsonValue::Null]),
+            "items".to_string(),
+            JsonValue::Array(vec![
+                JsonValue::Number(4),
+                JsonValue::String("ok".to_string()),
+            ]),
         );
-        let original = JsonValue::Object(object);
 
-        let reparsed = JsonValue::parse(&original.render()).expect("rendered json should re-parse");
+        let rendered = JsonValue::Object(object).render();
+        let parsed = JsonValue::parse(&rendered).expect("json should parse");
 
-        assert_eq!(reparsed, original);
+        assert_eq!(parsed.as_object().expect("object").len(), 2);
     }
 
     #[test]
@@ -519,7 +433,6 @@ mod tests {
         object.insert("a\nb".to_string(), JsonValue::String("c\td".to_string()));
         let original = JsonValue::Object(object);
         let reparsed = JsonValue::parse(&original.render()).expect("escaped key re-parses");
-
         assert_eq!(reparsed, original);
     }
 
@@ -558,37 +471,4 @@ mod tests {
             "i64::MIN - 1"
         );
     }
-
-    #[test]
-    fn parse_rejects_malformed_input() {
-        assert!(JsonValue::parse("").is_err(), "empty input");
-        assert!(JsonValue::parse("nul").is_err(), "truncated literal");
-        assert!(JsonValue::parse("true false").is_err(), "trailing content");
-        assert!(
-            JsonValue::parse("\"unterminated").is_err(),
-            "unterminated string"
-        );
-        assert!(JsonValue::parse("[1, 2").is_err(), "unterminated array");
-    }
-
-    #[test]
-    fn parse_rejects_integers_outside_the_i64_range() {
-        // Far beyond i64::MAX (~9.2e18): the parser must reject rather than
-        // silently truncate the value.
-        assert!(JsonValue::parse("9999999999999999999999999").is_err());
-    }
-
-    #[test]
-    fn accessors_return_none_for_mismatched_variants() {
-        assert_eq!(JsonValue::Null.as_bool(), None);
-        assert_eq!(JsonValue::Bool(true).as_i64(), None);
-        assert!(JsonValue::Number(1).as_str().is_none());
-        assert!(JsonValue::Number(1).as_array().is_none());
-        assert!(JsonValue::String("x".to_string()).as_object().is_none());
-    }
-
-    #[test]
-    fn json_error_displays_its_message() {
-        assert_eq!(JsonError::new("boom").to_string(), "boom");
-    }
 }

rust/crates/runtime/src/lib.rs

@@ -66,16 +66,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,
@@ -83,8 +82,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,

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

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

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

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

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

rust/crates/tools/MULTI_TOOL_README.md

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

rust/crates/tools/src/lane_completion.rs

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