Prevent long sessions from stalling and expose the requested internal command surface

The runtime now auto-compacts completed conversations once cumulative input usage
crosses a configurable threshold, preserving recent context while surfacing an
explicit user notice. The CLI also publishes the requested ant-only slash
commands through the shared commands crate and main dispatch, using meaningful
local implementations for commit/PR/issue/teleport/debug workflows.

Constraint: Reuse the existing Rust compaction pipeline instead of introducing a new summarization stack
Constraint: No new dependencies or broad command-framework rewrite
Rejected: Implement API-driven compaction inside ConversationRuntime now | too much new plumbing for this delivery
Rejected: Expose new commands as parse-only stubs | would not satisfy the requested command availability
Confidence: medium
Scope-risk: moderate
Reversibility: clean
Directive: If runtime later gains true API-backed compaction, preserve the TurnSummary auto-compaction metadata shape so CLI call sites stay stable
Tested: cargo test; cargo build --release; cargo fmt --all; git diff --check; LSP diagnostics directory check
Not-tested: Live Anthropic-backed specialist command flows; gh-authenticated PR/issue creation in a real repo

rust/Cargo.lock

@@ -25,7 +25,6 @@ dependencies = [
  "runtime",
  "serde",
  "serde_json",
- "telemetry",
  "tokio",
 ]
 
@@ -1097,7 +1096,6 @@ dependencies = [
  "serde",
  "serde_json",
  "sha2",
- "telemetry",
  "tokio",
  "walkdir",
 ]
@@ -1430,14 +1428,6 @@ dependencies = [
  "yaml-rust",
 ]
 
-[[package]]
-name = "telemetry"
-version = "0.1.0"
-dependencies = [
- "serde",
- "serde_json",
-]
-
 [[package]]
 name = "thiserror"
 version = "2.0.18"

rust/crates/api/Cargo.toml

@@ -10,7 +10,6 @@ reqwest = { version = "0.12", default-features = false, features = ["json", "rus
 runtime = { path = "../runtime" }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
-telemetry = { path = "../telemetry" }
 tokio = { version = "1", features = ["io-util", "macros", "net", "rt-multi-thread", "time"] }
 
 [lints]

rust/crates/api/src/client.rs

@@ -2,19 +2,17 @@ use std::collections::VecDeque;
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
 use runtime::{
-    format_usd, load_oauth_credentials, pricing_for_model, save_oauth_credentials, OAuthConfig,
-    OAuthRefreshRequest, OAuthTokenExchangeRequest,
+    load_oauth_credentials, save_oauth_credentials, OAuthConfig, OAuthRefreshRequest,
+    OAuthTokenExchangeRequest,
 };
 use serde::Deserialize;
-use serde_json::{Map, Value};
-use telemetry::{AnalyticsEvent, AnthropicRequestProfile, ClientIdentity, SessionTracer};
 
 use crate::error::ApiError;
 use crate::sse::SseParser;
 use crate::types::{MessageRequest, MessageResponse, StreamEvent};
 
 const DEFAULT_BASE_URL: &str = "https://api.anthropic.com";
-const MESSAGES_PATH: &str = "/v1/messages";
+const ANTHROPIC_VERSION: &str = "2023-06-01";
 const REQUEST_ID_HEADER: &str = "request-id";
 const ALT_REQUEST_ID_HEADER: &str = "x-request-id";
 const DEFAULT_INITIAL_BACKOFF: Duration = Duration::from_millis(200);
@@ -110,8 +108,6 @@ pub struct AnthropicClient {
     max_retries: u32,
     initial_backoff: Duration,
     max_backoff: Duration,
-    request_profile: AnthropicRequestProfile,
-    session_tracer: Option<SessionTracer>,
 }
 
 impl AnthropicClient {
@@ -124,8 +120,6 @@ impl AnthropicClient {
             max_retries: DEFAULT_MAX_RETRIES,
             initial_backoff: DEFAULT_INITIAL_BACKOFF,
             max_backoff: DEFAULT_MAX_BACKOFF,
-            request_profile: AnthropicRequestProfile::default(),
-            session_tracer: None,
         }
     }
 
@@ -138,8 +132,6 @@ impl AnthropicClient {
             max_retries: DEFAULT_MAX_RETRIES,
             initial_backoff: DEFAULT_INITIAL_BACKOFF,
             max_backoff: DEFAULT_MAX_BACKOFF,
-            request_profile: AnthropicRequestProfile::default(),
-            session_tracer: None,
         }
     }
 
@@ -184,39 +176,6 @@ impl AnthropicClient {
         self
     }
 
-    #[must_use]
-    pub fn with_request_profile(mut self, request_profile: AnthropicRequestProfile) -> Self {
-        self.request_profile = request_profile;
-        self
-    }
-
-    #[must_use]
-    pub fn with_client_identity(mut self, client_identity: ClientIdentity) -> Self {
-        self.request_profile.client_identity = client_identity;
-        self
-    }
-
-    #[must_use]
-    pub fn with_beta(mut self, beta: impl Into<String>) -> Self {
-        let beta = beta.into();
-        if !self.request_profile.betas.contains(&beta) {
-            self.request_profile.betas.push(beta);
-        }
-        self
-    }
-
-    #[must_use]
-    pub fn with_extra_body_param(mut self, key: impl Into<String>, value: Value) -> Self {
-        self.request_profile.extra_body.insert(key.into(), value);
-        self
-    }
-
-    #[must_use]
-    pub fn with_session_tracer(mut self, session_tracer: SessionTracer) -> Self {
-        self.session_tracer = Some(session_tracer);
-        self
-    }
-
     #[must_use]
     pub fn with_retry_policy(
         mut self,
@@ -252,7 +211,6 @@ impl AnthropicClient {
         if response.request_id.is_none() {
             response.request_id = request_id;
         }
-        self.record_response_usage(&response);
         Ok(response)
     }
 
@@ -321,30 +279,18 @@ impl AnthropicClient {
 
         loop {
             attempts += 1;
-            self.record_request_started(request, attempts);
             match self.send_raw_request(request).await {
                 Ok(response) => match expect_success(response).await {
-                    Ok(response) => {
-                        self.record_request_succeeded(request, attempts, &response);
-                        return Ok(response);
-                    }
+                    Ok(response) => return Ok(response),
                     Err(error) if error.is_retryable() && attempts <= self.max_retries + 1 => {
-                        self.record_request_failed(request, attempts, &error);
                         last_error = Some(error);
                     }
-                    Err(error) => {
-                        self.record_request_failed(request, attempts, &error);
-                        return Err(error);
-                    }
+                    Err(error) => return Err(error),
                 },
                 Err(error) if error.is_retryable() && attempts <= self.max_retries + 1 => {
-                    self.record_request_failed(request, attempts, &error);
                     last_error = Some(error);
                 }
-                Err(error) => {
-                    self.record_request_failed(request, attempts, &error);
-                    return Err(error);
-                }
+                Err(error) => return Err(error),
             }
 
             if attempts > self.max_retries {
@@ -364,213 +310,18 @@ impl AnthropicClient {
         &self,
         request: &MessageRequest,
     ) -> Result<reqwest::Response, ApiError> {
-        let request_url = format!("{}{}", self.base_url.trim_end_matches('/'), MESSAGES_PATH);
-        let mut request_builder = self
+        let request_url = format!("{}/v1/messages", self.base_url.trim_end_matches('/'));
+        let request_builder = self
             .http
             .post(&request_url)
+            .header("anthropic-version", ANTHROPIC_VERSION)
             .header("content-type", "application/json");
-        for (name, value) in self.request_profile.header_pairs() {
-            request_builder = request_builder.header(name, value);
-        }
         let mut request_builder = self.auth.apply(request_builder);
 
-        let request_body = self.request_profile.render_json_body(request)?;
-        request_builder = request_builder.json(&request_body);
+        request_builder = request_builder.json(request);
         request_builder.send().await.map_err(ApiError::from)
     }
 
-    fn record_request_started(&self, request: &MessageRequest, attempt: u32) {
-        if let Some(tracer) = &self.session_tracer {
-            tracer.record_http_request_started(
-                attempt,
-                "POST",
-                MESSAGES_PATH,
-                self.request_attributes(request),
-            );
-        }
-    }
-
-    fn record_request_succeeded(
-        &self,
-        request: &MessageRequest,
-        attempt: u32,
-        response: &reqwest::Response,
-    ) {
-        if let Some(tracer) = &self.session_tracer {
-            tracer.record_http_request_succeeded(
-                attempt,
-                "POST",
-                MESSAGES_PATH,
-                response.status().as_u16(),
-                request_id_from_headers(response.headers()),
-                self.request_attributes(request),
-            );
-        }
-    }
-
-    fn record_request_failed(&self, request: &MessageRequest, attempt: u32, error: &ApiError) {
-        if let Some(tracer) = &self.session_tracer {
-            tracer.record_http_request_failed(
-                attempt,
-                "POST",
-                MESSAGES_PATH,
-                error.to_string(),
-                error.is_retryable(),
-                self.error_attributes(request, error),
-            );
-        }
-    }
-
-    fn record_response_usage(&self, response: &MessageResponse) {
-        let Some(tracer) = &self.session_tracer else {
-            return;
-        };
-
-        let cost = response.usage.estimated_cost_usd(&response.model);
-        let pricing_source = if pricing_for_model(&response.model).is_some() {
-            "model-specific"
-        } else {
-            "default-sonnet"
-        };
-
-        let mut properties = Map::new();
-        properties.insert("model".to_string(), Value::String(response.model.clone()));
-        properties.insert(
-            "pricing_source".to_string(),
-            Value::String(pricing_source.to_string()),
-        );
-        properties.insert(
-            "input_tokens".to_string(),
-            Value::from(response.usage.input_tokens),
-        );
-        properties.insert(
-            "output_tokens".to_string(),
-            Value::from(response.usage.output_tokens),
-        );
-        properties.insert(
-            "cache_creation_input_tokens".to_string(),
-            Value::from(response.usage.cache_creation_input_tokens),
-        );
-        properties.insert(
-            "cache_read_input_tokens".to_string(),
-            Value::from(response.usage.cache_read_input_tokens),
-        );
-        properties.insert(
-            "total_tokens".to_string(),
-            Value::from(response.usage.total_tokens()),
-        );
-        properties.insert(
-            "estimated_cost_usd".to_string(),
-            Value::String(format_usd(cost.total_cost_usd())),
-        );
-        properties.insert(
-            "estimated_input_cost_usd".to_string(),
-            Value::String(format_usd(cost.input_cost_usd)),
-        );
-        properties.insert(
-            "estimated_output_cost_usd".to_string(),
-            Value::String(format_usd(cost.output_cost_usd)),
-        );
-        properties.insert(
-            "estimated_cache_creation_cost_usd".to_string(),
-            Value::String(format_usd(cost.cache_creation_cost_usd)),
-        );
-        properties.insert(
-            "estimated_cache_read_cost_usd".to_string(),
-            Value::String(format_usd(cost.cache_read_cost_usd)),
-        );
-        if let Some(request_id) = &response.request_id {
-            properties.insert("request_id".to_string(), Value::String(request_id.clone()));
-        }
-
-        tracer.record_analytics(AnalyticsEvent {
-            namespace: "api".to_string(),
-            action: "message_usage".to_string(),
-            properties,
-        });
-    }
-
-    fn request_attributes(&self, request: &MessageRequest) -> Map<String, Value> {
-        let mut attributes = Map::new();
-        attributes.insert("model".to_string(), Value::String(request.model.clone()));
-        attributes.insert("stream".to_string(), Value::Bool(request.stream));
-        attributes.insert("max_tokens".to_string(), Value::from(request.max_tokens));
-        attributes.insert(
-            "message_count".to_string(),
-            Value::from(u64::try_from(request.messages.len()).unwrap_or(u64::MAX)),
-        );
-        attributes.insert(
-            "tool_count".to_string(),
-            Value::from(
-                u64::try_from(request.tools.as_ref().map_or(0, Vec::len)).unwrap_or(u64::MAX),
-            ),
-        );
-        attributes.insert(
-            "beta_count".to_string(),
-            Value::from(u64::try_from(self.request_profile.betas.len()).unwrap_or(u64::MAX)),
-        );
-        if !self.request_profile.betas.is_empty() {
-            attributes.insert(
-                "betas".to_string(),
-                Value::Array(
-                    self.request_profile
-                        .betas
-                        .iter()
-                        .cloned()
-                        .map(Value::String)
-                        .collect(),
-                ),
-            );
-        }
-        if !self.request_profile.extra_body.is_empty() {
-            attributes.insert(
-                "extra_body_keys".to_string(),
-                Value::Array(
-                    self.request_profile
-                        .extra_body
-                        .keys()
-                        .cloned()
-                        .map(Value::String)
-                        .collect(),
-                ),
-            );
-        }
-        attributes
-    }
-
-    fn error_attributes(&self, request: &MessageRequest, error: &ApiError) -> Map<String, Value> {
-        let mut attributes = self.request_attributes(request);
-        match error {
-            ApiError::Api {
-                status,
-                error_type,
-                message,
-                ..
-            } => {
-                attributes.insert("status".to_string(), Value::from(status.as_u16()));
-                if let Some(error_type) = error_type {
-                    attributes.insert("error_type".to_string(), Value::String(error_type.clone()));
-                }
-                if let Some(message) = message {
-                    attributes.insert("api_message".to_string(), Value::String(message.clone()));
-                }
-            }
-            ApiError::Http(_) => {
-                attributes.insert("error_type".to_string(), Value::String("http".to_string()));
-            }
-            ApiError::Json(_) => {
-                attributes.insert("error_type".to_string(), Value::String("json".to_string()));
-            }
-            _ => {
-                attributes.insert(
-                    "error_type".to_string(),
-                    Value::String("client".to_string()),
-                );
-            }
-        }
-        attributes
-    }
-
     fn backoff_for_attempt(&self, attempt: u32) -> Result<Duration, ApiError> {
         let Some(multiplier) = 1_u32.checked_shl(attempt.saturating_sub(1)) else {
             return Err(ApiError::BackoffOverflow {

rust/crates/api/src/lib.rs

@@ -15,9 +15,3 @@ pub use types::{
     MessageResponse, MessageStartEvent, MessageStopEvent, OutputContentBlock, StreamEvent,
     ToolChoice, ToolDefinition, ToolResultContentBlock, Usage,
 };
-
-pub use telemetry::{
-    AnalyticsEvent, AnthropicRequestProfile, ClientIdentity, JsonlTelemetrySink,
-    MemoryTelemetrySink, SessionTraceRecord, SessionTracer, TelemetryEvent, TelemetrySink,
-    DEFAULT_ANTHROPIC_VERSION,
-};

rust/crates/api/src/types.rs

@@ -1,4 +1,3 @@
-use runtime::{pricing_for_model, TokenUsage, UsageCostEstimate};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 
@@ -151,29 +150,7 @@ pub struct Usage {
 impl Usage {
     #[must_use]
     pub const fn total_tokens(&self) -> u32 {
-        self.input_tokens
-            + self.output_tokens
-            + self.cache_creation_input_tokens
-            + self.cache_read_input_tokens
-    }
-
-    #[must_use]
-    pub const fn token_usage(&self) -> TokenUsage {
-        TokenUsage {
-            input_tokens: self.input_tokens,
-            output_tokens: self.output_tokens,
-            cache_creation_input_tokens: self.cache_creation_input_tokens,
-            cache_read_input_tokens: self.cache_read_input_tokens,
-        }
-    }
-
-    #[must_use]
-    pub fn estimated_cost_usd(&self, model: &str) -> UsageCostEstimate {
-        let usage = self.token_usage();
-        pricing_for_model(model).map_or_else(
-            || usage.estimate_cost_usd(),
-            |pricing| usage.estimate_cost_usd_with_pricing(pricing),
-        )
+        self.input_tokens + self.output_tokens
     }
 }
 
@@ -233,47 +210,3 @@ pub enum StreamEvent {
     ContentBlockStop(ContentBlockStopEvent),
     MessageStop(MessageStopEvent),
 }
-
-#[cfg(test)]
-mod tests {
-    use runtime::format_usd;
-
-    use super::{MessageResponse, Usage};
-
-    #[test]
-    fn usage_total_tokens_includes_cache_tokens() {
-        let usage = Usage {
-            input_tokens: 10,
-            cache_creation_input_tokens: 2,
-            cache_read_input_tokens: 3,
-            output_tokens: 4,
-        };
-
-        assert_eq!(usage.total_tokens(), 19);
-        assert_eq!(usage.token_usage().total_tokens(), 19);
-    }
-
-    #[test]
-    fn message_response_estimates_cost_from_model_usage() {
-        let response = MessageResponse {
-            id: "msg_cost".to_string(),
-            kind: "message".to_string(),
-            role: "assistant".to_string(),
-            content: Vec::new(),
-            model: "claude-sonnet-4-20250514".to_string(),
-            stop_reason: Some("end_turn".to_string()),
-            stop_sequence: None,
-            usage: Usage {
-                input_tokens: 1_000_000,
-                cache_creation_input_tokens: 100_000,
-                cache_read_input_tokens: 200_000,
-                output_tokens: 500_000,
-            },
-            request_id: None,
-        };
-
-        let cost = response.usage.estimated_cost_usd(&response.model);
-        assert_eq!(format_usd(cost.total_cost_usd()), "$54.6750");
-        assert_eq!(response.total_tokens(), 1_800_000);
-    }
-}

rust/crates/api/tests/client_integration.rs

@@ -8,7 +8,6 @@ use api::{
     StreamEvent, ToolChoice, ToolDefinition,
 };
 use serde_json::json;
-use telemetry::{ClientIdentity, MemoryTelemetrySink, SessionTracer, TelemetryEvent};
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::net::TcpListener;
 use tokio::sync::Mutex;
@@ -65,18 +64,6 @@ async fn send_message_posts_json_and_parses_response() {
         request.headers.get("authorization").map(String::as_str),
         Some("Bearer proxy-token")
     );
-    assert_eq!(
-        request.headers.get("anthropic-version").map(String::as_str),
-        Some("2023-06-01")
-    );
-    assert_eq!(
-        request.headers.get("user-agent").map(String::as_str),
-        Some("claude-code/0.1.0")
-    );
-    assert_eq!(
-        request.headers.get("anthropic-beta").map(String::as_str),
-        Some("claude-code-20250219,prompt-caching-scope-2026-01-05")
-    );
     let body: serde_json::Value =
         serde_json::from_str(&request.body).expect("request body should be json");
     assert_eq!(
@@ -86,115 +73,6 @@ async fn send_message_posts_json_and_parses_response() {
     assert!(body.get("stream").is_none());
     assert_eq!(body["tools"][0]["name"], json!("get_weather"));
     assert_eq!(body["tool_choice"]["type"], json!("auto"));
-    assert_eq!(
-        body["betas"],
-        json!(["claude-code-20250219", "prompt-caching-scope-2026-01-05"])
-    );
-}
-
-#[tokio::test]
-async fn send_message_applies_request_profile_and_records_telemetry() {
-    let state = Arc::new(Mutex::new(Vec::<CapturedRequest>::new()));
-    let server = spawn_server(
-        state.clone(),
-        vec![http_response_with_headers(
-            "200 OK",
-            "application/json",
-            concat!(
-                "{",
-                "\"id\":\"msg_profile\",",
-                "\"type\":\"message\",",
-                "\"role\":\"assistant\",",
-                "\"content\":[{\"type\":\"text\",\"text\":\"ok\"}],",
-                "\"model\":\"claude-3-7-sonnet-latest\",",
-                "\"stop_reason\":\"end_turn\",",
-                "\"stop_sequence\":null,",
-                "\"usage\":{\"input_tokens\":1,\"cache_creation_input_tokens\":2,\"cache_read_input_tokens\":3,\"output_tokens\":1}",
-                "}"
-            ),
-            &[("request-id", "req_profile_123")],
-        )],
-    )
-    .await;
-    let sink = Arc::new(MemoryTelemetrySink::default());
-
-    let client = AnthropicClient::new("test-key")
-        .with_base_url(server.base_url())
-        .with_client_identity(ClientIdentity::new("claude-code", "9.9.9").with_runtime("rust-cli"))
-        .with_beta("tools-2026-04-01")
-        .with_extra_body_param("metadata", json!({"source": "clawd-code"}))
-        .with_session_tracer(SessionTracer::new("session-telemetry", sink.clone()));
-
-    let response = client
-        .send_message(&sample_request(false))
-        .await
-        .expect("request should succeed");
-
-    assert_eq!(response.request_id.as_deref(), Some("req_profile_123"));
-
-    let captured = state.lock().await;
-    let request = captured.first().expect("server should capture request");
-    assert_eq!(
-        request.headers.get("anthropic-beta").map(String::as_str),
-        Some("claude-code-20250219,prompt-caching-scope-2026-01-05,tools-2026-04-01")
-    );
-    assert_eq!(
-        request.headers.get("user-agent").map(String::as_str),
-        Some("claude-code/9.9.9")
-    );
-    let body: serde_json::Value =
-        serde_json::from_str(&request.body).expect("request body should be json");
-    assert_eq!(body["metadata"]["source"], json!("clawd-code"));
-    assert_eq!(
-        body["betas"],
-        json!([
-            "claude-code-20250219",
-            "prompt-caching-scope-2026-01-05",
-            "tools-2026-04-01"
-        ])
-    );
-
-    let events = sink.events();
-    assert_eq!(events.len(), 6);
-    assert!(matches!(
-        &events[0],
-        TelemetryEvent::HttpRequestStarted {
-            session_id,
-            attempt: 1,
-            method,
-            path,
-            ..
-        } if session_id == "session-telemetry" && method == "POST" && path == "/v1/messages"
-    ));
-    assert!(matches!(
-        &events[1],
-        TelemetryEvent::SessionTrace(trace) if trace.name == "http_request_started"
-    ));
-    assert!(matches!(
-        &events[2],
-        TelemetryEvent::HttpRequestSucceeded {
-            request_id,
-            status: 200,
-            ..
-        } if request_id.as_deref() == Some("req_profile_123")
-    ));
-    assert!(matches!(
-        &events[3],
-        TelemetryEvent::SessionTrace(trace) if trace.name == "http_request_succeeded"
-    ));
-    assert!(matches!(
-        &events[4],
-        TelemetryEvent::Analytics(event)
-            if event.namespace == "api"
-                && event.action == "message_usage"
-                && event.properties.get("request_id") == Some(&json!("req_profile_123"))
-                && event.properties.get("total_tokens") == Some(&json!(7))
-                && event.properties.get("estimated_cost_usd") == Some(&json!("$0.0001"))
-    ));
-    assert!(matches!(
-        &events[5],
-        TelemetryEvent::SessionTrace(trace) if trace.name == "analytics"
-    ));
 }
 
 #[tokio::test]

rust/crates/commands/src/lib.rs

@@ -117,6 +117,48 @@ const SLASH_COMMAND_SPECS: &[SlashCommandSpec] = &[
         argument_hint: None,
         resume_supported: true,
     },
+    SlashCommandSpec {
+        name: "bughunter",
+        summary: "Inspect the codebase for likely bugs",
+        argument_hint: Some("[scope]"),
+        resume_supported: false,
+    },
+    SlashCommandSpec {
+        name: "commit",
+        summary: "Generate a commit message and create a git commit",
+        argument_hint: None,
+        resume_supported: false,
+    },
+    SlashCommandSpec {
+        name: "pr",
+        summary: "Draft or create a pull request from the conversation",
+        argument_hint: Some("[context]"),
+        resume_supported: false,
+    },
+    SlashCommandSpec {
+        name: "issue",
+        summary: "Draft or create a GitHub issue from the conversation",
+        argument_hint: Some("[context]"),
+        resume_supported: false,
+    },
+    SlashCommandSpec {
+        name: "ultraplan",
+        summary: "Run a deep planning prompt with multi-step reasoning",
+        argument_hint: Some("[task]"),
+        resume_supported: false,
+    },
+    SlashCommandSpec {
+        name: "teleport",
+        summary: "Jump to a file or symbol by searching the workspace",
+        argument_hint: Some("<symbol-or-path>"),
+        resume_supported: false,
+    },
+    SlashCommandSpec {
+        name: "debug-tool-call",
+        summary: "Replay the last tool call with debug details",
+        argument_hint: None,
+        resume_supported: false,
+    },
     SlashCommandSpec {
         name: "export",
         summary: "Export the current conversation to a file",
@@ -136,6 +178,23 @@ pub enum SlashCommand {
     Help,
     Status,
     Compact,
+    Bughunter {
+        scope: Option<String>,
+    },
+    Commit,
+    Pr {
+        context: Option<String>,
+    },
+    Issue {
+        context: Option<String>,
+    },
+    Ultraplan {
+        task: Option<String>,
+    },
+    Teleport {
+        target: Option<String>,
+    },
+    DebugToolCall,
     Model {
         model: Option<String>,
     },
@@ -180,6 +239,23 @@ impl SlashCommand {
             "help" => Self::Help,
             "status" => Self::Status,
             "compact" => Self::Compact,
+            "bughunter" => Self::Bughunter {
+                scope: remainder_after_command(trimmed, command),
+            },
+            "commit" => Self::Commit,
+            "pr" => Self::Pr {
+                context: remainder_after_command(trimmed, command),
+            },
+            "issue" => Self::Issue {
+                context: remainder_after_command(trimmed, command),
+            },
+            "ultraplan" => Self::Ultraplan {
+                task: remainder_after_command(trimmed, command),
+            },
+            "teleport" => Self::Teleport {
+                target: remainder_after_command(trimmed, command),
+            },
+            "debug-tool-call" => Self::DebugToolCall,
             "model" => Self::Model {
                 model: parts.next().map(ToOwned::to_owned),
             },
@@ -212,6 +288,15 @@ impl SlashCommand {
     }
 }
 
+fn remainder_after_command(input: &str, command: &str) -> Option<String> {
+    input
+        .trim()
+        .strip_prefix(&format!("/{command}"))
+        .map(str::trim)
+        .filter(|value| !value.is_empty())
+        .map(ToOwned::to_owned)
+}
+
 #[must_use]
 pub fn slash_command_specs() -> &'static [SlashCommandSpec] {
     SLASH_COMMAND_SPECS
@@ -279,6 +364,13 @@ pub fn handle_slash_command(
             session: session.clone(),
         }),
         SlashCommand::Status
+        | SlashCommand::Bughunter { .. }
+        | SlashCommand::Commit
+        | SlashCommand::Pr { .. }
+        | SlashCommand::Issue { .. }
+        | SlashCommand::Ultraplan { .. }
+        | SlashCommand::Teleport { .. }
+        | SlashCommand::DebugToolCall
         | SlashCommand::Model { .. }
         | SlashCommand::Permissions { .. }
         | SlashCommand::Clear { .. }
@@ -307,6 +399,41 @@ mod tests {
     fn parses_supported_slash_commands() {
         assert_eq!(SlashCommand::parse("/help"), Some(SlashCommand::Help));
         assert_eq!(SlashCommand::parse(" /status "), Some(SlashCommand::Status));
+        assert_eq!(
+            SlashCommand::parse("/bughunter runtime"),
+            Some(SlashCommand::Bughunter {
+                scope: Some("runtime".to_string())
+            })
+        );
+        assert_eq!(SlashCommand::parse("/commit"), Some(SlashCommand::Commit));
+        assert_eq!(
+            SlashCommand::parse("/pr ready for review"),
+            Some(SlashCommand::Pr {
+                context: Some("ready for review".to_string())
+            })
+        );
+        assert_eq!(
+            SlashCommand::parse("/issue flaky test"),
+            Some(SlashCommand::Issue {
+                context: Some("flaky test".to_string())
+            })
+        );
+        assert_eq!(
+            SlashCommand::parse("/ultraplan ship both features"),
+            Some(SlashCommand::Ultraplan {
+                task: Some("ship both features".to_string())
+            })
+        );
+        assert_eq!(
+            SlashCommand::parse("/teleport conversation.rs"),
+            Some(SlashCommand::Teleport {
+                target: Some("conversation.rs".to_string())
+            })
+        );
+        assert_eq!(
+            SlashCommand::parse("/debug-tool-call"),
+            Some(SlashCommand::DebugToolCall)
+        );
         assert_eq!(
             SlashCommand::parse("/model claude-opus"),
             Some(SlashCommand::Model {
@@ -374,6 +501,13 @@ mod tests {
         assert!(help.contains("/help"));
         assert!(help.contains("/status"));
         assert!(help.contains("/compact"));
+        assert!(help.contains("/bughunter [scope]"));
+        assert!(help.contains("/commit"));
+        assert!(help.contains("/pr [context]"));
+        assert!(help.contains("/issue [context]"));
+        assert!(help.contains("/ultraplan [task]"));
+        assert!(help.contains("/teleport <symbol-or-path>"));
+        assert!(help.contains("/debug-tool-call"));
         assert!(help.contains("/model [model]"));
         assert!(help.contains("/permissions [read-only|workspace-write|danger-full-access]"));
         assert!(help.contains("/clear [--confirm]"));
@@ -386,7 +520,7 @@ mod tests {
         assert!(help.contains("/version"));
         assert!(help.contains("/export [file]"));
         assert!(help.contains("/session [list|switch <session-id>]"));
-        assert_eq!(slash_command_specs().len(), 15);
+        assert_eq!(slash_command_specs().len(), 22);
         assert_eq!(resume_supported_slash_commands().len(), 11);
     }
 
@@ -434,6 +568,22 @@ mod tests {
         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("/bughunter", &session, CompactionConfig::default()).is_none()
+        );
+        assert!(handle_slash_command("/commit", &session, CompactionConfig::default()).is_none());
+        assert!(handle_slash_command("/pr", &session, CompactionConfig::default()).is_none());
+        assert!(handle_slash_command("/issue", &session, CompactionConfig::default()).is_none());
+        assert!(
+            handle_slash_command("/ultraplan", &session, CompactionConfig::default()).is_none()
+        );
+        assert!(
+            handle_slash_command("/teleport foo", &session, CompactionConfig::default()).is_none()
+        );
+        assert!(
+            handle_slash_command("/debug-tool-call", &session, CompactionConfig::default())
+                .is_none()
+        );
         assert!(
             handle_slash_command("/model claude", &session, CompactionConfig::default()).is_none()
         );

rust/crates/runtime/Cargo.toml

@@ -11,7 +11,6 @@ glob = "0.3"
 regex = "1"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
-telemetry = { path = "../telemetry" }
 tokio = { version = "1", features = ["io-util", "macros", "process", "rt", "rt-multi-thread", "time"] }
 walkdir = "2"
 

rust/crates/runtime/src/config.rs

@@ -37,7 +37,6 @@ pub struct RuntimeConfig {
 
 #[derive(Debug, Clone, PartialEq, Eq, Default)]
 pub struct RuntimeFeatureConfig {
-    hooks: RuntimeHookConfig,
     mcp: McpConfigCollection,
     oauth: Option<OAuthConfig>,
     model: Option<String>,
@@ -45,12 +44,6 @@ pub struct RuntimeFeatureConfig {
     sandbox: SandboxConfig,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Default)]
-pub struct RuntimeHookConfig {
-    pre_tool_use: Vec<String>,
-    post_tool_use: Vec<String>,
-}
-
 #[derive(Debug, Clone, PartialEq, Eq, Default)]
 pub struct McpConfigCollection {
     servers: BTreeMap<String, ScopedMcpServerConfig>,
@@ -228,7 +221,6 @@ impl ConfigLoader {
         let merged_value = JsonValue::Object(merged.clone());
 
         let feature_config = RuntimeFeatureConfig {
-            hooks: parse_optional_hooks_config(&merged_value)?,
             mcp: McpConfigCollection {
                 servers: mcp_servers,
             },
@@ -286,11 +278,6 @@ impl RuntimeConfig {
         &self.feature_config.mcp
     }
 
-    #[must_use]
-    pub fn hooks(&self) -> &RuntimeHookConfig {
-        &self.feature_config.hooks
-    }
-
     #[must_use]
     pub fn oauth(&self) -> Option<&OAuthConfig> {
         self.feature_config.oauth.as_ref()
@@ -313,17 +300,6 @@ impl RuntimeConfig {
 }
 
 impl RuntimeFeatureConfig {
-    #[must_use]
-    pub fn with_hooks(mut self, hooks: RuntimeHookConfig) -> Self {
-        self.hooks = hooks;
-        self
-    }
-
-    #[must_use]
-    pub fn hooks(&self) -> &RuntimeHookConfig {
-        &self.hooks
-    }
-
     #[must_use]
     pub fn mcp(&self) -> &McpConfigCollection {
         &self.mcp
@@ -350,26 +326,6 @@ impl RuntimeFeatureConfig {
     }
 }
 
-impl RuntimeHookConfig {
-    #[must_use]
-    pub fn new(pre_tool_use: Vec<String>, post_tool_use: Vec<String>) -> Self {
-        Self {
-            pre_tool_use,
-            post_tool_use,
-        }
-    }
-
-    #[must_use]
-    pub fn pre_tool_use(&self) -> &[String] {
-        &self.pre_tool_use
-    }
-
-    #[must_use]
-    pub fn post_tool_use(&self) -> &[String] {
-        &self.post_tool_use
-    }
-}
-
 impl McpConfigCollection {
     #[must_use]
     pub fn servers(&self) -> &BTreeMap<String, ScopedMcpServerConfig> {
@@ -468,22 +424,6 @@ fn parse_optional_model(root: &JsonValue) -> Option<String> {
         .map(ToOwned::to_owned)
 }
 
-fn parse_optional_hooks_config(root: &JsonValue) -> Result<RuntimeHookConfig, ConfigError> {
-    let Some(object) = root.as_object() else {
-        return Ok(RuntimeHookConfig::default());
-    };
-    let Some(hooks_value) = object.get("hooks") else {
-        return Ok(RuntimeHookConfig::default());
-    };
-    let hooks = expect_object(hooks_value, "merged settings.hooks")?;
-    Ok(RuntimeHookConfig {
-        pre_tool_use: optional_string_array(hooks, "PreToolUse", "merged settings.hooks")?
-            .unwrap_or_default(),
-        post_tool_use: optional_string_array(hooks, "PostToolUse", "merged settings.hooks")?
-            .unwrap_or_default(),
-    })
-}
-
 fn parse_optional_permission_mode(
     root: &JsonValue,
 ) -> Result<Option<ResolvedPermissionMode>, ConfigError> {
@@ -896,8 +836,6 @@ mod tests {
             .and_then(JsonValue::as_object)
             .expect("hooks object")
             .contains_key("PostToolUse"));
-        assert_eq!(loaded.hooks().pre_tool_use(), &["base".to_string()]);
-        assert_eq!(loaded.hooks().post_tool_use(), &["project".to_string()]);
         assert!(loaded.mcp().get("home").is_some());
         assert!(loaded.mcp().get("project").is_some());
 

rust/crates/runtime/src/conversation.rs

@@ -1,18 +1,16 @@
 use std::collections::BTreeMap;
 use std::fmt::{Display, Formatter};
 
-use serde_json::{Map, Value};
-use telemetry::SessionTracer;
-
 use crate::compact::{
     compact_session, estimate_session_tokens, CompactionConfig, CompactionResult,
 };
-use crate::config::RuntimeFeatureConfig;
-use crate::hooks::{HookRunResult, HookRunner};
 use crate::permissions::{PermissionOutcome, PermissionPolicy, PermissionPrompter};
 use crate::session::{ContentBlock, ConversationMessage, Session};
 use crate::usage::{TokenUsage, UsageTracker};
 
+const DEFAULT_AUTO_COMPACTION_INPUT_TOKENS_THRESHOLD: u32 = 100_000;
+const AUTO_COMPACTION_THRESHOLD_ENV_VAR: &str = "CLAUDE_CODE_AUTO_COMPACT_INPUT_TOKENS";
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ApiRequest {
     pub system_prompt: Vec<String>,
@@ -89,6 +87,12 @@ pub struct TurnSummary {
     pub tool_results: Vec<ConversationMessage>,
     pub iterations: usize,
     pub usage: TokenUsage,
+    pub auto_compaction: Option<AutoCompactionEvent>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct AutoCompactionEvent {
+    pub removed_message_count: usize,
 }
 
 pub struct ConversationRuntime<C, T> {
@@ -99,8 +103,7 @@ pub struct ConversationRuntime<C, T> {
     system_prompt: Vec<String>,
     max_iterations: usize,
     usage_tracker: UsageTracker,
-    hook_runner: HookRunner,
-    session_tracer: Option<SessionTracer>,
+    auto_compaction_input_tokens_threshold: u32,
 }
 
 impl<C, T> ConversationRuntime<C, T>
@@ -115,25 +118,6 @@ where
         tool_executor: T,
         permission_policy: PermissionPolicy,
         system_prompt: Vec<String>,
-    ) -> Self {
-        Self::new_with_features(
-            session,
-            api_client,
-            tool_executor,
-            permission_policy,
-            system_prompt,
-            &RuntimeFeatureConfig::default(),
-        )
-    }
-
-    #[must_use]
-    pub fn new_with_features(
-        session: Session,
-        api_client: C,
-        tool_executor: T,
-        permission_policy: PermissionPolicy,
-        system_prompt: Vec<String>,
-        feature_config: &RuntimeFeatureConfig,
     ) -> Self {
         let usage_tracker = UsageTracker::from_session(&session);
         Self {
@@ -144,8 +128,7 @@ where
             system_prompt,
             max_iterations: usize::MAX,
             usage_tracker,
-            hook_runner: HookRunner::from_feature_config(feature_config),
-            session_tracer: None,
+            auto_compaction_input_tokens_threshold: auto_compaction_threshold_from_env(),
         }
     }
 
@@ -156,22 +139,19 @@ where
     }
 
     #[must_use]
-    pub fn with_session_tracer(mut self, session_tracer: SessionTracer) -> Self {
-        self.session_tracer = Some(session_tracer);
+    pub fn with_auto_compaction_input_tokens_threshold(mut self, threshold: u32) -> Self {
+        self.auto_compaction_input_tokens_threshold = threshold;
         self
     }
 
-    #[allow(clippy::too_many_lines)]
     pub fn run_turn(
         &mut self,
         user_input: impl Into<String>,
         mut prompter: Option<&mut dyn PermissionPrompter>,
     ) -> Result<TurnSummary, RuntimeError> {
-        let user_input = user_input.into();
-        self.record_turn_started(&user_input);
         self.session
             .messages
-            .push(ConversationMessage::user_text(user_input));
+            .push(ConversationMessage::user_text(user_input.into()));
 
         let mut assistant_messages = Vec::new();
         let mut tool_results = Vec::new();
@@ -180,31 +160,17 @@ where
         loop {
             iterations += 1;
             if iterations > self.max_iterations {
-                let error = RuntimeError::new(
+                return Err(RuntimeError::new(
                     "conversation loop exceeded the maximum number of iterations",
-                );
-                self.record_turn_failed(iterations, &error);
-                return Err(error);
+                ));
             }
 
             let request = ApiRequest {
                 system_prompt: self.system_prompt.clone(),
                 messages: self.session.messages.clone(),
             };
-            let events = match self.api_client.stream(request) {
-                Ok(events) => events,
-                Err(error) => {
-                    self.record_turn_failed(iterations, &error);
-                    return Err(error);
-                }
-            };
-            let (assistant_message, usage) = match build_assistant_message(events) {
-                Ok(result) => result,
-                Err(error) => {
-                    self.record_turn_failed(iterations, &error);
-                    return Err(error);
-                }
-            };
+            let events = self.api_client.stream(request)?;
+            let (assistant_message, usage) = build_assistant_message(events)?;
             if let Some(usage) = usage {
                 self.usage_tracker.record(usage);
             }
@@ -218,11 +184,6 @@ where
                     _ => None,
                 })
                 .collect::<Vec<_>>();
-            self.record_assistant_iteration(
-                iterations,
-                &assistant_message,
-                pending_tool_uses.len(),
-            );
 
             self.session.messages.push(assistant_message.clone());
             assistant_messages.push(assistant_message);
@@ -232,7 +193,6 @@ where
             }
 
             for (tool_use_id, tool_name, input) in pending_tool_uses {
-                self.record_tool_started(iterations, &tool_name);
                 let permission_outcome = if let Some(prompt) = prompter.as_mut() {
                     self.permission_policy
                         .authorize(&tool_name, &input, Some(*prompt))
@@ -242,61 +202,39 @@ where
 
                 let result_message = match permission_outcome {
                     PermissionOutcome::Allow => {
-                        let pre_hook_result = self.hook_runner.run_pre_tool_use(&tool_name, &input);
-                        if pre_hook_result.is_denied() {
-                            let deny_message = format!("PreToolUse hook denied tool `{tool_name}`");
-                            ConversationMessage::tool_result(
+                        match self.tool_executor.execute(&tool_name, &input) {
+                            Ok(output) => ConversationMessage::tool_result(
                                 tool_use_id,
                                 tool_name,
-                                format_hook_message(&pre_hook_result, &deny_message),
+                                output,
+                                false,
+                            ),
+                            Err(error) => ConversationMessage::tool_result(
+                                tool_use_id,
+                                tool_name,
+                                error.to_string(),
                                 true,
-                            )
-                        } else {
-                            let (mut output, mut is_error) =
-                                match self.tool_executor.execute(&tool_name, &input) {
-                                    Ok(output) => (output, false),
-                                    Err(error) => (error.to_string(), true),
-                                };
-                            output = merge_hook_feedback(pre_hook_result.messages(), output, false);
-
-                            let post_hook_result = self
-                                .hook_runner
-                                .run_post_tool_use(&tool_name, &input, &output, is_error);
-                            if post_hook_result.is_denied() {
-                                is_error = true;
-                            }
-                            output = merge_hook_feedback(
-                                post_hook_result.messages(),
-                                output,
-                                post_hook_result.is_denied(),
-                            );
-
-                            ConversationMessage::tool_result(
-                                tool_use_id,
-                                tool_name,
-                                output,
-                                is_error,
-                            )
+                            ),
                         }
                     }
                     PermissionOutcome::Deny { reason } => {
                         ConversationMessage::tool_result(tool_use_id, tool_name, reason, true)
                     }
                 };
-                self.record_tool_finished(iterations, &result_message);
                 self.session.messages.push(result_message.clone());
                 tool_results.push(result_message);
             }
         }
 
-        let summary = TurnSummary {
+        let auto_compaction = self.maybe_auto_compact();
+
+        Ok(TurnSummary {
             assistant_messages,
             tool_results,
             iterations,
             usage: self.usage_tracker.cumulative_usage(),
-        };
-        self.record_turn_completed(&summary);
-        Ok(summary)
+            auto_compaction,
+        })
     }
 
     #[must_use]
@@ -324,127 +262,49 @@ where
         self.session
     }
 
-    fn record_turn_started(&self, user_input: &str) {
-        if let Some(tracer) = &self.session_tracer {
-            let mut attributes = Map::new();
-            attributes.insert(
-                "message_count_before".to_string(),
-                Value::from(u64::try_from(self.session.messages.len()).unwrap_or(u64::MAX)),
-            );
-            attributes.insert(
-                "input_chars".to_string(),
-                Value::from(u64::try_from(user_input.chars().count()).unwrap_or(u64::MAX)),
-            );
-            tracer.record("turn_started", attributes);
+    fn maybe_auto_compact(&mut self) -> Option<AutoCompactionEvent> {
+        if self.usage_tracker.cumulative_usage().input_tokens
+            < self.auto_compaction_input_tokens_threshold
+        {
+            return None;
         }
-    }
 
-    fn record_assistant_iteration(
-        &self,
-        iteration: usize,
-        assistant_message: &ConversationMessage,
-        pending_tool_count: usize,
-    ) {
-        if let Some(tracer) = &self.session_tracer {
-            let mut attributes = Map::new();
-            attributes.insert(
-                "iteration".to_string(),
-                Value::from(u64::try_from(iteration).unwrap_or(u64::MAX)),
-            );
-            attributes.insert(
-                "block_count".to_string(),
-                Value::from(u64::try_from(assistant_message.blocks.len()).unwrap_or(u64::MAX)),
-            );
-            attributes.insert(
-                "pending_tool_count".to_string(),
-                Value::from(u64::try_from(pending_tool_count).unwrap_or(u64::MAX)),
-            );
-            tracer.record("assistant_iteration_completed", attributes);
-        }
-    }
-
-    fn record_tool_started(&self, iteration: usize, tool_name: &str) {
-        if let Some(tracer) = &self.session_tracer {
-            let mut attributes = Map::new();
-            attributes.insert(
-                "iteration".to_string(),
-                Value::from(u64::try_from(iteration).unwrap_or(u64::MAX)),
-            );
-            attributes.insert(
-                "tool_name".to_string(),
-                Value::String(tool_name.to_string()),
-            );
-            tracer.record("tool_execution_started", attributes);
-        }
-    }
-
-    fn record_tool_finished(&self, iteration: usize, result_message: &ConversationMessage) {
-        let Some(tracer) = &self.session_tracer else {
-            return;
-        };
-        let Some(ContentBlock::ToolResult {
-            tool_name,
-            is_error,
-            output,
-            ..
-        }) = result_message.blocks.first()
-        else {
-            return;
-        };
-        let mut attributes = Map::new();
-        attributes.insert(
-            "iteration".to_string(),
-            Value::from(u64::try_from(iteration).unwrap_or(u64::MAX)),
+        let result = compact_session(
+            &self.session,
+            CompactionConfig {
+                max_estimated_tokens: 0,
+                ..CompactionConfig::default()
+            },
         );
-        attributes.insert("tool_name".to_string(), Value::String(tool_name.clone()));
-        attributes.insert("is_error".to_string(), Value::Bool(*is_error));
-        attributes.insert(
-            "output_chars".to_string(),
-            Value::from(u64::try_from(output.chars().count()).unwrap_or(u64::MAX)),
-        );
-        tracer.record("tool_execution_finished", attributes);
-    }
 
-    fn record_turn_completed(&self, summary: &TurnSummary) {
-        if let Some(tracer) = &self.session_tracer {
-            let mut attributes = Map::new();
-            attributes.insert(
-                "assistant_message_count".to_string(),
-                Value::from(u64::try_from(summary.assistant_messages.len()).unwrap_or(u64::MAX)),
-            );
-            attributes.insert(
-                "tool_result_count".to_string(),
-                Value::from(u64::try_from(summary.tool_results.len()).unwrap_or(u64::MAX)),
-            );
-            attributes.insert(
-                "iterations".to_string(),
-                Value::from(u64::try_from(summary.iterations).unwrap_or(u64::MAX)),
-            );
-            attributes.insert(
-                "total_input_tokens".to_string(),
-                Value::from(summary.usage.input_tokens),
-            );
-            attributes.insert(
-                "total_output_tokens".to_string(),
-                Value::from(summary.usage.output_tokens),
-            );
-            tracer.record("turn_completed", attributes);
+        if result.removed_message_count == 0 {
+            return None;
         }
-    }
 
-    fn record_turn_failed(&self, iteration: usize, error: &RuntimeError) {
-        if let Some(tracer) = &self.session_tracer {
-            let mut attributes = Map::new();
-            attributes.insert(
-                "iteration".to_string(),
-                Value::from(u64::try_from(iteration).unwrap_or(u64::MAX)),
-            );
-            attributes.insert("error".to_string(), Value::String(error.to_string()));
-            tracer.record("turn_failed", attributes);
-        }
+        self.session = result.compacted_session;
+        Some(AutoCompactionEvent {
+            removed_message_count: result.removed_message_count,
+        })
     }
 }
 
+#[must_use]
+pub fn auto_compaction_threshold_from_env() -> u32 {
+    parse_auto_compaction_threshold(
+        std::env::var(AUTO_COMPACTION_THRESHOLD_ENV_VAR)
+            .ok()
+            .as_deref(),
+    )
+}
+
+#[must_use]
+fn parse_auto_compaction_threshold(value: Option<&str>) -> u32 {
+    value
+        .and_then(|raw| raw.trim().parse::<u32>().ok())
+        .filter(|threshold| *threshold > 0)
+        .unwrap_or(DEFAULT_AUTO_COMPACTION_INPUT_TOKENS_THRESHOLD)
+}
+
 fn build_assistant_message(
     events: Vec<AssistantEvent>,
 ) -> Result<(ConversationMessage, Option<TokenUsage>), RuntimeError> {
@@ -492,32 +352,6 @@ fn flush_text_block(text: &mut String, blocks: &mut Vec<ContentBlock>) {
     }
 }
 
-fn format_hook_message(result: &HookRunResult, fallback: &str) -> String {
-    if result.messages().is_empty() {
-        fallback.to_string()
-    } else {
-        result.messages().join("\n")
-    }
-}
-
-fn merge_hook_feedback(messages: &[String], output: String, denied: bool) -> String {
-    if messages.is_empty() {
-        return output;
-    }
-
-    let mut sections = Vec::new();
-    if !output.trim().is_empty() {
-        sections.push(output);
-    }
-    let label = if denied {
-        "Hook feedback (denied)"
-    } else {
-        "Hook feedback"
-    };
-    sections.push(format!("{label}:\n{}", messages.join("\n")));
-    sections.join("\n\n")
-}
-
 type ToolHandler = Box<dyn FnMut(&str) -> Result<String, ToolError>>;
 
 #[derive(Default)]
@@ -553,11 +387,11 @@ impl ToolExecutor for StaticToolExecutor {
 #[cfg(test)]
 mod tests {
     use super::{
-        ApiClient, ApiRequest, AssistantEvent, ConversationRuntime, RuntimeError,
-        StaticToolExecutor,
+        parse_auto_compaction_threshold, ApiClient, ApiRequest, AssistantEvent,
+        AutoCompactionEvent, ConversationRuntime, RuntimeError, StaticToolExecutor,
+        DEFAULT_AUTO_COMPACTION_INPUT_TOKENS_THRESHOLD,
     };
     use crate::compact::CompactionConfig;
-    use crate::config::{RuntimeFeatureConfig, RuntimeHookConfig};
     use crate::permissions::{
         PermissionMode, PermissionPolicy, PermissionPromptDecision, PermissionPrompter,
         PermissionRequest,
@@ -566,8 +400,6 @@ mod tests {
     use crate::session::{ContentBlock, MessageRole, Session};
     use crate::usage::TokenUsage;
     use std::path::PathBuf;
-    use std::sync::Arc;
-    use telemetry::{MemoryTelemetrySink, SessionTracer, TelemetryEvent};
 
     struct ScriptedApiClient {
         call_count: usize,
@@ -667,6 +499,7 @@ mod tests {
         assert_eq!(summary.tool_results.len(), 1);
         assert_eq!(runtime.session().messages.len(), 4);
         assert_eq!(summary.usage.output_tokens, 10);
+        assert_eq!(summary.auto_compaction, None);
         assert!(matches!(
             runtime.session().messages[1].blocks[1],
             ContentBlock::ToolUse { .. }
@@ -680,39 +513,6 @@ mod tests {
         ));
     }
 
-    #[test]
-    fn records_runtime_session_trace_events() {
-        let sink = Arc::new(MemoryTelemetrySink::default());
-        let tracer = SessionTracer::new("session-runtime", sink.clone());
-        let mut runtime = ConversationRuntime::new(
-            Session::new(),
-            ScriptedApiClient { call_count: 0 },
-            StaticToolExecutor::new().register("add", |_input| Ok("4".to_string())),
-            PermissionPolicy::new(PermissionMode::WorkspaceWrite),
-            vec!["system".to_string()],
-        )
-        .with_session_tracer(tracer);
-
-        runtime
-            .run_turn("what is 2 + 2?", Some(&mut PromptAllowOnce))
-            .expect("conversation loop should succeed");
-
-        let events = sink.events();
-        let trace_names = events
-            .iter()
-            .filter_map(|event| match event {
-                TelemetryEvent::SessionTrace(trace) => Some(trace.name.as_str()),
-                _ => None,
-            })
-            .collect::<Vec<_>>();
-
-        assert!(trace_names.contains(&"turn_started"));
-        assert!(trace_names.contains(&"assistant_iteration_completed"));
-        assert!(trace_names.contains(&"tool_execution_started"));
-        assert!(trace_names.contains(&"tool_execution_finished"));
-        assert!(trace_names.contains(&"turn_completed"));
-    }
-
     #[test]
     fn records_denied_tool_results_when_prompt_rejects() {
         struct RejectPrompter;
@@ -767,141 +567,6 @@ mod tests {
         ));
     }
 
-    #[test]
-    fn denies_tool_use_when_pre_tool_hook_blocks() {
-        struct SingleCallApiClient;
-        impl ApiClient for SingleCallApiClient {
-            fn stream(&mut self, request: ApiRequest) -> Result<Vec<AssistantEvent>, RuntimeError> {
-                if request
-                    .messages
-                    .iter()
-                    .any(|message| message.role == MessageRole::Tool)
-                {
-                    return Ok(vec![
-                        AssistantEvent::TextDelta("blocked".to_string()),
-                        AssistantEvent::MessageStop,
-                    ]);
-                }
-                Ok(vec![
-                    AssistantEvent::ToolUse {
-                        id: "tool-1".to_string(),
-                        name: "blocked".to_string(),
-                        input: r#"{"path":"secret.txt"}"#.to_string(),
-                    },
-                    AssistantEvent::MessageStop,
-                ])
-            }
-        }
-
-        let mut runtime = ConversationRuntime::new_with_features(
-            Session::new(),
-            SingleCallApiClient,
-            StaticToolExecutor::new().register("blocked", |_input| {
-                panic!("tool should not execute when hook denies")
-            }),
-            PermissionPolicy::new(PermissionMode::DangerFullAccess),
-            vec!["system".to_string()],
-            &RuntimeFeatureConfig::default().with_hooks(RuntimeHookConfig::new(
-                vec![shell_snippet("printf 'blocked by hook'; exit 2")],
-                Vec::new(),
-            )),
-        );
-
-        let summary = runtime
-            .run_turn("use the tool", None)
-            .expect("conversation should continue after hook denial");
-
-        assert_eq!(summary.tool_results.len(), 1);
-        let ContentBlock::ToolResult {
-            is_error, output, ..
-        } = &summary.tool_results[0].blocks[0]
-        else {
-            panic!("expected tool result block");
-        };
-        assert!(
-            *is_error,
-            "hook denial should produce an error result: {output}"
-        );
-        assert!(
-            output.contains("denied tool") || output.contains("blocked by hook"),
-            "unexpected hook denial output: {output:?}"
-        );
-    }
-
-    #[test]
-    fn appends_post_tool_hook_feedback_to_tool_result() {
-        struct TwoCallApiClient {
-            calls: usize,
-        }
-
-        impl ApiClient for TwoCallApiClient {
-            fn stream(&mut self, request: ApiRequest) -> Result<Vec<AssistantEvent>, RuntimeError> {
-                self.calls += 1;
-                match self.calls {
-                    1 => Ok(vec![
-                        AssistantEvent::ToolUse {
-                            id: "tool-1".to_string(),
-                            name: "add".to_string(),
-                            input: r#"{"lhs":2,"rhs":2}"#.to_string(),
-                        },
-                        AssistantEvent::MessageStop,
-                    ]),
-                    2 => {
-                        assert!(request
-                            .messages
-                            .iter()
-                            .any(|message| message.role == MessageRole::Tool));
-                        Ok(vec![
-                            AssistantEvent::TextDelta("done".to_string()),
-                            AssistantEvent::MessageStop,
-                        ])
-                    }
-                    _ => Err(RuntimeError::new("unexpected extra API call")),
-                }
-            }
-        }
-
-        let mut runtime = ConversationRuntime::new_with_features(
-            Session::new(),
-            TwoCallApiClient { calls: 0 },
-            StaticToolExecutor::new().register("add", |_input| Ok("4".to_string())),
-            PermissionPolicy::new(PermissionMode::DangerFullAccess),
-            vec!["system".to_string()],
-            &RuntimeFeatureConfig::default().with_hooks(RuntimeHookConfig::new(
-                vec![shell_snippet("printf 'pre hook ran'")],
-                vec![shell_snippet("printf 'post hook ran'")],
-            )),
-        );
-
-        let summary = runtime
-            .run_turn("use add", None)
-            .expect("tool loop succeeds");
-
-        assert_eq!(summary.tool_results.len(), 1);
-        let ContentBlock::ToolResult {
-            is_error, output, ..
-        } = &summary.tool_results[0].blocks[0]
-        else {
-            panic!("expected tool result block");
-        };
-        assert!(
-            !*is_error,
-            "post hook should preserve non-error result: {output:?}"
-        );
-        assert!(
-            output.contains('4'),
-            "tool output missing value: {output:?}"
-        );
-        assert!(
-            output.contains("pre hook ran"),
-            "tool output missing pre hook feedback: {output:?}"
-        );
-        assert!(
-            output.contains("post hook ran"),
-            "tool output missing post hook feedback: {output:?}"
-        );
-    }
-
     #[test]
     fn reconstructs_usage_tracker_from_restored_session() {
         struct SimpleApi;
@@ -981,13 +646,110 @@ mod tests {
         );
     }
 
-    #[cfg(windows)]
-    fn shell_snippet(script: &str) -> String {
-        script.replace('\'', "\"")
+    #[test]
+    fn auto_compacts_when_cumulative_input_threshold_is_crossed() {
+        struct SimpleApi;
+        impl ApiClient for SimpleApi {
+            fn stream(
+                &mut self,
+                _request: ApiRequest,
+            ) -> Result<Vec<AssistantEvent>, RuntimeError> {
+                Ok(vec![
+                    AssistantEvent::TextDelta("done".to_string()),
+                    AssistantEvent::Usage(TokenUsage {
+                        input_tokens: 120_000,
+                        output_tokens: 4,
+                        cache_creation_input_tokens: 0,
+                        cache_read_input_tokens: 0,
+                    }),
+                    AssistantEvent::MessageStop,
+                ])
+            }
+        }
+
+        let session = Session {
+            version: 1,
+            messages: vec![
+                crate::session::ConversationMessage::user_text("one"),
+                crate::session::ConversationMessage::assistant(vec![ContentBlock::Text {
+                    text: "two".to_string(),
+                }]),
+                crate::session::ConversationMessage::user_text("three"),
+                crate::session::ConversationMessage::assistant(vec![ContentBlock::Text {
+                    text: "four".to_string(),
+                }]),
+            ],
+        };
+
+        let mut runtime = ConversationRuntime::new(
+            session,
+            SimpleApi,
+            StaticToolExecutor::new(),
+            PermissionPolicy::new(PermissionMode::DangerFullAccess),
+            vec!["system".to_string()],
+        )
+        .with_auto_compaction_input_tokens_threshold(100_000);
+
+        let summary = runtime
+            .run_turn("trigger", None)
+            .expect("turn should succeed");
+
+        assert_eq!(
+            summary.auto_compaction,
+            Some(AutoCompactionEvent {
+                removed_message_count: 2,
+            })
+        );
+        assert_eq!(runtime.session().messages[0].role, MessageRole::System);
     }
 
-    #[cfg(not(windows))]
-    fn shell_snippet(script: &str) -> String {
-        script.to_string()
+    #[test]
+    fn skips_auto_compaction_below_threshold() {
+        struct SimpleApi;
+        impl ApiClient for SimpleApi {
+            fn stream(
+                &mut self,
+                _request: ApiRequest,
+            ) -> Result<Vec<AssistantEvent>, RuntimeError> {
+                Ok(vec![
+                    AssistantEvent::TextDelta("done".to_string()),
+                    AssistantEvent::Usage(TokenUsage {
+                        input_tokens: 99_999,
+                        output_tokens: 4,
+                        cache_creation_input_tokens: 0,
+                        cache_read_input_tokens: 0,
+                    }),
+                    AssistantEvent::MessageStop,
+                ])
+            }
+        }
+
+        let mut runtime = ConversationRuntime::new(
+            Session::new(),
+            SimpleApi,
+            StaticToolExecutor::new(),
+            PermissionPolicy::new(PermissionMode::DangerFullAccess),
+            vec!["system".to_string()],
+        )
+        .with_auto_compaction_input_tokens_threshold(100_000);
+
+        let summary = runtime
+            .run_turn("trigger", None)
+            .expect("turn should succeed");
+        assert_eq!(summary.auto_compaction, None);
+        assert_eq!(runtime.session().messages.len(), 2);
+    }
+
+    #[test]
+    fn auto_compaction_threshold_defaults_and_parses_values() {
+        assert_eq!(
+            parse_auto_compaction_threshold(None),
+            DEFAULT_AUTO_COMPACTION_INPUT_TOKENS_THRESHOLD
+        );
+        assert_eq!(parse_auto_compaction_threshold(Some("4321")), 4321);
+        assert_eq!(
+            parse_auto_compaction_threshold(Some("not-a-number")),
+            DEFAULT_AUTO_COMPACTION_INPUT_TOKENS_THRESHOLD
+        );
     }
 }

rust/crates/runtime/src/hooks.rs

@@ -1,353 +0,0 @@
-use std::ffi::OsStr;
-use std::process::Command;
-
-use serde_json::json;
-
-use crate::config::{RuntimeFeatureConfig, RuntimeHookConfig};
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum HookEvent {
-    PreToolUse,
-    PostToolUse,
-}
-
-impl HookEvent {
-    fn as_str(self) -> &'static str {
-        match self {
-            Self::PreToolUse => "PreToolUse",
-            Self::PostToolUse => "PostToolUse",
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct HookRunResult {
-    denied: bool,
-    messages: Vec<String>,
-}
-
-impl HookRunResult {
-    #[must_use]
-    pub fn allow(messages: Vec<String>) -> Self {
-        Self {
-            denied: false,
-            messages,
-        }
-    }
-
-    #[must_use]
-    pub fn is_denied(&self) -> bool {
-        self.denied
-    }
-
-    #[must_use]
-    pub fn messages(&self) -> &[String] {
-        &self.messages
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Default)]
-pub struct HookRunner {
-    config: RuntimeHookConfig,
-}
-
-impl HookRunner {
-    #[must_use]
-    pub fn new(config: RuntimeHookConfig) -> Self {
-        Self { config }
-    }
-
-    #[must_use]
-    pub fn from_feature_config(feature_config: &RuntimeFeatureConfig) -> Self {
-        Self::new(feature_config.hooks().clone())
-    }
-
-    #[must_use]
-    pub fn run_pre_tool_use(&self, tool_name: &str, tool_input: &str) -> HookRunResult {
-        Self::run_commands(
-            HookEvent::PreToolUse,
-            self.config.pre_tool_use(),
-            tool_name,
-            tool_input,
-            None,
-            false,
-        )
-    }
-
-    #[must_use]
-    pub fn run_post_tool_use(
-        &self,
-        tool_name: &str,
-        tool_input: &str,
-        tool_output: &str,
-        is_error: bool,
-    ) -> HookRunResult {
-        Self::run_commands(
-            HookEvent::PostToolUse,
-            self.config.post_tool_use(),
-            tool_name,
-            tool_input,
-            Some(tool_output),
-            is_error,
-        )
-    }
-
-    fn run_commands(
-        event: HookEvent,
-        commands: &[String],
-        tool_name: &str,
-        tool_input: &str,
-        tool_output: Option<&str>,
-        is_error: bool,
-    ) -> HookRunResult {
-        if commands.is_empty() {
-            return HookRunResult::allow(Vec::new());
-        }
-
-        let payload = json!({
-            "hook_event_name": event.as_str(),
-            "tool_name": tool_name,
-            "tool_input": parse_tool_input(tool_input),
-            "tool_input_json": tool_input,
-            "tool_output": tool_output,
-            "tool_result_is_error": is_error,
-        })
-        .to_string();
-        let invocation = HookInvocation {
-            event,
-            tool_name,
-            tool_input,
-            tool_output,
-            is_error,
-            payload: &payload,
-        };
-
-        let mut messages = Vec::new();
-
-        for command in commands {
-            match Self::run_command(command, &invocation) {
-                HookCommandOutcome::Allow { message } => {
-                    if let Some(message) = message {
-                        messages.push(message);
-                    }
-                }
-                HookCommandOutcome::Deny { message } => {
-                    let message = message.unwrap_or_else(|| {
-                        format!("{} hook denied tool `{tool_name}`", event.as_str())
-                    });
-                    messages.push(message);
-                    return HookRunResult {
-                        denied: true,
-                        messages,
-                    };
-                }
-                HookCommandOutcome::Warn { message } => messages.push(message),
-            }
-        }
-
-        HookRunResult::allow(messages)
-    }
-
-    fn run_command(command: &str, invocation: &HookInvocation<'_>) -> HookCommandOutcome {
-        let mut child = shell_command(command);
-        child.stdin(std::process::Stdio::piped());
-        child.stdout(std::process::Stdio::piped());
-        child.stderr(std::process::Stdio::piped());
-        child.env("HOOK_EVENT", invocation.event.as_str());
-        child.env("HOOK_TOOL_NAME", invocation.tool_name);
-        child.env("HOOK_TOOL_INPUT", invocation.tool_input);
-        child.env(
-            "HOOK_TOOL_IS_ERROR",
-            if invocation.is_error { "1" } else { "0" },
-        );
-        if let Some(tool_output) = invocation.tool_output {
-            child.env("HOOK_TOOL_OUTPUT", tool_output);
-        }
-
-        match child.output_with_stdin(invocation.payload.as_bytes()) {
-            Ok(output) => {
-                let stdout = String::from_utf8_lossy(&output.stdout).trim().to_string();
-                let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
-                let message = (!stdout.is_empty()).then_some(stdout);
-                match output.status.code() {
-                    Some(0) => HookCommandOutcome::Allow { message },
-                    Some(2) => HookCommandOutcome::Deny { message },
-                    Some(code) => HookCommandOutcome::Warn {
-                        message: format_hook_warning(
-                            command,
-                            code,
-                            message.as_deref(),
-                            stderr.as_str(),
-                        ),
-                    },
-                    None => HookCommandOutcome::Warn {
-                        message: format!(
-                            "{} hook `{command}` terminated by signal while handling `{}`",
-                            invocation.event.as_str(),
-                            invocation.tool_name
-                        ),
-                    },
-                }
-            }
-            Err(error) => HookCommandOutcome::Warn {
-                message: format!(
-                    "{} hook `{command}` failed to start for `{tool_name}`: {error}",
-                    invocation.event.as_str(),
-                    tool_name = invocation.tool_name
-                ),
-            },
-        }
-    }
-}
-
-struct HookInvocation<'a> {
-    event: HookEvent,
-    tool_name: &'a str,
-    tool_input: &'a str,
-    tool_output: Option<&'a str>,
-    is_error: bool,
-    payload: &'a str,
-}
-
-enum HookCommandOutcome {
-    Allow { message: Option<String> },
-    Deny { message: Option<String> },
-    Warn { message: String },
-}
-
-fn parse_tool_input(tool_input: &str) -> serde_json::Value {
-    serde_json::from_str(tool_input).unwrap_or_else(|_| json!({ "raw": tool_input }))
-}
-
-fn format_hook_warning(command: &str, code: i32, stdout: Option<&str>, stderr: &str) -> String {
-    let mut message =
-        format!("Hook `{command}` exited with status {code}; allowing tool execution to continue");
-    if let Some(stdout) = stdout.filter(|stdout| !stdout.is_empty()) {
-        message.push_str(": ");
-        message.push_str(stdout);
-    } else if !stderr.is_empty() {
-        message.push_str(": ");
-        message.push_str(stderr);
-    }
-    message
-}
-
-fn shell_command(command: &str) -> CommandWithStdin {
-    #[cfg(windows)]
-    let mut command_builder = {
-        let mut command_builder = Command::new("cmd");
-        command_builder.arg("/C").arg(command);
-        CommandWithStdin::new(command_builder)
-    };
-
-    #[cfg(not(windows))]
-    let command_builder = {
-        let mut command_builder = Command::new("sh");
-        command_builder.arg("-lc").arg(command);
-        CommandWithStdin::new(command_builder)
-    };
-
-    command_builder
-}
-
-struct CommandWithStdin {
-    command: Command,
-}
-
-impl CommandWithStdin {
-    fn new(command: Command) -> Self {
-        Self { command }
-    }
-
-    fn stdin(&mut self, cfg: std::process::Stdio) -> &mut Self {
-        self.command.stdin(cfg);
-        self
-    }
-
-    fn stdout(&mut self, cfg: std::process::Stdio) -> &mut Self {
-        self.command.stdout(cfg);
-        self
-    }
-
-    fn stderr(&mut self, cfg: std::process::Stdio) -> &mut Self {
-        self.command.stderr(cfg);
-        self
-    }
-
-    fn env<K, V>(&mut self, key: K, value: V) -> &mut Self
-    where
-        K: AsRef<OsStr>,
-        V: AsRef<OsStr>,
-    {
-        self.command.env(key, value);
-        self
-    }
-
-    fn output_with_stdin(&mut self, stdin: &[u8]) -> std::io::Result<std::process::Output> {
-        let mut child = self.command.spawn()?;
-        if let Some(mut child_stdin) = child.stdin.take() {
-            use std::io::Write;
-            child_stdin.write_all(stdin)?;
-        }
-        child.wait_with_output()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{HookRunResult, HookRunner};
-    use crate::config::{RuntimeFeatureConfig, RuntimeHookConfig};
-
-    #[test]
-    fn allows_exit_code_zero_and_captures_stdout() {
-        let runner = HookRunner::new(RuntimeHookConfig::new(
-            vec![shell_snippet("printf 'pre ok'")],
-            Vec::new(),
-        ));
-
-        let result = runner.run_pre_tool_use("Read", r#"{"path":"README.md"}"#);
-
-        assert_eq!(result, HookRunResult::allow(vec!["pre ok".to_string()]));
-    }
-
-    #[test]
-    fn denies_exit_code_two() {
-        let runner = HookRunner::new(RuntimeHookConfig::new(
-            vec![shell_snippet("printf 'blocked by hook'; exit 2")],
-            Vec::new(),
-        ));
-
-        let result = runner.run_pre_tool_use("Bash", r#"{"command":"pwd"}"#);
-
-        assert!(result.is_denied());
-        assert_eq!(result.messages(), &["blocked by hook".to_string()]);
-    }
-
-    #[test]
-    fn warns_for_other_non_zero_statuses() {
-        let runner = HookRunner::from_feature_config(&RuntimeFeatureConfig::default().with_hooks(
-            RuntimeHookConfig::new(
-                vec![shell_snippet("printf 'warning hook'; exit 1")],
-                Vec::new(),
-            ),
-        ));
-
-        let result = runner.run_pre_tool_use("Edit", r#"{"file":"src/lib.rs"}"#);
-
-        assert!(!result.is_denied());
-        assert!(result
-            .messages()
-            .iter()
-            .any(|message| message.contains("allowing tool execution to continue")));
-    }
-
-    #[cfg(windows)]
-    fn shell_snippet(script: &str) -> String {
-        script.replace('\'', "\"")
-    }
-
-    #[cfg(not(windows))]
-    fn shell_snippet(script: &str) -> String {
-        script.to_string()
-    }
-}

rust/crates/runtime/src/lib.rs

@@ -4,7 +4,6 @@ mod compact;
 mod config;
 mod conversation;
 mod file_ops;
-mod hooks;
 mod json;
 mod mcp;
 mod mcp_client;
@@ -27,19 +26,18 @@ pub use config::{
     ConfigEntry, ConfigError, ConfigLoader, ConfigSource, McpClaudeAiProxyServerConfig,
     McpConfigCollection, McpOAuthConfig, McpRemoteServerConfig, McpSdkServerConfig,
     McpServerConfig, McpStdioServerConfig, McpTransport, McpWebSocketServerConfig, OAuthConfig,
-    ResolvedPermissionMode, RuntimeConfig, RuntimeFeatureConfig, RuntimeHookConfig,
-    ScopedMcpServerConfig, CLAUDE_CODE_SETTINGS_SCHEMA_NAME,
+    ResolvedPermissionMode, RuntimeConfig, RuntimeFeatureConfig, ScopedMcpServerConfig,
+    CLAUDE_CODE_SETTINGS_SCHEMA_NAME,
 };
 pub use conversation::{
-    ApiClient, ApiRequest, AssistantEvent, ConversationRuntime, RuntimeError, StaticToolExecutor,
-    ToolError, ToolExecutor, TurnSummary,
+    auto_compaction_threshold_from_env, ApiClient, ApiRequest, AssistantEvent, AutoCompactionEvent,
+    ConversationRuntime, RuntimeError, StaticToolExecutor, ToolError, ToolExecutor, TurnSummary,
 };
 pub use file_ops::{
     edit_file, glob_search, grep_search, read_file, write_file, EditFileOutput, GlobSearchOutput,
     GrepSearchInput, GrepSearchOutput, ReadFileOutput, StructuredPatchHunk, TextFilePayload,
     WriteFileOutput,
 };
-pub use hooks::{HookEvent, HookRunResult, HookRunner};
 pub use mcp::{
     mcp_server_signature, mcp_tool_name, mcp_tool_prefix, normalize_name_for_mcp,
     scoped_mcp_config_hash, unwrap_ccr_proxy_url,

rust/crates/runtime/src/mcp_stdio.rs

@@ -1144,20 +1144,8 @@ mod tests {
     }
 
     fn cleanup_script(script_path: &Path) {
-        if let Err(error) = fs::remove_file(script_path) {
-            assert_eq!(
-                error.kind(),
-                std::io::ErrorKind::NotFound,
-                "cleanup script: {error}"
-            );
-        }
-        if let Err(error) = fs::remove_dir_all(script_path.parent().expect("script parent")) {
-            assert_eq!(
-                error.kind(),
-                std::io::ErrorKind::NotFound,
-                "cleanup dir: {error}"
-            );
-        }
+        fs::remove_file(script_path).expect("cleanup script");
+        fs::remove_dir_all(script_path.parent().expect("script parent")).expect("cleanup dir");
     }
 
     fn manager_server_config(

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

@@ -4,7 +4,6 @@ mod render;
 
 use std::collections::{BTreeMap, BTreeSet};
 use std::env;
-use std::fmt::Write as _;
 use std::fs;
 use std::io::{self, Read, Write};
 use std::net::TcpListener;
@@ -14,9 +13,8 @@ use std::time::{SystemTime, UNIX_EPOCH};
 
 use api::{
     resolve_startup_auth_source, AnthropicClient, AuthSource, ContentBlockDelta, InputContentBlock,
-    InputMessage, JsonlTelemetrySink, MessageRequest, MessageResponse, OutputContentBlock,
-    SessionTracer, StreamEvent as ApiStreamEvent, ToolChoice, ToolDefinition,
-    ToolResultContentBlock,
+    InputMessage, MessageRequest, MessageResponse, OutputContentBlock,
+    StreamEvent as ApiStreamEvent, ToolChoice, ToolDefinition, ToolResultContentBlock,
 };
 
 use commands::{
@@ -46,7 +44,6 @@ fn max_tokens_for_model(model: &str) -> u32 {
 }
 const DEFAULT_DATE: &str = "2026-03-31";
 const DEFAULT_OAUTH_CALLBACK_PORT: u16 = 4545;
-const TELEMETRY_LOG_PATH_ENV: &str = "CLAW_TELEMETRY_LOG_PATH";
 const VERSION: &str = env!("CARGO_PKG_VERSION");
 const BUILD_TARGET: Option<&str> = option_env!("TARGET");
 const GIT_SHA: Option<&str> = option_env!("GIT_SHA");
@@ -778,6 +775,10 @@ fn format_compact_report(removed: usize, resulting_messages: usize, skipped: boo
     }
 }
 
+fn format_auto_compaction_notice(removed: usize) -> String {
+    format!("[auto-compacted: removed {removed} messages]")
+}
+
 fn parse_git_status_metadata(status: Option<&str>) -> (Option<PathBuf>, Option<String>) {
     let Some(status) = status else {
         return (None, None);
@@ -916,7 +917,14 @@ fn run_resume_command(
                 )),
             })
         }
-        SlashCommand::Resume { .. }
+        SlashCommand::Bughunter { .. }
+        | SlashCommand::Commit
+        | SlashCommand::Pr { .. }
+        | SlashCommand::Issue { .. }
+        | SlashCommand::Ultraplan { .. }
+        | SlashCommand::Teleport { .. }
+        | SlashCommand::DebugToolCall
+        | SlashCommand::Resume { .. }
         | SlashCommand::Model { .. }
         | SlashCommand::Permissions { .. }
         | SlashCommand::Session { .. }
@@ -998,7 +1006,6 @@ impl LiveCli {
         let session = create_managed_session_handle()?;
         let runtime = build_runtime(
             Session::new(),
-            &session.id,
             model.clone(),
             system_prompt.clone(),
             enable_tools,
@@ -1054,13 +1061,19 @@ impl LiveCli {
         let mut permission_prompter = CliPermissionPrompter::new(self.permission_mode);
         let result = self.runtime.run_turn(input, Some(&mut permission_prompter));
         match result {
-            Ok(_) => {
+            Ok(summary) => {
                 spinner.finish(
                     "✨ Done",
                     TerminalRenderer::new().color_theme(),
                     &mut stdout,
                 )?;
                 println!();
+                if let Some(event) = summary.auto_compaction {
+                    println!(
+                        "{}",
+                        format_auto_compaction_notice(event.removed_message_count)
+                    );
+                }
                 self.persist_session()?;
                 Ok(())
             }
@@ -1090,7 +1103,6 @@ impl LiveCli {
         let session = self.runtime.session().clone();
         let mut runtime = build_runtime(
             session,
-            &self.session.id,
             self.model.clone(),
             self.system_prompt.clone(),
             true,
@@ -1108,6 +1120,10 @@ impl LiveCli {
                 "message": final_assistant_text(&summary),
                 "model": self.model,
                 "iterations": summary.iterations,
+                "auto_compaction": summary.auto_compaction.map(|event| json!({
+                    "removed_messages": event.removed_message_count,
+                    "notice": format_auto_compaction_notice(event.removed_message_count),
+                })),
                 "tool_uses": collect_tool_uses(&summary),
                 "tool_results": collect_tool_results(&summary),
                 "usage": {
@@ -1134,6 +1150,34 @@ impl LiveCli {
                 self.print_status();
                 false
             }
+            SlashCommand::Bughunter { scope } => {
+                self.run_bughunter(scope.as_deref())?;
+                false
+            }
+            SlashCommand::Commit => {
+                self.run_commit()?;
+                true
+            }
+            SlashCommand::Pr { context } => {
+                self.run_pr(context.as_deref())?;
+                false
+            }
+            SlashCommand::Issue { context } => {
+                self.run_issue(context.as_deref())?;
+                false
+            }
+            SlashCommand::Ultraplan { task } => {
+                self.run_ultraplan(task.as_deref())?;
+                false
+            }
+            SlashCommand::Teleport { target } => {
+                self.run_teleport(target.as_deref())?;
+                false
+            }
+            SlashCommand::DebugToolCall => {
+                self.run_debug_tool_call()?;
+                false
+            }
             SlashCommand::Compact => {
                 self.compact()?;
                 false
@@ -1237,7 +1281,6 @@ impl LiveCli {
         let message_count = session.messages.len();
         self.runtime = build_runtime(
             session,
-            &self.session.id,
             model.clone(),
             self.system_prompt.clone(),
             true,
@@ -1281,7 +1324,6 @@ impl LiveCli {
         self.permission_mode = permission_mode_from_label(normalized);
         self.runtime = build_runtime(
             session,
-            &self.session.id,
             self.model.clone(),
             self.system_prompt.clone(),
             true,
@@ -1307,7 +1349,6 @@ impl LiveCli {
         self.session = create_managed_session_handle()?;
         self.runtime = build_runtime(
             Session::new(),
-            &self.session.id,
             self.model.clone(),
             self.system_prompt.clone(),
             true,
@@ -1343,7 +1384,6 @@ impl LiveCli {
         let message_count = session.messages.len();
         self.runtime = build_runtime(
             session,
-            &handle.id,
             self.model.clone(),
             self.system_prompt.clone(),
             true,
@@ -1416,7 +1456,6 @@ impl LiveCli {
                 let message_count = session.messages.len();
                 self.runtime = build_runtime(
                     session,
-                    &handle.id,
                     self.model.clone(),
                     self.system_prompt.clone(),
                     true,
@@ -1447,7 +1486,6 @@ impl LiveCli {
         let skipped = removed == 0;
         self.runtime = build_runtime(
             result.compacted_session,
-            &self.session.id,
             self.model.clone(),
             self.system_prompt.clone(),
             true,
@@ -1459,6 +1497,160 @@ impl LiveCli {
         println!("{}", format_compact_report(removed, kept, skipped));
         Ok(())
     }
+
+    fn run_internal_prompt_text(
+        &self,
+        prompt: &str,
+        enable_tools: bool,
+    ) -> Result<String, Box<dyn std::error::Error>> {
+        let session = self.runtime.session().clone();
+        let mut runtime = build_runtime(
+            session,
+            self.model.clone(),
+            self.system_prompt.clone(),
+            enable_tools,
+            false,
+            self.allowed_tools.clone(),
+            self.permission_mode,
+        )?;
+        let mut permission_prompter = CliPermissionPrompter::new(self.permission_mode);
+        let summary = runtime.run_turn(prompt, Some(&mut permission_prompter))?;
+        Ok(final_assistant_text(&summary).trim().to_string())
+    }
+
+    fn run_bughunter(&self, scope: Option<&str>) -> Result<(), Box<dyn std::error::Error>> {
+        let scope = scope.unwrap_or("the current repository");
+        let prompt = format!(
+            "You are /bughunter. Inspect {scope} and identify the most likely bugs or correctness issues. Prioritize concrete findings with file paths, severity, and suggested fixes. Use tools if needed."
+        );
+        println!("{}", self.run_internal_prompt_text(&prompt, true)?);
+        Ok(())
+    }
+
+    fn run_ultraplan(&self, task: Option<&str>) -> Result<(), Box<dyn std::error::Error>> {
+        let task = task.unwrap_or("the current repo work");
+        let prompt = format!(
+            "You are /ultraplan. Produce a deep multi-step execution plan for {task}. Include goals, risks, implementation sequence, verification steps, and rollback considerations. Use tools if needed."
+        );
+        println!("{}", self.run_internal_prompt_text(&prompt, true)?);
+        Ok(())
+    }
+
+    fn run_teleport(&self, target: Option<&str>) -> Result<(), Box<dyn std::error::Error>> {
+        let Some(target) = target.map(str::trim).filter(|value| !value.is_empty()) else {
+            println!("Usage: /teleport <symbol-or-path>");
+            return Ok(());
+        };
+
+        println!("{}", render_teleport_report(target)?);
+        Ok(())
+    }
+
+    fn run_debug_tool_call(&self) -> Result<(), Box<dyn std::error::Error>> {
+        println!("{}", render_last_tool_debug_report(self.runtime.session())?);
+        Ok(())
+    }
+
+    fn run_commit(&mut self) -> Result<(), Box<dyn std::error::Error>> {
+        let status = git_output(&["status", "--short"])?;
+        if status.trim().is_empty() {
+            println!("Commit\n  Result           skipped\n  Reason           no workspace changes");
+            return Ok(());
+        }
+
+        git_status_ok(&["add", "-A"])?;
+        let staged_stat = git_output(&["diff", "--cached", "--stat"])?;
+        let prompt = format!(
+            "Generate a git commit message in plain text Lore format only. Base it on this staged diff summary:\n\n{}\n\nRecent conversation context:\n{}",
+            truncate_for_prompt(&staged_stat, 8_000),
+            recent_user_context(self.runtime.session(), 6)
+        );
+        let message = sanitize_generated_message(&self.run_internal_prompt_text(&prompt, false)?);
+        if message.trim().is_empty() {
+            return Err("generated commit message was empty".into());
+        }
+
+        let path = write_temp_text_file("claw-commit-message.txt", &message)?;
+        let output = Command::new("git")
+            .args(["commit", "--file"])
+            .arg(&path)
+            .current_dir(env::current_dir()?)
+            .output()?;
+        if !output.status.success() {
+            let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
+            return Err(format!("git commit failed: {stderr}").into());
+        }
+
+        println!(
+            "Commit\n  Result           created\n  Message file     {}\n\n{}",
+            path.display(),
+            message.trim()
+        );
+        Ok(())
+    }
+
+    fn run_pr(&self, context: Option<&str>) -> Result<(), Box<dyn std::error::Error>> {
+        let staged = git_output(&["diff", "--stat"])?;
+        let prompt = format!(
+            "Generate a pull request title and body from this conversation and diff summary. Output plain text in this format exactly:\nTITLE: <title>\nBODY:\n<body markdown>\n\nContext hint: {}\n\nDiff summary:\n{}",
+            context.unwrap_or("none"),
+            truncate_for_prompt(&staged, 10_000)
+        );
+        let draft = sanitize_generated_message(&self.run_internal_prompt_text(&prompt, false)?);
+        let (title, body) = parse_titled_body(&draft)
+            .ok_or_else(|| "failed to parse generated PR title/body".to_string())?;
+
+        if command_exists("gh") {
+            let body_path = write_temp_text_file("claw-pr-body.md", &body)?;
+            let output = Command::new("gh")
+                .args(["pr", "create", "--title", &title, "--body-file"])
+                .arg(&body_path)
+                .current_dir(env::current_dir()?)
+                .output()?;
+            if output.status.success() {
+                let stdout = String::from_utf8_lossy(&output.stdout).trim().to_string();
+                println!(
+                    "PR\n  Result           created\n  Title            {title}\n  URL              {}",
+                    if stdout.is_empty() { "<unknown>" } else { &stdout }
+                );
+                return Ok(());
+            }
+        }
+
+        println!("PR draft\n  Title            {title}\n\n{body}");
+        Ok(())
+    }
+
+    fn run_issue(&self, context: Option<&str>) -> Result<(), Box<dyn std::error::Error>> {
+        let prompt = format!(
+            "Generate a GitHub issue title and body from this conversation. Output plain text in this format exactly:\nTITLE: <title>\nBODY:\n<body markdown>\n\nContext hint: {}\n\nConversation context:\n{}",
+            context.unwrap_or("none"),
+            truncate_for_prompt(&recent_user_context(self.runtime.session(), 10), 10_000)
+        );
+        let draft = sanitize_generated_message(&self.run_internal_prompt_text(&prompt, false)?);
+        let (title, body) = parse_titled_body(&draft)
+            .ok_or_else(|| "failed to parse generated issue title/body".to_string())?;
+
+        if command_exists("gh") {
+            let body_path = write_temp_text_file("claw-issue-body.md", &body)?;
+            let output = Command::new("gh")
+                .args(["issue", "create", "--title", &title, "--body-file"])
+                .arg(&body_path)
+                .current_dir(env::current_dir()?)
+                .output()?;
+            if output.status.success() {
+                let stdout = String::from_utf8_lossy(&output.stdout).trim().to_string();
+                println!(
+                    "Issue\n  Result           created\n  Title            {title}\n  URL              {}",
+                    if stdout.is_empty() { "<unknown>" } else { &stdout }
+                );
+                return Ok(());
+            }
+        }
+
+        println!("Issue draft\n  Title            {title}\n\n{body}");
+        Ok(())
+    }
 }
 
 fn sessions_dir() -> Result<PathBuf, Box<dyn std::error::Error>> {
@@ -1810,6 +2002,206 @@ fn render_diff_report() -> Result<String, Box<dyn std::error::Error>> {
     Ok(format!("Diff\n\n{}", diff.trim_end()))
 }
 
+fn render_teleport_report(target: &str) -> Result<String, Box<dyn std::error::Error>> {
+    let cwd = env::current_dir()?;
+
+    let file_list = Command::new("rg")
+        .args(["--files"])
+        .current_dir(&cwd)
+        .output()?;
+    let file_matches = if file_list.status.success() {
+        String::from_utf8(file_list.stdout)?
+            .lines()
+            .filter(|line| line.contains(target))
+            .take(10)
+            .map(ToOwned::to_owned)
+            .collect::<Vec<_>>()
+    } else {
+        Vec::new()
+    };
+
+    let content_output = Command::new("rg")
+        .args(["-n", "-S", "--color", "never", target, "."])
+        .current_dir(&cwd)
+        .output()?;
+
+    let mut lines = vec![format!("Teleport\n  Target           {target}")];
+    if !file_matches.is_empty() {
+        lines.push(String::new());
+        lines.push("File matches".to_string());
+        lines.extend(file_matches.into_iter().map(|path| format!("  {path}")));
+    }
+
+    if content_output.status.success() {
+        let matches = String::from_utf8(content_output.stdout)?;
+        if !matches.trim().is_empty() {
+            lines.push(String::new());
+            lines.push("Content matches".to_string());
+            lines.push(truncate_for_prompt(&matches, 4_000));
+        }
+    }
+
+    if lines.len() == 1 {
+        lines.push("  Result           no matches found".to_string());
+    }
+
+    Ok(lines.join("\n"))
+}
+
+fn render_last_tool_debug_report(session: &Session) -> Result<String, Box<dyn std::error::Error>> {
+    let last_tool_use = session
+        .messages
+        .iter()
+        .rev()
+        .find_map(|message| {
+            message.blocks.iter().rev().find_map(|block| match block {
+                ContentBlock::ToolUse { id, name, input } => {
+                    Some((id.clone(), name.clone(), input.clone()))
+                }
+                _ => None,
+            })
+        })
+        .ok_or_else(|| "no prior tool call found in session".to_string())?;
+
+    let tool_result = session.messages.iter().rev().find_map(|message| {
+        message.blocks.iter().rev().find_map(|block| match block {
+            ContentBlock::ToolResult {
+                tool_use_id,
+                tool_name,
+                output,
+                is_error,
+            } if tool_use_id == &last_tool_use.0 => {
+                Some((tool_name.clone(), output.clone(), *is_error))
+            }
+            _ => None,
+        })
+    });
+
+    let mut lines = vec![
+        "Debug tool call".to_string(),
+        format!("  Tool id          {}", last_tool_use.0),
+        format!("  Tool name        {}", last_tool_use.1),
+        "  Input".to_string(),
+        indent_block(&last_tool_use.2, 4),
+    ];
+
+    match tool_result {
+        Some((tool_name, output, is_error)) => {
+            lines.push("  Result".to_string());
+            lines.push(format!("    name           {tool_name}"));
+            lines.push(format!(
+                "    status         {}",
+                if is_error { "error" } else { "ok" }
+            ));
+            lines.push(indent_block(&output, 4));
+        }
+        None => lines.push("  Result           missing tool result".to_string()),
+    }
+
+    Ok(lines.join("\n"))
+}
+
+fn indent_block(value: &str, spaces: usize) -> String {
+    let indent = " ".repeat(spaces);
+    value
+        .lines()
+        .map(|line| format!("{indent}{line}"))
+        .collect::<Vec<_>>()
+        .join("\n")
+}
+
+fn git_output(args: &[&str]) -> Result<String, Box<dyn std::error::Error>> {
+    let output = Command::new("git")
+        .args(args)
+        .current_dir(env::current_dir()?)
+        .output()?;
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
+        return Err(format!("git {} failed: {stderr}", args.join(" ")).into());
+    }
+    Ok(String::from_utf8(output.stdout)?)
+}
+
+fn git_status_ok(args: &[&str]) -> Result<(), Box<dyn std::error::Error>> {
+    let output = Command::new("git")
+        .args(args)
+        .current_dir(env::current_dir()?)
+        .output()?;
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
+        return Err(format!("git {} failed: {stderr}", args.join(" ")).into());
+    }
+    Ok(())
+}
+
+fn command_exists(name: &str) -> bool {
+    Command::new("which")
+        .arg(name)
+        .output()
+        .map(|output| output.status.success())
+        .unwrap_or(false)
+}
+
+fn write_temp_text_file(
+    filename: &str,
+    contents: &str,
+) -> Result<PathBuf, Box<dyn std::error::Error>> {
+    let path = env::temp_dir().join(filename);
+    fs::write(&path, contents)?;
+    Ok(path)
+}
+
+fn recent_user_context(session: &Session, limit: usize) -> String {
+    let requests = session
+        .messages
+        .iter()
+        .filter(|message| message.role == MessageRole::User)
+        .filter_map(|message| {
+            message.blocks.iter().find_map(|block| match block {
+                ContentBlock::Text { text } => Some(text.trim().to_string()),
+                _ => None,
+            })
+        })
+        .rev()
+        .take(limit)
+        .collect::<Vec<_>>();
+
+    if requests.is_empty() {
+        "<no prior user messages>".to_string()
+    } else {
+        requests
+            .into_iter()
+            .rev()
+            .enumerate()
+            .map(|(index, text)| format!("{}. {}", index + 1, text))
+            .collect::<Vec<_>>()
+            .join("\n")
+    }
+}
+
+fn truncate_for_prompt(value: &str, limit: usize) -> String {
+    if value.chars().count() <= limit {
+        value.trim().to_string()
+    } else {
+        let truncated = value.chars().take(limit).collect::<String>();
+        format!("{}\n…[truncated]", truncated.trim_end())
+    }
+}
+
+fn sanitize_generated_message(value: &str) -> String {
+    value.trim().trim_matches('`').trim().replace("\r\n", "\n")
+}
+
+fn parse_titled_body(value: &str) -> Option<(String, String)> {
+    let normalized = sanitize_generated_message(value);
+    let title = normalized
+        .lines()
+        .find_map(|line| line.strip_prefix("TITLE:").map(str::trim))?;
+    let body_start = normalized.find("BODY:")?;
+    let body = normalized[body_start + "BODY:".len()..].trim();
+    Some((title.to_string(), body.to_string()))
+}
+
 fn render_version_report() -> String {
     let git_sha = GIT_SHA.unwrap_or("unknown");
     let target = BUILD_TARGET.unwrap_or("unknown");
@@ -1914,19 +2306,8 @@ fn build_system_prompt() -> Result<Vec<String>, Box<dyn std::error::Error>> {
     )?)
 }
 
-fn build_runtime_feature_config(
-) -> Result<runtime::RuntimeFeatureConfig, Box<dyn std::error::Error>> {
-    let cwd = env::current_dir()?;
-    Ok(ConfigLoader::default_for(cwd)
-        .load()?
-        .feature_config()
-        .clone())
-}
-
-#[allow(clippy::too_many_arguments)]
 fn build_runtime(
     session: Session,
-    session_id: &str,
     model: String,
     system_prompt: Vec<String>,
     enable_tools: bool,
@@ -1935,41 +2316,13 @@ fn build_runtime(
     permission_mode: PermissionMode,
 ) -> Result<ConversationRuntime<AnthropicRuntimeClient, CliToolExecutor>, Box<dyn std::error::Error>>
 {
-    let session_tracer = build_session_tracer(session_id)?;
-    let api_client = match session_tracer.clone() {
-        Some(session_tracer) => {
-            AnthropicRuntimeClient::new(model, enable_tools, emit_output, allowed_tools.clone())?
-                .with_session_tracer(session_tracer)
-        }
-        None => {
-            AnthropicRuntimeClient::new(model, enable_tools, emit_output, allowed_tools.clone())?
-        }
-    };
-    let runtime = ConversationRuntime::new_with_features(
+    Ok(ConversationRuntime::new(
         session,
-        api_client,
+        AnthropicRuntimeClient::new(model, enable_tools, emit_output, allowed_tools.clone())?,
         CliToolExecutor::new(allowed_tools, emit_output),
         permission_policy(permission_mode),
         system_prompt,
-        &build_runtime_feature_config()?,
-    );
-    Ok(match session_tracer {
-        Some(session_tracer) => runtime.with_session_tracer(session_tracer),
-        None => runtime,
-    })
-}
-
-fn build_session_tracer(
-    session_id: &str,
-) -> Result<Option<SessionTracer>, Box<dyn std::error::Error>> {
-    let Some(path) = env::var_os(TELEMETRY_LOG_PATH_ENV) else {
-        return Ok(None);
-    };
-    let sink = JsonlTelemetrySink::new(PathBuf::from(path))?;
-    Ok(Some(SessionTracer::new(
-        session_id.to_string(),
-        std::sync::Arc::new(sink),
-    )))
+    ))
 }
 
 struct CliPermissionPrompter {
@@ -2044,11 +2397,6 @@ impl AnthropicRuntimeClient {
             allowed_tools,
         })
     }
-
-    fn with_session_tracer(mut self, session_tracer: SessionTracer) -> Self {
-        self.client = self.client.with_session_tracer(session_tracer);
-        self
-    }
 }
 
 fn resolve_cli_auth_source() -> Result<AuthSource, Box<dyn std::error::Error>> {
@@ -2154,7 +2502,12 @@ impl ApiClient for AnthropicRuntimeClient {
                         }
                     }
                     ApiStreamEvent::MessageDelta(delta) => {
-                        events.push(AssistantEvent::Usage(delta.usage.token_usage()));
+                        events.push(AssistantEvent::Usage(TokenUsage {
+                            input_tokens: delta.usage.input_tokens,
+                            output_tokens: delta.usage.output_tokens,
+                            cache_creation_input_tokens: 0,
+                            cache_read_input_tokens: 0,
+                        }));
                     }
                     ApiStreamEvent::MessageStop(_) => {
                         saw_stop = true;
@@ -2404,13 +2757,13 @@ fn format_bash_result(icon: &str, parsed: &serde_json::Value) -> String {
         .get("backgroundTaskId")
         .and_then(|value| value.as_str())
     {
-        write!(&mut lines[0], " backgrounded ({task_id})").expect("write to string");
+        lines[0].push_str(&format!(" backgrounded ({task_id})"));
     } else if let Some(status) = parsed
         .get("returnCodeInterpretation")
         .and_then(|value| value.as_str())
         .filter(|status| !status.is_empty())
     {
-        write!(&mut lines[0], " {status}").expect("write to string");
+        lines[0].push_str(&format!(" {status}"));
     }
 
     if let Some(stdout) = parsed.get("stdout").and_then(|value| value.as_str()) {
@@ -2432,15 +2785,15 @@ fn format_read_result(icon: &str, parsed: &serde_json::Value) -> String {
     let path = extract_tool_path(file);
     let start_line = file
         .get("startLine")
-        .and_then(serde_json::Value::as_u64)
+        .and_then(|value| value.as_u64())
         .unwrap_or(1);
     let num_lines = file
         .get("numLines")
-        .and_then(serde_json::Value::as_u64)
+        .and_then(|value| value.as_u64())
         .unwrap_or(0);
     let total_lines = file
         .get("totalLines")
-        .and_then(serde_json::Value::as_u64)
+        .and_then(|value| value.as_u64())
         .unwrap_or(num_lines);
     let content = file
         .get("content")
@@ -2466,7 +2819,8 @@ fn format_write_result(icon: &str, parsed: &serde_json::Value) -> String {
     let line_count = parsed
         .get("content")
         .and_then(|value| value.as_str())
-        .map_or(0, |content| content.lines().count());
+        .map(|content| content.lines().count())
+        .unwrap_or(0);
     format!(
         "{icon} \x1b[1;32m✏️ {} {path}\x1b[0m \x1b[2m({line_count} lines)\x1b[0m",
         if kind == "create" { "Wrote" } else { "Updated" },
@@ -2497,7 +2851,7 @@ fn format_edit_result(icon: &str, parsed: &serde_json::Value) -> String {
     let path = extract_tool_path(parsed);
     let suffix = if parsed
         .get("replaceAll")
-        .and_then(serde_json::Value::as_bool)
+        .and_then(|value| value.as_bool())
         .unwrap_or(false)
     {
         " (replace all)"
@@ -2525,7 +2879,7 @@ fn format_edit_result(icon: &str, parsed: &serde_json::Value) -> String {
 fn format_glob_result(icon: &str, parsed: &serde_json::Value) -> String {
     let num_files = parsed
         .get("numFiles")
-        .and_then(serde_json::Value::as_u64)
+        .and_then(|value| value.as_u64())
         .unwrap_or(0);
     let filenames = parsed
         .get("filenames")
@@ -2549,11 +2903,11 @@ fn format_glob_result(icon: &str, parsed: &serde_json::Value) -> String {
 fn format_grep_result(icon: &str, parsed: &serde_json::Value) -> String {
     let num_matches = parsed
         .get("numMatches")
-        .and_then(serde_json::Value::as_u64)
+        .and_then(|value| value.as_u64())
         .unwrap_or(0);
     let num_files = parsed
         .get("numFiles")
-        .and_then(serde_json::Value::as_u64)
+        .and_then(|value| value.as_u64())
         .unwrap_or(0);
     let content = parsed
         .get("content")
@@ -2650,7 +3004,12 @@ fn response_to_events(
         }
     }
 
-    events.push(AssistantEvent::Usage(response.usage.token_usage()));
+    events.push(AssistantEvent::Usage(TokenUsage {
+        input_tokens: response.usage.input_tokens,
+        output_tokens: response.usage.output_tokens,
+        cache_creation_input_tokens: response.usage.cache_creation_input_tokens,
+        cache_read_input_tokens: response.usage.cache_read_input_tokens,
+    }));
     events.push(AssistantEvent::MessageStop);
     Ok(events)
 }

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

@@ -286,7 +286,7 @@ impl TerminalRenderer {
     ) {
         match event {
             Event::Start(Tag::Heading { level, .. }) => {
-                Self::start_heading(state, level as u8, output);
+                self.start_heading(state, level as u8, output)
             }
             Event::End(TagEnd::Paragraph) => output.push_str("\n\n"),
             Event::Start(Tag::BlockQuote(..)) => self.start_quote(state, output),
@@ -426,7 +426,7 @@ impl TerminalRenderer {
         }
     }
 
-    fn start_heading(state: &mut RenderState, level: u8, output: &mut String) {
+    fn start_heading(&self, state: &mut RenderState, level: u8, output: &mut String) {
         state.heading_level = Some(level);
         if !output.is_empty() {
             output.push('\n');

rust/crates/telemetry/Cargo.toml

@@ -1,13 +0,0 @@
-[package]
-name = "telemetry"
-version.workspace = true
-edition.workspace = true
-license.workspace = true
-publish.workspace = true
-
-[dependencies]
-serde = { version = "1", features = ["derive"] }
-serde_json = "1"
-
-[lints]
-workspace = true

rust/crates/telemetry/src/lib.rs

@@ -1,526 +0,0 @@
-use std::fmt::{Debug, Formatter};
-use std::fs::{File, OpenOptions};
-use std::io::Write;
-use std::path::{Path, PathBuf};
-use std::sync::atomic::{AtomicU64, Ordering};
-use std::sync::{Arc, Mutex};
-use std::time::{SystemTime, UNIX_EPOCH};
-
-use serde::{Deserialize, Serialize};
-use serde_json::{Map, Value};
-
-pub const DEFAULT_ANTHROPIC_VERSION: &str = "2023-06-01";
-pub const DEFAULT_APP_NAME: &str = "claude-code";
-pub const DEFAULT_RUNTIME: &str = "rust";
-pub const DEFAULT_AGENTIC_BETA: &str = "claude-code-20250219";
-pub const DEFAULT_PROMPT_CACHING_SCOPE_BETA: &str = "prompt-caching-scope-2026-01-05";
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct ClientIdentity {
-    pub app_name: String,
-    pub app_version: String,
-    pub runtime: String,
-}
-
-impl ClientIdentity {
-    #[must_use]
-    pub fn new(app_name: impl Into<String>, app_version: impl Into<String>) -> Self {
-        Self {
-            app_name: app_name.into(),
-            app_version: app_version.into(),
-            runtime: DEFAULT_RUNTIME.to_string(),
-        }
-    }
-
-    #[must_use]
-    pub fn with_runtime(mut self, runtime: impl Into<String>) -> Self {
-        self.runtime = runtime.into();
-        self
-    }
-
-    #[must_use]
-    pub fn user_agent(&self) -> String {
-        format!("{}/{}", self.app_name, self.app_version)
-    }
-}
-
-impl Default for ClientIdentity {
-    fn default() -> Self {
-        Self::new(DEFAULT_APP_NAME, env!("CARGO_PKG_VERSION"))
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct AnthropicRequestProfile {
-    pub anthropic_version: String,
-    pub client_identity: ClientIdentity,
-    #[serde(default, skip_serializing_if = "Vec::is_empty")]
-    pub betas: Vec<String>,
-    #[serde(default, skip_serializing_if = "Map::is_empty")]
-    pub extra_body: Map<String, Value>,
-}
-
-impl AnthropicRequestProfile {
-    #[must_use]
-    pub fn new(client_identity: ClientIdentity) -> Self {
-        Self {
-            anthropic_version: DEFAULT_ANTHROPIC_VERSION.to_string(),
-            client_identity,
-            betas: vec![
-                DEFAULT_AGENTIC_BETA.to_string(),
-                DEFAULT_PROMPT_CACHING_SCOPE_BETA.to_string(),
-            ],
-            extra_body: Map::new(),
-        }
-    }
-
-    #[must_use]
-    pub fn with_beta(mut self, beta: impl Into<String>) -> Self {
-        let beta = beta.into();
-        if !self.betas.contains(&beta) {
-            self.betas.push(beta);
-        }
-        self
-    }
-
-    #[must_use]
-    pub fn with_extra_body(mut self, key: impl Into<String>, value: Value) -> Self {
-        self.extra_body.insert(key.into(), value);
-        self
-    }
-
-    #[must_use]
-    pub fn header_pairs(&self) -> Vec<(String, String)> {
-        let mut headers = vec![
-            (
-                "anthropic-version".to_string(),
-                self.anthropic_version.clone(),
-            ),
-            ("user-agent".to_string(), self.client_identity.user_agent()),
-        ];
-        if !self.betas.is_empty() {
-            headers.push(("anthropic-beta".to_string(), self.betas.join(",")));
-        }
-        headers
-    }
-
-    pub fn render_json_body<T: Serialize>(&self, request: &T) -> Result<Value, serde_json::Error> {
-        let mut body = serde_json::to_value(request)?;
-        let object = body.as_object_mut().ok_or_else(|| {
-            serde_json::Error::io(std::io::Error::new(
-                std::io::ErrorKind::InvalidData,
-                "request body must serialize to a JSON object",
-            ))
-        })?;
-        for (key, value) in &self.extra_body {
-            object.insert(key.clone(), value.clone());
-        }
-        if !self.betas.is_empty() {
-            object.insert(
-                "betas".to_string(),
-                Value::Array(self.betas.iter().cloned().map(Value::String).collect()),
-            );
-        }
-        Ok(body)
-    }
-}
-
-impl Default for AnthropicRequestProfile {
-    fn default() -> Self {
-        Self::new(ClientIdentity::default())
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct AnalyticsEvent {
-    pub namespace: String,
-    pub action: String,
-    #[serde(default, skip_serializing_if = "Map::is_empty")]
-    pub properties: Map<String, Value>,
-}
-
-impl AnalyticsEvent {
-    #[must_use]
-    pub fn new(namespace: impl Into<String>, action: impl Into<String>) -> Self {
-        Self {
-            namespace: namespace.into(),
-            action: action.into(),
-            properties: Map::new(),
-        }
-    }
-
-    #[must_use]
-    pub fn with_property(mut self, key: impl Into<String>, value: Value) -> Self {
-        self.properties.insert(key.into(), value);
-        self
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct SessionTraceRecord {
-    pub session_id: String,
-    pub sequence: u64,
-    pub name: String,
-    pub timestamp_ms: u64,
-    #[serde(default, skip_serializing_if = "Map::is_empty")]
-    pub attributes: Map<String, Value>,
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(tag = "type", rename_all = "snake_case")]
-pub enum TelemetryEvent {
-    HttpRequestStarted {
-        session_id: String,
-        attempt: u32,
-        method: String,
-        path: String,
-        #[serde(default, skip_serializing_if = "Map::is_empty")]
-        attributes: Map<String, Value>,
-    },
-    HttpRequestSucceeded {
-        session_id: String,
-        attempt: u32,
-        method: String,
-        path: String,
-        status: u16,
-        #[serde(default, skip_serializing_if = "Option::is_none")]
-        request_id: Option<String>,
-        #[serde(default, skip_serializing_if = "Map::is_empty")]
-        attributes: Map<String, Value>,
-    },
-    HttpRequestFailed {
-        session_id: String,
-        attempt: u32,
-        method: String,
-        path: String,
-        error: String,
-        retryable: bool,
-        #[serde(default, skip_serializing_if = "Map::is_empty")]
-        attributes: Map<String, Value>,
-    },
-    Analytics(AnalyticsEvent),
-    SessionTrace(SessionTraceRecord),
-}
-
-pub trait TelemetrySink: Send + Sync {
-    fn record(&self, event: TelemetryEvent);
-}
-
-#[derive(Default)]
-pub struct MemoryTelemetrySink {
-    events: Mutex<Vec<TelemetryEvent>>,
-}
-
-impl MemoryTelemetrySink {
-    #[must_use]
-    pub fn events(&self) -> Vec<TelemetryEvent> {
-        self.events
-            .lock()
-            .unwrap_or_else(std::sync::PoisonError::into_inner)
-            .clone()
-    }
-}
-
-impl TelemetrySink for MemoryTelemetrySink {
-    fn record(&self, event: TelemetryEvent) {
-        self.events
-            .lock()
-            .unwrap_or_else(std::sync::PoisonError::into_inner)
-            .push(event);
-    }
-}
-
-pub struct JsonlTelemetrySink {
-    path: PathBuf,
-    file: Mutex<File>,
-}
-
-impl Debug for JsonlTelemetrySink {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("JsonlTelemetrySink")
-            .field("path", &self.path)
-            .finish_non_exhaustive()
-    }
-}
-
-impl JsonlTelemetrySink {
-    pub fn new(path: impl AsRef<Path>) -> Result<Self, std::io::Error> {
-        let path = path.as_ref().to_path_buf();
-        if let Some(parent) = path.parent() {
-            std::fs::create_dir_all(parent)?;
-        }
-        let file = OpenOptions::new().create(true).append(true).open(&path)?;
-        Ok(Self {
-            path,
-            file: Mutex::new(file),
-        })
-    }
-
-    #[must_use]
-    pub fn path(&self) -> &Path {
-        &self.path
-    }
-}
-
-impl TelemetrySink for JsonlTelemetrySink {
-    fn record(&self, event: TelemetryEvent) {
-        let Ok(line) = serde_json::to_string(&event) else {
-            return;
-        };
-        let mut file = self
-            .file
-            .lock()
-            .unwrap_or_else(std::sync::PoisonError::into_inner);
-        let _ = writeln!(file, "{line}");
-        let _ = file.flush();
-    }
-}
-
-#[derive(Clone)]
-pub struct SessionTracer {
-    session_id: String,
-    sequence: Arc<AtomicU64>,
-    sink: Arc<dyn TelemetrySink>,
-}
-
-impl Debug for SessionTracer {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("SessionTracer")
-            .field("session_id", &self.session_id)
-            .finish_non_exhaustive()
-    }
-}
-
-impl SessionTracer {
-    #[must_use]
-    pub fn new(session_id: impl Into<String>, sink: Arc<dyn TelemetrySink>) -> Self {
-        Self {
-            session_id: session_id.into(),
-            sequence: Arc::new(AtomicU64::new(0)),
-            sink,
-        }
-    }
-
-    #[must_use]
-    pub fn session_id(&self) -> &str {
-        &self.session_id
-    }
-
-    pub fn record(&self, name: impl Into<String>, attributes: Map<String, Value>) {
-        let record = SessionTraceRecord {
-            session_id: self.session_id.clone(),
-            sequence: self.sequence.fetch_add(1, Ordering::Relaxed),
-            name: name.into(),
-            timestamp_ms: current_timestamp_ms(),
-            attributes,
-        };
-        self.sink.record(TelemetryEvent::SessionTrace(record));
-    }
-
-    pub fn record_http_request_started(
-        &self,
-        attempt: u32,
-        method: impl Into<String>,
-        path: impl Into<String>,
-        attributes: Map<String, Value>,
-    ) {
-        let method = method.into();
-        let path = path.into();
-        self.sink.record(TelemetryEvent::HttpRequestStarted {
-            session_id: self.session_id.clone(),
-            attempt,
-            method: method.clone(),
-            path: path.clone(),
-            attributes: attributes.clone(),
-        });
-        self.record(
-            "http_request_started",
-            merge_trace_fields(method, path, attempt, attributes),
-        );
-    }
-
-    pub fn record_http_request_succeeded(
-        &self,
-        attempt: u32,
-        method: impl Into<String>,
-        path: impl Into<String>,
-        status: u16,
-        request_id: Option<String>,
-        attributes: Map<String, Value>,
-    ) {
-        let method = method.into();
-        let path = path.into();
-        self.sink.record(TelemetryEvent::HttpRequestSucceeded {
-            session_id: self.session_id.clone(),
-            attempt,
-            method: method.clone(),
-            path: path.clone(),
-            status,
-            request_id: request_id.clone(),
-            attributes: attributes.clone(),
-        });
-        let mut trace_attributes = merge_trace_fields(method, path, attempt, attributes);
-        trace_attributes.insert("status".to_string(), Value::from(status));
-        if let Some(request_id) = request_id {
-            trace_attributes.insert("request_id".to_string(), Value::String(request_id));
-        }
-        self.record("http_request_succeeded", trace_attributes);
-    }
-
-    pub fn record_http_request_failed(
-        &self,
-        attempt: u32,
-        method: impl Into<String>,
-        path: impl Into<String>,
-        error: impl Into<String>,
-        retryable: bool,
-        attributes: Map<String, Value>,
-    ) {
-        let method = method.into();
-        let path = path.into();
-        let error = error.into();
-        self.sink.record(TelemetryEvent::HttpRequestFailed {
-            session_id: self.session_id.clone(),
-            attempt,
-            method: method.clone(),
-            path: path.clone(),
-            error: error.clone(),
-            retryable,
-            attributes: attributes.clone(),
-        });
-        let mut trace_attributes = merge_trace_fields(method, path, attempt, attributes);
-        trace_attributes.insert("error".to_string(), Value::String(error));
-        trace_attributes.insert("retryable".to_string(), Value::Bool(retryable));
-        self.record("http_request_failed", trace_attributes);
-    }
-
-    pub fn record_analytics(&self, event: AnalyticsEvent) {
-        let mut attributes = event.properties.clone();
-        attributes.insert(
-            "namespace".to_string(),
-            Value::String(event.namespace.clone()),
-        );
-        attributes.insert("action".to_string(), Value::String(event.action.clone()));
-        self.sink.record(TelemetryEvent::Analytics(event));
-        self.record("analytics", attributes);
-    }
-}
-
-fn merge_trace_fields(
-    method: String,
-    path: String,
-    attempt: u32,
-    mut attributes: Map<String, Value>,
-) -> Map<String, Value> {
-    attributes.insert("method".to_string(), Value::String(method));
-    attributes.insert("path".to_string(), Value::String(path));
-    attributes.insert("attempt".to_string(), Value::from(attempt));
-    attributes
-}
-
-fn current_timestamp_ms() -> u64 {
-    SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .unwrap_or_default()
-        .as_millis()
-        .try_into()
-        .unwrap_or(u64::MAX)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn request_profile_emits_headers_and_merges_body() {
-        let profile = AnthropicRequestProfile::new(
-            ClientIdentity::new("claude-code", "1.2.3").with_runtime("rust-cli"),
-        )
-        .with_beta("tools-2026-04-01")
-        .with_extra_body("metadata", serde_json::json!({"source": "test"}));
-
-        assert_eq!(
-            profile.header_pairs(),
-            vec![
-                (
-                    "anthropic-version".to_string(),
-                    DEFAULT_ANTHROPIC_VERSION.to_string()
-                ),
-                ("user-agent".to_string(), "claude-code/1.2.3".to_string()),
-                (
-                    "anthropic-beta".to_string(),
-                    "claude-code-20250219,prompt-caching-scope-2026-01-05,tools-2026-04-01"
-                        .to_string(),
-                ),
-            ]
-        );
-
-        let body = profile
-            .render_json_body(&serde_json::json!({"model": "claude-sonnet"}))
-            .expect("body should serialize");
-        assert_eq!(
-            body["metadata"]["source"],
-            Value::String("test".to_string())
-        );
-        assert_eq!(
-            body["betas"],
-            serde_json::json!([
-                "claude-code-20250219",
-                "prompt-caching-scope-2026-01-05",
-                "tools-2026-04-01"
-            ])
-        );
-    }
-
-    #[test]
-    fn session_tracer_records_structured_events_and_trace_sequence() {
-        let sink = Arc::new(MemoryTelemetrySink::default());
-        let tracer = SessionTracer::new("session-123", sink.clone());
-
-        tracer.record_http_request_started(1, "POST", "/v1/messages", Map::new());
-        tracer.record_analytics(
-            AnalyticsEvent::new("cli", "prompt_sent")
-                .with_property("model", Value::String("claude-opus".to_string())),
-        );
-
-        let events = sink.events();
-        assert!(matches!(
-            &events[0],
-            TelemetryEvent::HttpRequestStarted {
-                session_id,
-                attempt: 1,
-                method,
-                path,
-                ..
-            } if session_id == "session-123" && method == "POST" && path == "/v1/messages"
-        ));
-        assert!(matches!(
-            &events[1],
-            TelemetryEvent::SessionTrace(SessionTraceRecord { sequence: 0, name, .. })
-            if name == "http_request_started"
-        ));
-        assert!(matches!(&events[2], TelemetryEvent::Analytics(_)));
-        assert!(matches!(
-            &events[3],
-            TelemetryEvent::SessionTrace(SessionTraceRecord { sequence: 1, name, .. })
-            if name == "analytics"
-        ));
-    }
-
-    #[test]
-    fn jsonl_sink_persists_events() {
-        let path =
-            std::env::temp_dir().join(format!("telemetry-jsonl-{}.log", current_timestamp_ms()));
-        let sink = JsonlTelemetrySink::new(&path).expect("sink should create file");
-
-        sink.record(TelemetryEvent::Analytics(
-            AnalyticsEvent::new("cli", "turn_completed").with_property("ok", Value::Bool(true)),
-        ));
-
-        let contents = std::fs::read_to_string(&path).expect("telemetry log should be readable");
-        assert!(contents.contains("\"type\":\"analytics\""));
-        assert!(contents.contains("\"action\":\"turn_completed\""));
-
-        let _ = std::fs::remove_file(path);
-    }
-}

rust/crates/tools/src/lib.rs

@@ -13,7 +13,7 @@ use runtime::{
     edit_file, execute_bash, glob_search, grep_search, load_system_prompt, read_file, write_file,
     ApiClient, ApiRequest, AssistantEvent, BashCommandInput, ContentBlock, ConversationMessage,
     ConversationRuntime, GrepSearchInput, MessageRole, PermissionMode, PermissionPolicy,
-    RuntimeError, Session, ToolError, ToolExecutor,
+    RuntimeError, Session, TokenUsage, ToolError, ToolExecutor,
 };
 use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
@@ -1723,7 +1723,12 @@ impl ApiClient for AnthropicRuntimeClient {
                         }
                     }
                     ApiStreamEvent::MessageDelta(delta) => {
-                        events.push(AssistantEvent::Usage(delta.usage.token_usage()));
+                        events.push(AssistantEvent::Usage(TokenUsage {
+                            input_tokens: delta.usage.input_tokens,
+                            output_tokens: delta.usage.output_tokens,
+                            cache_creation_input_tokens: 0,
+                            cache_read_input_tokens: 0,
+                        }));
                     }
                     ApiStreamEvent::MessageStop(_) => {
                         saw_stop = true;
@@ -1869,7 +1874,12 @@ fn response_to_events(response: MessageResponse) -> Vec<AssistantEvent> {
         }
     }
 
-    events.push(AssistantEvent::Usage(response.usage.token_usage()));
+    events.push(AssistantEvent::Usage(TokenUsage {
+        input_tokens: response.usage.input_tokens,
+        output_tokens: response.usage.output_tokens,
+        cache_creation_input_tokens: response.usage.cache_creation_input_tokens,
+        cache_read_input_tokens: response.usage.cache_read_input_tokens,
+    }));
     events.push(AssistantEvent::MessageStop);
     events
 }