feat: telemetry progress

rust/Cargo.lock

@@ -25,6 +25,7 @@ dependencies = [
  "runtime",
  "serde",
  "serde_json",
+ "telemetry",
  "tokio",
 ]
 
@@ -1096,6 +1097,7 @@ dependencies = [
  "serde",
  "serde_json",
  "sha2",
+ "telemetry",
  "tokio",
  "walkdir",
 ]
@@ -1428,6 +1430,14 @@ 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,6 +10,7 @@ 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,17 +2,19 @@ use std::collections::VecDeque;
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
 use runtime::{
-    load_oauth_credentials, save_oauth_credentials, OAuthConfig, OAuthRefreshRequest,
-    OAuthTokenExchangeRequest,
+    format_usd, load_oauth_credentials, pricing_for_model, 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 ANTHROPIC_VERSION: &str = "2023-06-01";
+const MESSAGES_PATH: &str = "/v1/messages";
 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);
@@ -108,6 +110,8 @@ pub struct AnthropicClient {
     max_retries: u32,
     initial_backoff: Duration,
     max_backoff: Duration,
+    request_profile: AnthropicRequestProfile,
+    session_tracer: Option<SessionTracer>,
 }
 
 impl AnthropicClient {
@@ -120,6 +124,8 @@ impl AnthropicClient {
             max_retries: DEFAULT_MAX_RETRIES,
             initial_backoff: DEFAULT_INITIAL_BACKOFF,
             max_backoff: DEFAULT_MAX_BACKOFF,
+            request_profile: AnthropicRequestProfile::default(),
+            session_tracer: None,
         }
     }
 
@@ -132,6 +138,8 @@ impl AnthropicClient {
             max_retries: DEFAULT_MAX_RETRIES,
             initial_backoff: DEFAULT_INITIAL_BACKOFF,
             max_backoff: DEFAULT_MAX_BACKOFF,
+            request_profile: AnthropicRequestProfile::default(),
+            session_tracer: None,
         }
     }
 
@@ -176,6 +184,39 @@ 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,
@@ -211,6 +252,7 @@ impl AnthropicClient {
         if response.request_id.is_none() {
             response.request_id = request_id;
         }
+        self.record_response_usage(&response);
         Ok(response)
     }
 
@@ -279,18 +321,30 @@ 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) => return Ok(response),
+                    Ok(response) => {
+                        self.record_request_succeeded(request, attempts, &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) => return Err(error),
+                    Err(error) => {
+                        self.record_request_failed(request, attempts, &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) => return Err(error),
+                Err(error) => {
+                    self.record_request_failed(request, attempts, &error);
+                    return Err(error);
+                }
             }
 
             if attempts > self.max_retries {
@@ -310,18 +364,213 @@ impl AnthropicClient {
         &self,
         request: &MessageRequest,
     ) -> Result<reqwest::Response, ApiError> {
-        let request_url = format!("{}/v1/messages", self.base_url.trim_end_matches('/'));
-        let request_builder = self
+        let request_url = format!("{}{}", self.base_url.trim_end_matches('/'), MESSAGES_PATH);
+        let mut 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);
 
-        request_builder = request_builder.json(request);
+        let request_body = self.request_profile.render_json_body(request)?;
+        request_builder = request_builder.json(&request_body);
         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,3 +15,9 @@ 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,3 +1,4 @@
+use runtime::{pricing_for_model, TokenUsage, UsageCostEstimate};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 
@@ -150,7 +151,29 @@ pub struct Usage {
 impl Usage {
     #[must_use]
     pub const fn total_tokens(&self) -> u32 {
-        self.input_tokens + self.output_tokens
+        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),
+        )
     }
 }
 
@@ -210,3 +233,47 @@ 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,6 +8,7 @@ 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;
@@ -64,6 +65,18 @@ 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!(
@@ -73,6 +86,115 @@ 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

@@ -125,8 +125,8 @@ const SLASH_COMMAND_SPECS: &[SlashCommandSpec] = &[
     },
     SlashCommandSpec {
         name: "session",
-        summary: "List, switch, or fork managed local sessions",
-        argument_hint: Some("[list|switch <session-id>|fork [branch-name]]"),
+        summary: "List or switch managed local sessions",
+        argument_hint: Some("[list|switch <session-id>]"),
         resume_supported: false,
     },
 ];
@@ -229,7 +229,7 @@ pub fn resume_supported_slash_commands() -> Vec<&'static SlashCommandSpec> {
 pub fn render_slash_command_help() -> String {
     let mut lines = vec![
         "Slash commands".to_string(),
-        "  [resume] means the command also works with --resume SESSION.jsonl".to_string(),
+        "  [resume] means the command also works with --resume SESSION.json".to_string(),
     ];
     for spec in slash_command_specs() {
         let name = match spec.argument_hint {
@@ -365,19 +365,12 @@ mod tests {
                 target: Some("abc123".to_string())
             })
         );
-        assert_eq!(
-            SlashCommand::parse("/session fork incident-review"),
-            Some(SlashCommand::Session {
-                action: Some("fork".to_string()),
-                target: Some("incident-review".to_string())
-            })
-        );
     }
 
     #[test]
     fn renders_help_from_shared_specs() {
         let help = render_slash_command_help();
-        assert!(help.contains("works with --resume SESSION.jsonl"));
+        assert!(help.contains("works with --resume SESSION.json"));
         assert!(help.contains("/help"));
         assert!(help.contains("/status"));
         assert!(help.contains("/compact"));
@@ -392,15 +385,16 @@ mod tests {
         assert!(help.contains("/diff"));
         assert!(help.contains("/version"));
         assert!(help.contains("/export [file]"));
-        assert!(help.contains("/session [list|switch <session-id>|fork [branch-name]]"));
+        assert!(help.contains("/session [list|switch <session-id>]"));
         assert_eq!(slash_command_specs().len(), 15);
         assert_eq!(resume_supported_slash_commands().len(), 11);
     }
 
     #[test]
     fn compacts_sessions_via_slash_command() {
-        let mut session = Session::new();
-        session.messages = vec![
+        let session = Session {
+            version: 1,
+            messages: vec![
                 ConversationMessage::user_text("a ".repeat(200)),
                 ConversationMessage::assistant(vec![ContentBlock::Text {
                     text: "b ".repeat(200),
@@ -409,7 +403,8 @@ mod tests {
                 ConversationMessage::assistant(vec![ContentBlock::Text {
                     text: "recent".to_string(),
                 }]),
-        ];
+            ],
+        };
 
         let result = handle_slash_command(
             "/compact",
@@ -460,12 +455,6 @@ mod tests {
             CompactionConfig::default()
         )
         .is_none());
-        assert!(handle_slash_command(
-            "/resume session.jsonl",
-            &session,
-            CompactionConfig::default()
-        )
-        .is_none());
         assert!(handle_slash_command("/config", &session, CompactionConfig::default()).is_none());
         assert!(
             handle_slash_command("/config env", &session, CompactionConfig::default()).is_none()

rust/crates/runtime/Cargo.toml

@@ -11,6 +11,7 @@ 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/compact.rs

@@ -99,14 +99,13 @@ pub fn compact_session(session: &Session, config: CompactionConfig) -> Compactio
     }];
     compacted_messages.extend(preserved);
 
-    let mut compacted_session = session.clone();
-    compacted_session.messages = compacted_messages;
-    compacted_session.record_compaction(summary.clone(), removed.len());
-
     CompactionResult {
         summary,
         formatted_summary,
-        compacted_session,
+        compacted_session: Session {
+            version: session.version,
+            messages: compacted_messages,
+        },
         removed_message_count: removed.len(),
     }
 }
@@ -391,8 +390,10 @@ mod tests {
 
     #[test]
     fn leaves_small_sessions_unchanged() {
-        let mut session = Session::new();
-        session.messages = vec![ConversationMessage::user_text("hello")];
+        let session = Session {
+            version: 1,
+            messages: vec![ConversationMessage::user_text("hello")],
+        };
 
         let result = compact_session(&session, CompactionConfig::default());
         assert_eq!(result.removed_message_count, 0);
@@ -403,8 +404,9 @@ mod tests {
 
     #[test]
     fn compacts_older_messages_into_a_system_summary() {
-        let mut session = Session::new();
-        session.messages = vec![
+        let session = Session {
+            version: 1,
+            messages: vec![
                 ConversationMessage::user_text("one ".repeat(200)),
                 ConversationMessage::assistant(vec![ContentBlock::Text {
                     text: "two ".repeat(200),
@@ -417,7 +419,8 @@ mod tests {
                     }],
                     usage: None,
                 },
-        ];
+            ],
+        };
 
         let result = compact_session(
             &session,

rust/crates/runtime/src/conversation.rs

@@ -1,6 +1,9 @@
 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,
 };
@@ -97,6 +100,7 @@ pub struct ConversationRuntime<C, T> {
     max_iterations: usize,
     usage_tracker: UsageTracker,
     hook_runner: HookRunner,
+    session_tracer: Option<SessionTracer>,
 }
 
 impl<C, T> ConversationRuntime<C, T>
@@ -118,7 +122,7 @@ where
             tool_executor,
             permission_policy,
             system_prompt,
-            RuntimeFeatureConfig::default(),
+            &RuntimeFeatureConfig::default(),
         )
     }
 
@@ -129,7 +133,7 @@ where
         tool_executor: T,
         permission_policy: PermissionPolicy,
         system_prompt: Vec<String>,
-        feature_config: RuntimeFeatureConfig,
+        feature_config: &RuntimeFeatureConfig,
     ) -> Self {
         let usage_tracker = UsageTracker::from_session(&session);
         Self {
@@ -140,7 +144,8 @@ where
             system_prompt,
             max_iterations: usize::MAX,
             usage_tracker,
-            hook_runner: HookRunner::from_feature_config(&feature_config),
+            hook_runner: HookRunner::from_feature_config(feature_config),
+            session_tracer: None,
         }
     }
 
@@ -150,14 +155,23 @@ where
         self
     }
 
+    #[must_use]
+    pub fn with_session_tracer(mut self, session_tracer: SessionTracer) -> Self {
+        self.session_tracer = Some(session_tracer);
+        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
-            .push_user_text(user_input.into())
-            .map_err(|error| RuntimeError::new(error.to_string()))?;
+            .messages
+            .push(ConversationMessage::user_text(user_input));
 
         let mut assistant_messages = Vec::new();
         let mut tool_results = Vec::new();
@@ -166,17 +180,31 @@ where
         loop {
             iterations += 1;
             if iterations > self.max_iterations {
-                return Err(RuntimeError::new(
+                let error = 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 = self.api_client.stream(request)?;
-            let (assistant_message, usage) = build_assistant_message(events)?;
+            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);
+                }
+            };
             if let Some(usage) = usage {
                 self.usage_tracker.record(usage);
             }
@@ -190,10 +218,13 @@ where
                     _ => None,
                 })
                 .collect::<Vec<_>>();
+            self.record_assistant_iteration(
+                iterations,
+                &assistant_message,
+                pending_tool_uses.len(),
+            );
 
-            self.session
-                .push_message(assistant_message.clone())
-                .map_err(|error| RuntimeError::new(error.to_string()))?;
+            self.session.messages.push(assistant_message.clone());
             assistant_messages.push(assistant_message);
 
             if pending_tool_uses.is_empty() {
@@ -201,6 +232,7 @@ 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))
@@ -251,19 +283,20 @@ where
                         ConversationMessage::tool_result(tool_use_id, tool_name, reason, true)
                     }
                 };
-                self.session
-                    .push_message(result_message.clone())
-                    .map_err(|error| RuntimeError::new(error.to_string()))?;
+                self.record_tool_finished(iterations, &result_message);
+                self.session.messages.push(result_message.clone());
                 tool_results.push(result_message);
             }
         }
 
-        Ok(TurnSummary {
+        let summary = TurnSummary {
             assistant_messages,
             tool_results,
             iterations,
             usage: self.usage_tracker.cumulative_usage(),
-        })
+        };
+        self.record_turn_completed(&summary);
+        Ok(summary)
     }
 
     #[must_use]
@@ -286,15 +319,130 @@ where
         &self.session
     }
 
-    #[must_use]
-    pub fn fork_session(&self, branch_name: Option<String>) -> Session {
-        self.session.fork(branch_name)
-    }
-
     #[must_use]
     pub fn into_session(self) -> Session {
         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 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)),
+        );
+        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);
+        }
+    }
+
+    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);
+        }
+    }
 }
 
 fn build_assistant_message(
@@ -417,9 +565,9 @@ mod tests {
     use crate::prompt::{ProjectContext, SystemPromptBuilder};
     use crate::session::{ContentBlock, MessageRole, Session};
     use crate::usage::TokenUsage;
-    use std::fs;
     use std::path::PathBuf;
-    use std::time::{SystemTime, UNIX_EPOCH};
+    use std::sync::Arc;
+    use telemetry::{MemoryTelemetrySink, SessionTracer, TelemetryEvent};
 
     struct ScriptedApiClient {
         call_count: usize,
@@ -532,6 +680,39 @@ 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;
@@ -620,7 +801,7 @@ mod tests {
             }),
             PermissionPolicy::new(PermissionMode::DangerFullAccess),
             vec!["system".to_string()],
-            RuntimeFeatureConfig::default().with_hooks(RuntimeHookConfig::new(
+            &RuntimeFeatureConfig::default().with_hooks(RuntimeHookConfig::new(
                 vec![shell_snippet("printf 'blocked by hook'; exit 2")],
                 Vec::new(),
             )),
@@ -686,7 +867,7 @@ mod tests {
             StaticToolExecutor::new().register("add", |_input| Ok("4".to_string())),
             PermissionPolicy::new(PermissionMode::DangerFullAccess),
             vec!["system".to_string()],
-            RuntimeFeatureConfig::default().with_hooks(RuntimeHookConfig::new(
+            &RuntimeFeatureConfig::default().with_hooks(RuntimeHookConfig::new(
                 vec![shell_snippet("printf 'pre hook ran'")],
                 vec![shell_snippet("printf 'post hook ran'")],
             )),
@@ -708,7 +889,7 @@ mod tests {
             "post hook should preserve non-error result: {output:?}"
         );
         assert!(
-            output.contains("4"),
+            output.contains('4'),
             "tool output missing value: {output:?}"
         );
         assert!(
@@ -798,86 +979,6 @@ mod tests {
             result.compacted_session.messages[0].role,
             MessageRole::System
         );
-        assert_eq!(
-            result.compacted_session.session_id,
-            runtime.session().session_id
-        );
-        assert!(result.compacted_session.compaction.is_some());
-    }
-
-    #[test]
-    fn persists_conversation_turn_messages_to_jsonl_session() {
-        struct SimpleApi;
-        impl ApiClient for SimpleApi {
-            fn stream(
-                &mut self,
-                _request: ApiRequest,
-            ) -> Result<Vec<AssistantEvent>, RuntimeError> {
-                Ok(vec![
-                    AssistantEvent::TextDelta("done".to_string()),
-                    AssistantEvent::MessageStop,
-                ])
-            }
-        }
-
-        let path = temp_session_path("persisted-turn");
-        let session = Session::new().with_persistence_path(path.clone());
-        let mut runtime = ConversationRuntime::new(
-            session,
-            SimpleApi,
-            StaticToolExecutor::new(),
-            PermissionPolicy::new(PermissionMode::DangerFullAccess),
-            vec!["system".to_string()],
-        );
-
-        runtime
-            .run_turn("persist this turn", None)
-            .expect("turn should succeed");
-
-        let restored = Session::load_from_path(&path).expect("persisted session should reload");
-        fs::remove_file(&path).expect("temp session file should be removable");
-
-        assert_eq!(restored.messages.len(), 2);
-        assert_eq!(restored.messages[0].role, MessageRole::User);
-        assert_eq!(restored.messages[1].role, MessageRole::Assistant);
-        assert_eq!(restored.session_id, runtime.session().session_id);
-    }
-
-    #[test]
-    fn forks_runtime_session_without_mutating_original() {
-        let mut session = Session::new();
-        session
-            .push_user_text("branch me")
-            .expect("message should append");
-
-        let runtime = ConversationRuntime::new(
-            session.clone(),
-            ScriptedApiClient { call_count: 0 },
-            StaticToolExecutor::new(),
-            PermissionPolicy::new(PermissionMode::DangerFullAccess),
-            vec!["system".to_string()],
-        );
-
-        let forked = runtime.fork_session(Some("alt-path".to_string()));
-
-        assert_eq!(forked.messages, session.messages);
-        assert_ne!(forked.session_id, session.session_id);
-        assert_eq!(
-            forked
-                .fork
-                .as_ref()
-                .map(|fork| (fork.parent_session_id.as_str(), fork.branch_name.as_deref())),
-            Some((session.session_id.as_str(), Some("alt-path")))
-        );
-        assert!(runtime.session().fork.is_none());
-    }
-
-    fn temp_session_path(label: &str) -> PathBuf {
-        let nanos = SystemTime::now()
-            .duration_since(UNIX_EPOCH)
-            .expect("system time should be after epoch")
-            .as_nanos();
-        std::env::temp_dir().join(format!("runtime-conversation-{label}-{nanos}.json"))
     }
 
     #[cfg(windows)]

rust/crates/runtime/src/hooks.rs

@@ -64,7 +64,7 @@ impl HookRunner {
 
     #[must_use]
     pub fn run_pre_tool_use(&self, tool_name: &str, tool_input: &str) -> HookRunResult {
-        self.run_commands(
+        Self::run_commands(
             HookEvent::PreToolUse,
             self.config.pre_tool_use(),
             tool_name,
@@ -82,7 +82,7 @@ impl HookRunner {
         tool_output: &str,
         is_error: bool,
     ) -> HookRunResult {
-        self.run_commands(
+        Self::run_commands(
             HookEvent::PostToolUse,
             self.config.post_tool_use(),
             tool_name,
@@ -93,7 +93,6 @@ impl HookRunner {
     }
 
     fn run_commands(
-        &self,
         event: HookEvent,
         commands: &[String],
         tool_name: &str,
@@ -114,19 +113,19 @@ impl HookRunner {
             "tool_result_is_error": is_error,
         })
         .to_string();
-
-        let mut messages = Vec::new();
-
-        for command in commands {
-            match self.run_command(
-                command,
+        let invocation = HookInvocation {
             event,
             tool_name,
             tool_input,
             tool_output,
             is_error,
-                &payload,
-            ) {
+            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);
@@ -149,29 +148,23 @@ impl HookRunner {
         HookRunResult::allow(messages)
     }
 
-    fn run_command(
-        &self,
-        command: &str,
-        event: HookEvent,
-        tool_name: &str,
-        tool_input: &str,
-        tool_output: Option<&str>,
-        is_error: bool,
-        payload: &str,
-    ) -> HookCommandOutcome {
+    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", event.as_str());
-        child.env("HOOK_TOOL_NAME", tool_name);
-        child.env("HOOK_TOOL_INPUT", tool_input);
-        child.env("HOOK_TOOL_IS_ERROR", if is_error { "1" } else { "0" });
-        if let Some(tool_output) = tool_output {
+        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(payload.as_bytes()) {
+        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();
@@ -189,8 +182,9 @@ impl HookRunner {
                     },
                     None => HookCommandOutcome::Warn {
                         message: format!(
-                            "{} hook `{command}` terminated by signal while handling `{tool_name}`",
-                            event.as_str()
+                            "{} hook `{command}` terminated by signal while handling `{}`",
+                            invocation.event.as_str(),
+                            invocation.tool_name
                         ),
                     },
                 }
@@ -198,13 +192,23 @@ impl HookRunner {
             Err(error) => HookCommandOutcome::Warn {
                 message: format!(
                     "{} hook `{command}` failed to start for `{tool_name}`: {error}",
-                    event.as_str()
+                    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> },

rust/crates/runtime/src/lib.rs

@@ -76,10 +76,7 @@ pub use remote::{
     RemoteSessionContext, UpstreamProxyBootstrap, UpstreamProxyState, DEFAULT_REMOTE_BASE_URL,
     DEFAULT_SESSION_TOKEN_PATH, DEFAULT_SYSTEM_CA_BUNDLE, NO_PROXY_HOSTS, UPSTREAM_PROXY_ENV_KEYS,
 };
-pub use session::{
-    ContentBlock, ConversationMessage, MessageRole, Session, SessionCompaction, SessionError,
-    SessionFork,
-};
+pub use session::{ContentBlock, ConversationMessage, MessageRole, Session, SessionError};
 pub use usage::{
     format_usd, pricing_for_model, ModelPricing, TokenUsage, UsageCostEstimate, UsageTracker,
 };

rust/crates/runtime/src/mcp_stdio.rs

@@ -1144,8 +1144,20 @@ mod tests {
     }
 
     fn cleanup_script(script_path: &Path) {
-        fs::remove_file(script_path).expect("cleanup script");
-        fs::remove_dir_all(script_path.parent().expect("script parent")).expect("cleanup dir");
+        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}"
+            );
+        }
     }
 
     fn manager_server_config(

rust/crates/runtime/src/session.rs

@@ -1,19 +1,11 @@
 use std::collections::BTreeMap;
 use std::fmt::{Display, Formatter};
-use std::fs::{self, OpenOptions};
-use std::io::Write;
-use std::path::{Path, PathBuf};
-use std::sync::atomic::{AtomicU64, Ordering};
-use std::time::{SystemTime, UNIX_EPOCH};
+use std::fs;
+use std::path::Path;
 
 use crate::json::{JsonError, JsonValue};
 use crate::usage::TokenUsage;
 
-const SESSION_VERSION: u32 = 1;
-const ROTATE_AFTER_BYTES: u64 = 256 * 1024;
-const MAX_ROTATED_FILES: usize = 3;
-static SESSION_ID_COUNTER: AtomicU64 = AtomicU64::new(0);
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum MessageRole {
     System,
@@ -48,49 +40,11 @@ pub struct ConversationMessage {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct SessionCompaction {
-    pub count: u32,
-    pub removed_message_count: usize,
-    pub summary: String,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct SessionFork {
-    pub parent_session_id: String,
-    pub branch_name: Option<String>,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-struct SessionPersistence {
-    path: PathBuf,
-}
-
-#[derive(Debug, Clone)]
 pub struct Session {
     pub version: u32,
-    pub session_id: String,
-    pub created_at_ms: u64,
-    pub updated_at_ms: u64,
     pub messages: Vec<ConversationMessage>,
-    pub compaction: Option<SessionCompaction>,
-    pub fork: Option<SessionFork>,
-    persistence: Option<SessionPersistence>,
 }
 
-impl PartialEq for Session {
-    fn eq(&self, other: &Self) -> bool {
-        self.version == other.version
-            && self.session_id == other.session_id
-            && self.created_at_ms == other.created_at_ms
-            && self.updated_at_ms == other.updated_at_ms
-            && self.messages == other.messages
-            && self.compaction == other.compaction
-            && self.fork == other.fork
-    }
-}
-
-impl Eq for Session {}
-
 #[derive(Debug)]
 pub enum SessionError {
     Io(std::io::Error),
@@ -125,84 +79,20 @@ impl From<JsonError> for SessionError {
 impl Session {
     #[must_use]
     pub fn new() -> Self {
-        let now = current_time_millis();
         Self {
-            version: SESSION_VERSION,
-            session_id: generate_session_id(),
-            created_at_ms: now,
-            updated_at_ms: now,
+            version: 1,
             messages: Vec::new(),
-            compaction: None,
-            fork: None,
-            persistence: None,
         }
     }
 
-    #[must_use]
-    pub fn with_persistence_path(mut self, path: impl Into<PathBuf>) -> Self {
-        self.persistence = Some(SessionPersistence { path: path.into() });
-        self
-    }
-
-    #[must_use]
-    pub fn persistence_path(&self) -> Option<&Path> {
-        self.persistence.as_ref().map(|value| value.path.as_path())
-    }
-
     pub fn save_to_path(&self, path: impl AsRef<Path>) -> Result<(), SessionError> {
-        let path = path.as_ref();
-        rotate_session_file_if_needed(path)?;
-        write_atomic(path, &self.render_jsonl_snapshot())?;
-        cleanup_rotated_logs(path)?;
+        fs::write(path, self.to_json().render())?;
         Ok(())
     }
 
     pub fn load_from_path(path: impl AsRef<Path>) -> Result<Self, SessionError> {
-        let path = path.as_ref();
         let contents = fs::read_to_string(path)?;
-        let session = match JsonValue::parse(&contents) {
-            Ok(value) => Self::from_json(&value)?,
-            Err(_) => Self::from_jsonl(&contents)?,
-        };
-        Ok(session.with_persistence_path(path.to_path_buf()))
-    }
-
-    pub fn push_message(&mut self, message: ConversationMessage) -> Result<(), SessionError> {
-        self.touch();
-        self.messages.push(message.clone());
-        self.append_persisted_message(&message)
-    }
-
-    pub fn push_user_text(&mut self, text: impl Into<String>) -> Result<(), SessionError> {
-        self.push_message(ConversationMessage::user_text(text))
-    }
-
-    pub fn record_compaction(&mut self, summary: impl Into<String>, removed_message_count: usize) {
-        self.touch();
-        let count = self.compaction.as_ref().map_or(1, |value| value.count + 1);
-        self.compaction = Some(SessionCompaction {
-            count,
-            removed_message_count,
-            summary: summary.into(),
-        });
-    }
-
-    #[must_use]
-    pub fn fork(&self, branch_name: Option<String>) -> Self {
-        let now = current_time_millis();
-        Self {
-            version: self.version,
-            session_id: generate_session_id(),
-            created_at_ms: now,
-            updated_at_ms: now,
-            messages: self.messages.clone(),
-            compaction: self.compaction.clone(),
-            fork: Some(SessionFork {
-                parent_session_id: self.session_id.clone(),
-                branch_name: normalize_optional_string(branch_name),
-            }),
-            persistence: None,
-        }
+        Self::from_json(&JsonValue::parse(&contents)?)
     }
 
     #[must_use]
@@ -212,18 +102,6 @@ impl Session {
             "version".to_string(),
             JsonValue::Number(i64::from(self.version)),
         );
-        object.insert(
-            "session_id".to_string(),
-            JsonValue::String(self.session_id.clone()),
-        );
-        object.insert(
-            "created_at_ms".to_string(),
-            JsonValue::Number(i64_from_u64(self.created_at_ms, "created_at_ms")),
-        );
-        object.insert(
-            "updated_at_ms".to_string(),
-            JsonValue::Number(i64_from_u64(self.updated_at_ms, "updated_at_ms")),
-        );
         object.insert(
             "messages".to_string(),
             JsonValue::Array(
@@ -233,12 +111,6 @@ impl Session {
                     .collect(),
             ),
         );
-        if let Some(compaction) = &self.compaction {
-            object.insert("compaction".to_string(), compaction.to_json());
-        }
-        if let Some(fork) = &self.fork {
-            object.insert("fork".to_string(), fork.to_json());
-        }
         JsonValue::Object(object)
     }
 
@@ -259,179 +131,7 @@ impl Session {
             .iter()
             .map(ConversationMessage::from_json)
             .collect::<Result<Vec<_>, _>>()?;
-        let now = current_time_millis();
-        let session_id = object
-            .get("session_id")
-            .and_then(JsonValue::as_str)
-            .map(ToOwned::to_owned)
-            .unwrap_or_else(generate_session_id);
-        let created_at_ms = object
-            .get("created_at_ms")
-            .map(|value| required_u64_from_value(value, "created_at_ms"))
-            .transpose()?
-            .unwrap_or(now);
-        let updated_at_ms = object
-            .get("updated_at_ms")
-            .map(|value| required_u64_from_value(value, "updated_at_ms"))
-            .transpose()?
-            .unwrap_or(created_at_ms);
-        let compaction = object
-            .get("compaction")
-            .map(SessionCompaction::from_json)
-            .transpose()?;
-        let fork = object.get("fork").map(SessionFork::from_json).transpose()?;
-        Ok(Self {
-            version,
-            session_id,
-            created_at_ms,
-            updated_at_ms,
-            messages,
-            compaction,
-            fork,
-            persistence: None,
-        })
-    }
-
-    fn from_jsonl(contents: &str) -> Result<Self, SessionError> {
-        let mut version = SESSION_VERSION;
-        let mut session_id = None;
-        let mut created_at_ms = None;
-        let mut updated_at_ms = None;
-        let mut messages = Vec::new();
-        let mut compaction = None;
-        let mut fork = None;
-
-        for (line_number, raw_line) in contents.lines().enumerate() {
-            let line = raw_line.trim();
-            if line.is_empty() {
-                continue;
-            }
-            let value = JsonValue::parse(line).map_err(|error| {
-                SessionError::Format(format!(
-                    "invalid JSONL record at line {}: {}",
-                    line_number + 1,
-                    error
-                ))
-            })?;
-            let object = value.as_object().ok_or_else(|| {
-                SessionError::Format(format!(
-                    "JSONL record at line {} must be an object",
-                    line_number + 1
-                ))
-            })?;
-            match object
-                .get("type")
-                .and_then(JsonValue::as_str)
-                .ok_or_else(|| {
-                    SessionError::Format(format!(
-                        "JSONL record at line {} missing type",
-                        line_number + 1
-                    ))
-                })? {
-                "session_meta" => {
-                    version = required_u32(object, "version")?;
-                    session_id = Some(required_string(object, "session_id")?);
-                    created_at_ms = Some(required_u64(object, "created_at_ms")?);
-                    updated_at_ms = Some(required_u64(object, "updated_at_ms")?);
-                    fork = object.get("fork").map(SessionFork::from_json).transpose()?;
-                }
-                "message" => {
-                    let message_value = object.get("message").ok_or_else(|| {
-                        SessionError::Format(format!(
-                            "JSONL record at line {} missing message",
-                            line_number + 1
-                        ))
-                    })?;
-                    messages.push(ConversationMessage::from_json(message_value)?);
-                }
-                "compaction" => {
-                    compaction = Some(SessionCompaction::from_json(&JsonValue::Object(
-                        object.clone(),
-                    ))?);
-                }
-                other => {
-                    return Err(SessionError::Format(format!(
-                        "unsupported JSONL record type at line {}: {other}",
-                        line_number + 1
-                    )))
-                }
-            }
-        }
-
-        let now = current_time_millis();
-        Ok(Self {
-            version,
-            session_id: session_id.unwrap_or_else(generate_session_id),
-            created_at_ms: created_at_ms.unwrap_or(now),
-            updated_at_ms: updated_at_ms.unwrap_or(created_at_ms.unwrap_or(now)),
-            messages,
-            compaction,
-            fork,
-            persistence: None,
-        })
-    }
-
-    fn render_jsonl_snapshot(&self) -> String {
-        let mut lines = vec![self.meta_record().render()];
-        if let Some(compaction) = &self.compaction {
-            lines.push(compaction.to_jsonl_record().render());
-        }
-        lines.extend(
-            self.messages
-                .iter()
-                .map(|message| message_record(message).render()),
-        );
-        let mut rendered = lines.join("\n");
-        rendered.push('\n');
-        rendered
-    }
-
-    fn append_persisted_message(&self, message: &ConversationMessage) -> Result<(), SessionError> {
-        let Some(path) = self.persistence_path() else {
-            return Ok(());
-        };
-
-        let needs_bootstrap = !path.exists() || fs::metadata(path)?.len() == 0;
-        if needs_bootstrap {
-            self.save_to_path(path)?;
-            return Ok(());
-        }
-
-        let mut file = OpenOptions::new().append(true).open(path)?;
-        writeln!(file, "{}", message_record(message).render())?;
-        Ok(())
-    }
-
-    fn meta_record(&self) -> JsonValue {
-        let mut object = BTreeMap::new();
-        object.insert(
-            "type".to_string(),
-            JsonValue::String("session_meta".to_string()),
-        );
-        object.insert(
-            "version".to_string(),
-            JsonValue::Number(i64::from(self.version)),
-        );
-        object.insert(
-            "session_id".to_string(),
-            JsonValue::String(self.session_id.clone()),
-        );
-        object.insert(
-            "created_at_ms".to_string(),
-            JsonValue::Number(i64_from_u64(self.created_at_ms, "created_at_ms")),
-        );
-        object.insert(
-            "updated_at_ms".to_string(),
-            JsonValue::Number(i64_from_u64(self.updated_at_ms, "updated_at_ms")),
-        );
-        if let Some(fork) = &self.fork {
-            object.insert("fork".to_string(), fork.to_json());
-        }
-        JsonValue::Object(object)
-    }
-
-    fn touch(&mut self) {
-        self.updated_at_ms = current_time_millis();
+        Ok(Self { version, messages })
     }
 }
 
@@ -624,92 +324,6 @@ impl ContentBlock {
     }
 }
 
-impl SessionCompaction {
-    #[must_use]
-    pub fn to_json(&self) -> JsonValue {
-        let mut object = BTreeMap::new();
-        object.insert(
-            "count".to_string(),
-            JsonValue::Number(i64::from(self.count)),
-        );
-        object.insert(
-            "removed_message_count".to_string(),
-            JsonValue::Number(i64_from_usize(
-                self.removed_message_count,
-                "removed_message_count",
-            )),
-        );
-        object.insert(
-            "summary".to_string(),
-            JsonValue::String(self.summary.clone()),
-        );
-        JsonValue::Object(object)
-    }
-
-    #[must_use]
-    pub fn to_jsonl_record(&self) -> JsonValue {
-        let mut object = self
-            .to_json()
-            .as_object()
-            .cloned()
-            .expect("compaction should render to object");
-        object.insert(
-            "type".to_string(),
-            JsonValue::String("compaction".to_string()),
-        );
-        JsonValue::Object(object)
-    }
-
-    fn from_json(value: &JsonValue) -> Result<Self, SessionError> {
-        let object = value
-            .as_object()
-            .ok_or_else(|| SessionError::Format("compaction must be an object".to_string()))?;
-        Ok(Self {
-            count: required_u32(object, "count")?,
-            removed_message_count: required_usize(object, "removed_message_count")?,
-            summary: required_string(object, "summary")?,
-        })
-    }
-}
-
-impl SessionFork {
-    #[must_use]
-    pub fn to_json(&self) -> JsonValue {
-        let mut object = BTreeMap::new();
-        object.insert(
-            "parent_session_id".to_string(),
-            JsonValue::String(self.parent_session_id.clone()),
-        );
-        if let Some(branch_name) = &self.branch_name {
-            object.insert(
-                "branch_name".to_string(),
-                JsonValue::String(branch_name.clone()),
-            );
-        }
-        JsonValue::Object(object)
-    }
-
-    fn from_json(value: &JsonValue) -> Result<Self, SessionError> {
-        let object = value
-            .as_object()
-            .ok_or_else(|| SessionError::Format("fork metadata must be an object".to_string()))?;
-        Ok(Self {
-            parent_session_id: required_string(object, "parent_session_id")?,
-            branch_name: object
-                .get("branch_name")
-                .and_then(JsonValue::as_str)
-                .map(ToOwned::to_owned),
-        })
-    }
-}
-
-fn message_record(message: &ConversationMessage) -> JsonValue {
-    let mut object = BTreeMap::new();
-    object.insert("type".to_string(), JsonValue::String("message".to_string()));
-    object.insert("message".to_string(), message.to_json());
-    JsonValue::Object(object)
-}
-
 fn usage_to_json(usage: TokenUsage) -> JsonValue {
     let mut object = BTreeMap::new();
     object.insert(
@@ -762,155 +376,22 @@ fn required_u32(object: &BTreeMap<String, JsonValue>, key: &str) -> Result<u32,
     u32::try_from(value).map_err(|_| SessionError::Format(format!("{key} out of range")))
 }
 
-fn required_u64(object: &BTreeMap<String, JsonValue>, key: &str) -> Result<u64, SessionError> {
-    let value = object
-        .get(key)
-        .ok_or_else(|| SessionError::Format(format!("missing {key}")))?;
-    required_u64_from_value(value, key)
-}
-
-fn required_u64_from_value(value: &JsonValue, key: &str) -> Result<u64, SessionError> {
-    let value = value
-        .as_i64()
-        .ok_or_else(|| SessionError::Format(format!("missing {key}")))?;
-    u64::try_from(value).map_err(|_| SessionError::Format(format!("{key} out of range")))
-}
-
-fn required_usize(object: &BTreeMap<String, JsonValue>, key: &str) -> Result<usize, SessionError> {
-    let value = object
-        .get(key)
-        .and_then(JsonValue::as_i64)
-        .ok_or_else(|| SessionError::Format(format!("missing {key}")))?;
-    usize::try_from(value).map_err(|_| SessionError::Format(format!("{key} out of range")))
-}
-
-fn i64_from_u64(value: u64, key: &str) -> i64 {
-    i64::try_from(value).unwrap_or_else(|_| panic!("{key} out of range for JSON number"))
-}
-
-fn i64_from_usize(value: usize, key: &str) -> i64 {
-    i64::try_from(value).unwrap_or_else(|_| panic!("{key} out of range for JSON number"))
-}
-
-fn normalize_optional_string(value: Option<String>) -> Option<String> {
-    value.and_then(|value| {
-        let trimmed = value.trim();
-        if trimmed.is_empty() {
-            None
-        } else {
-            Some(trimmed.to_string())
-        }
-    })
-}
-
-fn current_time_millis() -> u64 {
-    SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .map(|duration| duration.as_millis() as u64)
-        .unwrap_or_default()
-}
-
-fn generate_session_id() -> String {
-    let millis = current_time_millis();
-    let counter = SESSION_ID_COUNTER.fetch_add(1, Ordering::Relaxed);
-    format!("session-{millis}-{counter}")
-}
-
-fn write_atomic(path: &Path, contents: &str) -> Result<(), SessionError> {
-    if let Some(parent) = path.parent() {
-        fs::create_dir_all(parent)?;
-    }
-    let temp_path = temporary_path_for(path);
-    fs::write(&temp_path, contents)?;
-    fs::rename(temp_path, path)?;
-    Ok(())
-}
-
-fn temporary_path_for(path: &Path) -> PathBuf {
-    let file_name = path
-        .file_name()
-        .and_then(|value| value.to_str())
-        .unwrap_or("session");
-    path.with_file_name(format!(
-        "{file_name}.tmp-{}-{}",
-        current_time_millis(),
-        SESSION_ID_COUNTER.fetch_add(1, Ordering::Relaxed)
-    ))
-}
-
-fn rotate_session_file_if_needed(path: &Path) -> Result<(), SessionError> {
-    let Ok(metadata) = fs::metadata(path) else {
-        return Ok(());
-    };
-    if metadata.len() < ROTATE_AFTER_BYTES {
-        return Ok(());
-    }
-    let rotated_path = rotated_log_path(path);
-    fs::rename(path, rotated_path)?;
-    Ok(())
-}
-
-fn rotated_log_path(path: &Path) -> PathBuf {
-    let stem = path
-        .file_stem()
-        .and_then(|value| value.to_str())
-        .unwrap_or("session");
-    path.with_file_name(format!("{stem}.rot-{}.jsonl", current_time_millis()))
-}
-
-fn cleanup_rotated_logs(path: &Path) -> Result<(), SessionError> {
-    let Some(parent) = path.parent() else {
-        return Ok(());
-    };
-    let stem = path
-        .file_stem()
-        .and_then(|value| value.to_str())
-        .unwrap_or("session");
-    let prefix = format!("{stem}.rot-");
-    let mut rotated_paths = fs::read_dir(parent)?
-        .filter_map(Result::ok)
-        .map(|entry| entry.path())
-        .filter(|entry_path| {
-            entry_path
-                .file_name()
-                .and_then(|value| value.to_str())
-                .is_some_and(|name| name.starts_with(&prefix) && name.ends_with(".jsonl"))
-        })
-        .collect::<Vec<_>>();
-
-    rotated_paths.sort_by_key(|entry_path| {
-        fs::metadata(entry_path)
-            .and_then(|metadata| metadata.modified())
-            .unwrap_or(UNIX_EPOCH)
-    });
-
-    let remove_count = rotated_paths.len().saturating_sub(MAX_ROTATED_FILES);
-    for stale_path in rotated_paths.into_iter().take(remove_count) {
-        fs::remove_file(stale_path)?;
-    }
-    Ok(())
-}
-
 #[cfg(test)]
 mod tests {
-    use super::{
-        cleanup_rotated_logs, rotate_session_file_if_needed, ContentBlock, ConversationMessage,
-        MessageRole, Session, SessionFork,
-    };
-    use crate::json::JsonValue;
+    use super::{ContentBlock, ConversationMessage, MessageRole, Session};
     use crate::usage::TokenUsage;
     use std::fs;
-    use std::path::PathBuf;
     use std::time::{SystemTime, UNIX_EPOCH};
 
     #[test]
-    fn persists_and_restores_session_jsonl() {
+    fn persists_and_restores_session_json() {
         let mut session = Session::new();
         session
-            .push_user_text("hello")
-            .expect("user message should append");
+            .messages
+            .push(ConversationMessage::user_text("hello"));
         session
-            .push_message(ConversationMessage::assistant_with_usage(
+            .messages
+            .push(ConversationMessage::assistant_with_usage(
                 vec![
                     ContentBlock::Text {
                         text: "thinking".to_string(),
@@ -927,15 +408,16 @@ mod tests {
                     cache_creation_input_tokens: 1,
                     cache_read_input_tokens: 2,
                 }),
-            ))
-            .expect("assistant message should append");
-        session
-            .push_message(ConversationMessage::tool_result(
+            ));
+        session.messages.push(ConversationMessage::tool_result(
             "tool-1", "bash", "hi", false,
-            ))
-            .expect("tool result should append");
+        ));
 
-        let path = temp_session_path("jsonl");
+        let nanos = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .expect("system time should be after epoch")
+            .as_nanos();
+        let path = std::env::temp_dir().join(format!("runtime-session-{nanos}.json"));
         session.save_to_path(&path).expect("session should save");
         let restored = Session::load_from_path(&path).expect("session should load");
         fs::remove_file(&path).expect("temp file should be removable");
@@ -946,157 +428,5 @@ mod tests {
             restored.messages[1].usage.expect("usage").total_tokens(),
             17
         );
-        assert_eq!(restored.session_id, session.session_id);
-    }
-
-    #[test]
-    fn loads_legacy_session_json_object() {
-        let path = temp_session_path("legacy");
-        let legacy = JsonValue::Object(
-            [
-                ("version".to_string(), JsonValue::Number(1)),
-                (
-                    "messages".to_string(),
-                    JsonValue::Array(vec![ConversationMessage::user_text("legacy").to_json()]),
-                ),
-            ]
-            .into_iter()
-            .collect(),
-        );
-        fs::write(&path, legacy.render()).expect("legacy file should write");
-
-        let restored = Session::load_from_path(&path).expect("legacy session should load");
-        fs::remove_file(&path).expect("temp file should be removable");
-
-        assert_eq!(restored.messages.len(), 1);
-        assert_eq!(
-            restored.messages[0],
-            ConversationMessage::user_text("legacy")
-        );
-        assert!(!restored.session_id.is_empty());
-    }
-
-    #[test]
-    fn appends_messages_to_persisted_jsonl_session() {
-        let path = temp_session_path("append");
-        let mut session = Session::new().with_persistence_path(path.clone());
-        session
-            .save_to_path(&path)
-            .expect("initial save should succeed");
-        session
-            .push_user_text("hi")
-            .expect("user append should succeed");
-        session
-            .push_message(ConversationMessage::assistant(vec![ContentBlock::Text {
-                text: "hello".to_string(),
-            }]))
-            .expect("assistant append should succeed");
-
-        let restored = Session::load_from_path(&path).expect("session should replay from jsonl");
-        fs::remove_file(&path).expect("temp file should be removable");
-
-        assert_eq!(restored.messages.len(), 2);
-        assert_eq!(restored.messages[0], ConversationMessage::user_text("hi"));
-    }
-
-    #[test]
-    fn persists_compaction_metadata() {
-        let path = temp_session_path("compaction");
-        let mut session = Session::new();
-        session
-            .push_user_text("before")
-            .expect("message should append");
-        session.record_compaction("summarized earlier work", 4);
-        session.save_to_path(&path).expect("session should save");
-
-        let restored = Session::load_from_path(&path).expect("session should load");
-        fs::remove_file(&path).expect("temp file should be removable");
-
-        let compaction = restored.compaction.expect("compaction metadata");
-        assert_eq!(compaction.count, 1);
-        assert_eq!(compaction.removed_message_count, 4);
-        assert!(compaction.summary.contains("summarized"));
-    }
-
-    #[test]
-    fn forks_sessions_with_branch_metadata_and_persists_it() {
-        let path = temp_session_path("fork");
-        let mut session = Session::new();
-        session
-            .push_user_text("before fork")
-            .expect("message should append");
-
-        let forked = session
-            .fork(Some("investigation".to_string()))
-            .with_persistence_path(path.clone());
-        forked
-            .save_to_path(&path)
-            .expect("forked session should save");
-
-        let restored = Session::load_from_path(&path).expect("forked session should load");
-        fs::remove_file(&path).expect("temp file should be removable");
-
-        assert_ne!(restored.session_id, session.session_id);
-        assert_eq!(
-            restored.fork,
-            Some(SessionFork {
-                parent_session_id: session.session_id,
-                branch_name: Some("investigation".to_string()),
-            })
-        );
-        assert_eq!(restored.messages, forked.messages);
-    }
-
-    #[test]
-    fn rotates_and_cleans_up_large_session_logs() {
-        let path = temp_session_path("rotation");
-        fs::write(&path, "x".repeat((super::ROTATE_AFTER_BYTES + 10) as usize))
-            .expect("oversized file should write");
-        rotate_session_file_if_needed(&path).expect("rotation should succeed");
-        assert!(
-            !path.exists(),
-            "original path should be rotated away before rewrite"
-        );
-
-        for _ in 0..5 {
-            let rotated = super::rotated_log_path(&path);
-            fs::write(&rotated, "old").expect("rotated file should write");
-        }
-        cleanup_rotated_logs(&path).expect("cleanup should succeed");
-
-        let rotated_count = rotation_files(&path).len();
-        assert!(rotated_count <= super::MAX_ROTATED_FILES);
-        for rotated in rotation_files(&path) {
-            fs::remove_file(rotated).expect("rotated file should be removable");
-        }
-    }
-
-    fn temp_session_path(label: &str) -> PathBuf {
-        let nanos = SystemTime::now()
-            .duration_since(UNIX_EPOCH)
-            .expect("system time should be after epoch")
-            .as_nanos();
-        std::env::temp_dir().join(format!("runtime-session-{label}-{nanos}.json"))
-    }
-
-    fn rotation_files(path: &PathBuf) -> Vec<PathBuf> {
-        let stem = path
-            .file_stem()
-            .and_then(|value| value.to_str())
-            .expect("temp path should have file stem")
-            .to_string();
-        fs::read_dir(path.parent().expect("temp path should have parent"))
-            .expect("temp dir should read")
-            .filter_map(Result::ok)
-            .map(|entry| entry.path())
-            .filter(|entry_path| {
-                entry_path
-                    .file_name()
-                    .and_then(|value| value.to_str())
-                    .is_some_and(|name| {
-                        name.starts_with(&format!("{stem}.rot-")) && name.ends_with(".jsonl")
-                    })
-            })
-            .collect()
     }
 }

rust/crates/runtime/src/usage.rs

@@ -286,8 +286,9 @@ mod tests {
 
     #[test]
     fn reconstructs_usage_from_session_messages() {
-        let mut session = Session::new();
-        session.messages = vec![ConversationMessage {
+        let session = Session {
+            version: 1,
+            messages: vec![ConversationMessage {
                 role: MessageRole::Assistant,
                 blocks: vec![ContentBlock::Text {
                     text: "done".to_string(),
@@ -298,7 +299,8 @@ mod tests {
                     cache_creation_input_tokens: 1,
                     cache_read_input_tokens: 0,
                 }),
-        }];
+            }],
+        };
 
         let tracker = UsageTracker::from_session(&session);
         assert_eq!(tracker.turns(), 1);

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

@@ -4,17 +4,19 @@ 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;
 use std::path::{Path, PathBuf};
 use std::process::Command;
-use std::time::UNIX_EPOCH;
+use std::time::{SystemTime, UNIX_EPOCH};
 
 use api::{
     resolve_startup_auth_source, AnthropicClient, AuthSource, ContentBlockDelta, InputContentBlock,
-    InputMessage, MessageRequest, MessageResponse, OutputContentBlock,
-    StreamEvent as ApiStreamEvent, ToolChoice, ToolDefinition, ToolResultContentBlock,
+    InputMessage, JsonlTelemetrySink, MessageRequest, MessageResponse, OutputContentBlock,
+    SessionTracer, StreamEvent as ApiStreamEvent, ToolChoice, ToolDefinition,
+    ToolResultContentBlock,
 };
 
 use commands::{
@@ -44,11 +46,10 @@ 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");
-const PRIMARY_SESSION_EXTENSION: &str = "jsonl";
-const LEGACY_SESSION_EXTENSION: &str = "json";
 
 type AllowedToolSet = BTreeSet<String>;
 
@@ -591,19 +592,7 @@ fn print_version() {
 }
 
 fn resume_session(session_path: &Path, commands: &[String]) {
-    let resolved_path = if session_path.exists() {
-        session_path.to_path_buf()
-    } else {
-        match resolve_session_reference(&session_path.display().to_string()) {
-            Ok(handle) => handle.path,
-            Err(error) => {
-                eprintln!("failed to restore session: {error}");
-                std::process::exit(1);
-            }
-        }
-    };
-
-    let session = match Session::load_from_path(&resolved_path) {
+    let session = match Session::load_from_path(session_path) {
         Ok(session) => session,
         Err(error) => {
             eprintln!("failed to restore session: {error}");
@@ -614,7 +603,7 @@ fn resume_session(session_path: &Path, commands: &[String]) {
     if commands.is_empty() {
         println!(
             "Restored session from {} ({} messages).",
-            resolved_path.display(),
+            session_path.display(),
             session.messages.len()
         );
         return;
@@ -626,7 +615,7 @@ fn resume_session(session_path: &Path, commands: &[String]) {
             eprintln!("unsupported resumed command: {raw_command}");
             std::process::exit(2);
         };
-        match run_resume_command(&resolved_path, &session, &command) {
+        match run_resume_command(session_path, &session, &command) {
             Ok(ResumeCommandOutcome {
                 session: next_session,
                 message,
@@ -987,8 +976,6 @@ struct ManagedSessionSummary {
     path: PathBuf,
     modified_epoch_secs: u64,
     message_count: usize,
-    parent_session_id: Option<String>,
-    branch_name: Option<String>,
 }
 
 struct LiveCli {
@@ -1008,10 +995,10 @@ impl LiveCli {
         permission_mode: PermissionMode,
     ) -> Result<Self, Box<dyn std::error::Error>> {
         let system_prompt = build_system_prompt()?;
-        let session_state = Session::new();
-        let session = create_managed_session_handle(&session_state.session_id)?;
+        let session = create_managed_session_handle()?;
         let runtime = build_runtime(
-            session_state.with_persistence_path(session.path.clone()),
+            Session::new(),
+            &session.id,
             model.clone(),
             system_prompt.clone(),
             enable_tools,
@@ -1103,6 +1090,7 @@ 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,
@@ -1249,6 +1237,7 @@ impl LiveCli {
         let message_count = session.messages.len();
         self.runtime = build_runtime(
             session,
+            &self.session.id,
             model.clone(),
             self.system_prompt.clone(),
             true,
@@ -1292,6 +1281,7 @@ 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,
@@ -1314,10 +1304,10 @@ impl LiveCli {
             return Ok(false);
         }
 
-        let session_state = Session::new();
-        self.session = create_managed_session_handle(&session_state.session_id)?;
+        self.session = create_managed_session_handle()?;
         self.runtime = build_runtime(
-            session_state.with_persistence_path(self.session.path.clone()),
+            Session::new(),
+            &self.session.id,
             self.model.clone(),
             self.system_prompt.clone(),
             true,
@@ -1351,9 +1341,9 @@ impl LiveCli {
         let handle = resolve_session_reference(&session_ref)?;
         let session = Session::load_from_path(&handle.path)?;
         let message_count = session.messages.len();
-        let session_id = session.session_id.clone();
         self.runtime = build_runtime(
             session,
+            &handle.id,
             self.model.clone(),
             self.system_prompt.clone(),
             true,
@@ -1361,10 +1351,7 @@ impl LiveCli {
             self.allowed_tools.clone(),
             self.permission_mode,
         )?;
-        self.session = SessionHandle {
-            id: session_id,
-            path: handle.path,
-        };
+        self.session = handle;
         println!(
             "{}",
             format_resume_report(
@@ -1427,41 +1414,9 @@ impl LiveCli {
                 let handle = resolve_session_reference(target)?;
                 let session = Session::load_from_path(&handle.path)?;
                 let message_count = session.messages.len();
-                let session_id = session.session_id.clone();
                 self.runtime = build_runtime(
                     session,
-                    self.model.clone(),
-                    self.system_prompt.clone(),
-                    true,
-                    true,
-                    self.allowed_tools.clone(),
-                    self.permission_mode,
-                )?;
-                self.session = SessionHandle {
-                    id: session_id,
-                    path: handle.path,
-                };
-                println!(
-                    "Session switched\n  Active session   {}\n  File             {}\n  Messages         {}",
-                    self.session.id,
-                    self.session.path.display(),
-                    message_count,
-                );
-                Ok(true)
-            }
-            Some("fork") => {
-                let forked = self.runtime.fork_session(target.map(ToOwned::to_owned));
-                let parent_session_id = self.session.id.clone();
-                let handle = create_managed_session_handle(&forked.session_id)?;
-                let branch_name = forked
-                    .fork
-                    .as_ref()
-                    .and_then(|fork| fork.branch_name.clone());
-                let forked = forked.with_persistence_path(handle.path.clone());
-                let message_count = forked.messages.len();
-                forked.save_to_path(&handle.path)?;
-                self.runtime = build_runtime(
-                    forked,
+                    &handle.id,
                     self.model.clone(),
                     self.system_prompt.clone(),
                     true,
@@ -1471,19 +1426,15 @@ impl LiveCli {
                 )?;
                 self.session = handle;
                 println!(
-                    "Session forked\n  Parent session   {}\n  Active session   {}\n  Branch           {}\n  File             {}\n  Messages         {}",
-                    parent_session_id,
+                    "Session switched\n  Active session   {}\n  File             {}\n  Messages         {}",
                     self.session.id,
-                    branch_name.as_deref().unwrap_or("(unnamed)"),
                     self.session.path.display(),
                     message_count,
                 );
                 Ok(true)
             }
             Some(other) => {
-                println!(
-                    "Unknown /session action '{other}'. Use /session list, /session switch <session-id>, or /session fork [branch-name]."
-                );
+                println!("Unknown /session action '{other}'. Use /session list or /session switch <session-id>.");
                 Ok(false)
             }
         }
@@ -1496,6 +1447,7 @@ impl LiveCli {
         let skipped = removed == 0;
         self.runtime = build_runtime(
             result.compacted_session,
+            &self.session.id,
             self.model.clone(),
             self.system_prompt.clone(),
             true,
@@ -1516,61 +1468,44 @@ fn sessions_dir() -> Result<PathBuf, Box<dyn std::error::Error>> {
     Ok(path)
 }
 
-fn create_managed_session_handle(
-    session_id: &str,
-) -> Result<SessionHandle, Box<dyn std::error::Error>> {
-    let id = session_id.to_string();
-    let path = sessions_dir()?.join(format!("{id}.{PRIMARY_SESSION_EXTENSION}"));
+fn create_managed_session_handle() -> Result<SessionHandle, Box<dyn std::error::Error>> {
+    let id = generate_session_id();
+    let path = sessions_dir()?.join(format!("{id}.json"));
     Ok(SessionHandle { id, path })
 }
 
+fn generate_session_id() -> String {
+    let millis = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|duration| duration.as_millis())
+        .unwrap_or_default();
+    format!("session-{millis}")
+}
+
 fn resolve_session_reference(reference: &str) -> Result<SessionHandle, Box<dyn std::error::Error>> {
     let direct = PathBuf::from(reference);
-    let looks_like_path = direct.extension().is_some() || direct.components().count() > 1;
     let path = if direct.exists() {
         direct
-    } else if looks_like_path {
-        return Err(format!("session not found: {reference}").into());
     } else {
-        resolve_managed_session_path(reference)?
+        sessions_dir()?.join(format!("{reference}.json"))
     };
+    if !path.exists() {
+        return Err(format!("session not found: {reference}").into());
+    }
     let id = path
-        .file_name()
+        .file_stem()
         .and_then(|value| value.to_str())
-        .and_then(|name| {
-            name.strip_suffix(&format!(".{PRIMARY_SESSION_EXTENSION}"))
-                .or_else(|| name.strip_suffix(&format!(".{LEGACY_SESSION_EXTENSION}")))
-        })
         .unwrap_or(reference)
         .to_string();
     Ok(SessionHandle { id, path })
 }
 
-fn resolve_managed_session_path(session_id: &str) -> Result<PathBuf, Box<dyn std::error::Error>> {
-    let directory = sessions_dir()?;
-    for extension in [PRIMARY_SESSION_EXTENSION, LEGACY_SESSION_EXTENSION] {
-        let path = directory.join(format!("{session_id}.{extension}"));
-        if path.exists() {
-            return Ok(path);
-        }
-    }
-    Err(format!("session not found: {session_id}").into())
-}
-
-fn is_managed_session_file(path: &Path) -> bool {
-    path.extension()
-        .and_then(|ext| ext.to_str())
-        .is_some_and(|extension| {
-            extension == PRIMARY_SESSION_EXTENSION || extension == LEGACY_SESSION_EXTENSION
-        })
-}
-
 fn list_managed_sessions() -> Result<Vec<ManagedSessionSummary>, Box<dyn std::error::Error>> {
     let mut sessions = Vec::new();
     for entry in fs::read_dir(sessions_dir()?)? {
         let entry = entry?;
         let path = entry.path();
-        if !is_managed_session_file(&path) {
+        if path.extension().and_then(|ext| ext.to_str()) != Some("json") {
             continue;
         }
         let metadata = entry.metadata()?;
@@ -1580,41 +1515,19 @@ fn list_managed_sessions() -> Result<Vec<ManagedSessionSummary>, Box<dyn std::er
             .and_then(|time| time.duration_since(UNIX_EPOCH).ok())
             .map(|duration| duration.as_secs())
             .unwrap_or_default();
-        let (id, message_count, parent_session_id, branch_name) = Session::load_from_path(&path)
-            .map(|session| {
-                let parent_session_id = session
-                    .fork
-                    .as_ref()
-                    .map(|fork| fork.parent_session_id.clone());
-                let branch_name = session
-                    .fork
-                    .as_ref()
-                    .and_then(|fork| fork.branch_name.clone());
-                (
-                    session.session_id,
-                    session.messages.len(),
-                    parent_session_id,
-                    branch_name,
-                )
-            })
-            .unwrap_or_else(|_| {
-                (
-                    path.file_stem()
+        let message_count = Session::load_from_path(&path)
+            .map(|session| session.messages.len())
+            .unwrap_or_default();
+        let id = path
+            .file_stem()
             .and_then(|value| value.to_str())
             .unwrap_or("unknown")
-                        .to_string(),
-                    0,
-                    None,
-                    None,
-                )
-            });
+            .to_string();
         sessions.push(ManagedSessionSummary {
             id,
             path,
             modified_epoch_secs,
             message_count,
-            parent_session_id,
-            branch_name,
         });
     }
     sessions.sort_by(|left, right| right.modified_epoch_secs.cmp(&left.modified_epoch_secs));
@@ -1637,23 +1550,11 @@ fn render_session_list(active_session_id: &str) -> Result<String, Box<dyn std::e
         } else {
             "○ saved"
         };
-        let lineage = match (
-            session.branch_name.as_deref(),
-            session.parent_session_id.as_deref(),
-        ) {
-            (Some(branch_name), Some(parent_session_id)) => {
-                format!(" branch={branch_name} from={parent_session_id}")
-            }
-            (None, Some(parent_session_id)) => format!(" from={parent_session_id}"),
-            (Some(branch_name), None) => format!(" branch={branch_name}"),
-            (None, None) => String::new(),
-        };
         lines.push(format!(
-            "  {id:<20} {marker:<10} msgs={msgs:<4} modified={modified}{lineage} path={path}",
+            "  {id:<20} {marker:<10} msgs={msgs:<4} modified={modified} path={path}",
             id = session.id,
             msgs = session.message_count,
             modified = session.modified_epoch_secs,
-            lineage = lineage,
             path = session.path.display(),
         ));
     }
@@ -2022,8 +1923,10 @@ fn build_runtime_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,
@@ -2032,14 +1935,41 @@ fn build_runtime(
     permission_mode: PermissionMode,
 ) -> Result<ConversationRuntime<AnthropicRuntimeClient, CliToolExecutor>, Box<dyn std::error::Error>>
 {
-    Ok(ConversationRuntime::new_with_features(
+    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(
         session,
-        AnthropicRuntimeClient::new(model, enable_tools, emit_output, allowed_tools.clone())?,
+        api_client,
         CliToolExecutor::new(allowed_tools, emit_output),
         permission_policy(permission_mode),
         system_prompt,
-        build_runtime_feature_config()?,
-    ))
+        &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 {
@@ -2114,6 +2044,11 @@ 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>> {
@@ -2219,12 +2154,7 @@ impl ApiClient for AnthropicRuntimeClient {
                         }
                     }
                     ApiStreamEvent::MessageDelta(delta) => {
-                        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,
-                        }));
+                        events.push(AssistantEvent::Usage(delta.usage.token_usage()));
                     }
                     ApiStreamEvent::MessageStop(_) => {
                         saw_stop = true;
@@ -2474,13 +2404,13 @@ fn format_bash_result(icon: &str, parsed: &serde_json::Value) -> String {
         .get("backgroundTaskId")
         .and_then(|value| value.as_str())
     {
-        lines[0].push_str(&format!(" backgrounded ({task_id})"));
+        write!(&mut lines[0], " backgrounded ({task_id})").expect("write to string");
     } else if let Some(status) = parsed
         .get("returnCodeInterpretation")
         .and_then(|value| value.as_str())
         .filter(|status| !status.is_empty())
     {
-        lines[0].push_str(&format!(" {status}"));
+        write!(&mut lines[0], " {status}").expect("write to string");
     }
 
     if let Some(stdout) = parsed.get("stdout").and_then(|value| value.as_str()) {
@@ -2502,15 +2432,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(|value| value.as_u64())
+        .and_then(serde_json::Value::as_u64)
         .unwrap_or(1);
     let num_lines = file
         .get("numLines")
-        .and_then(|value| value.as_u64())
+        .and_then(serde_json::Value::as_u64)
         .unwrap_or(0);
     let total_lines = file
         .get("totalLines")
-        .and_then(|value| value.as_u64())
+        .and_then(serde_json::Value::as_u64)
         .unwrap_or(num_lines);
     let content = file
         .get("content")
@@ -2536,8 +2466,7 @@ fn format_write_result(icon: &str, parsed: &serde_json::Value) -> String {
     let line_count = parsed
         .get("content")
         .and_then(|value| value.as_str())
-        .map(|content| content.lines().count())
-        .unwrap_or(0);
+        .map_or(0, |content| content.lines().count());
     format!(
         "{icon} \x1b[1;32m✏️ {} {path}\x1b[0m \x1b[2m({line_count} lines)\x1b[0m",
         if kind == "create" { "Wrote" } else { "Updated" },
@@ -2568,7 +2497,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(|value| value.as_bool())
+        .and_then(serde_json::Value::as_bool)
         .unwrap_or(false)
     {
         " (replace all)"
@@ -2596,7 +2525,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(|value| value.as_u64())
+        .and_then(serde_json::Value::as_u64)
         .unwrap_or(0);
     let filenames = parsed
         .get("filenames")
@@ -2620,11 +2549,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(|value| value.as_u64())
+        .and_then(serde_json::Value::as_u64)
         .unwrap_or(0);
     let num_files = parsed
         .get("numFiles")
-        .and_then(|value| value.as_u64())
+        .and_then(serde_json::Value::as_u64)
         .unwrap_or(0);
     let content = parsed
         .get("content")
@@ -2721,12 +2650,7 @@ fn response_to_events(
         }
     }
 
-    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::Usage(response.usage.token_usage()));
     events.push(AssistantEvent::MessageStop);
     Ok(events)
 }
@@ -2857,7 +2781,7 @@ fn print_help_to(out: &mut impl Write) -> io::Result<()> {
     writeln!(out, "      Shorthand non-interactive prompt mode")?;
     writeln!(
         out,
-        "  claw --resume SESSION.jsonl [/status] [/compact] [...]"
+        "  claw --resume SESSION.json [/status] [/compact] [...]"
     )?;
     writeln!(
         out,
@@ -2917,7 +2841,7 @@ fn print_help_to(out: &mut impl Write) -> io::Result<()> {
     )?;
     writeln!(
         out,
-        "  claw --resume session.jsonl /status /diff /export notes.txt"
+        "  claw --resume session.json /status /diff /export notes.txt"
     )?;
     writeln!(out, "  claw login")?;
     writeln!(out, "  claw init")?;
@@ -2931,23 +2855,18 @@ fn print_help() {
 #[cfg(test)]
 mod tests {
     use super::{
-        create_managed_session_handle, filter_tool_specs, format_compact_report,
-        format_cost_report, format_model_report, format_model_switch_report,
-        format_permissions_report, format_permissions_switch_report, format_resume_report,
-        format_status_report, format_tool_call_start, format_tool_result,
+        filter_tool_specs, format_compact_report, format_cost_report, format_model_report,
+        format_model_switch_report, format_permissions_report, format_permissions_switch_report,
+        format_resume_report, format_status_report, format_tool_call_start, format_tool_result,
         normalize_permission_mode, parse_args, parse_git_status_metadata, print_help_to,
         push_output_block, render_config_report, render_memory_report, render_repl_help,
-        resolve_model_alias, resolve_session_reference, response_to_events,
-        resume_supported_slash_commands, status_context, CliAction, CliOutputFormat, SlashCommand,
-        StatusUsage, DEFAULT_MODEL,
+        resolve_model_alias, response_to_events, resume_supported_slash_commands, status_context,
+        CliAction, CliOutputFormat, SlashCommand, StatusUsage, DEFAULT_MODEL,
     };
     use api::{MessageResponse, OutputContentBlock, Usage};
-    use runtime::{
-        AssistantEvent, ContentBlock, ConversationMessage, MessageRole, PermissionMode, Session,
-    };
+    use runtime::{AssistantEvent, ContentBlock, ConversationMessage, MessageRole, PermissionMode};
     use serde_json::json;
     use std::path::PathBuf;
-    use std::sync::{Mutex, OnceLock};
 
     #[test]
     fn defaults_to_repl_when_no_args() {
@@ -3121,13 +3040,13 @@ mod tests {
     fn parses_resume_flag_with_slash_command() {
         let args = vec![
             "--resume".to_string(),
-            "session.jsonl".to_string(),
+            "session.json".to_string(),
             "/compact".to_string(),
         ];
         assert_eq!(
             parse_args(&args).expect("args should parse"),
             CliAction::ResumeSession {
-                session_path: PathBuf::from("session.jsonl"),
+                session_path: PathBuf::from("session.json"),
                 commands: vec!["/compact".to_string()],
             }
         );
@@ -3137,7 +3056,7 @@ mod tests {
     fn parses_resume_flag_with_multiple_slash_commands() {
         let args = vec![
             "--resume".to_string(),
-            "session.jsonl".to_string(),
+            "session.json".to_string(),
             "/status".to_string(),
             "/compact".to_string(),
             "/cost".to_string(),
@@ -3145,7 +3064,7 @@ mod tests {
         assert_eq!(
             parse_args(&args).expect("args should parse"),
             CliAction::ResumeSession {
-                session_path: PathBuf::from("session.jsonl"),
+                session_path: PathBuf::from("session.json"),
                 commands: vec![
                     "/status".to_string(),
                     "/compact".to_string(),
@@ -3173,7 +3092,7 @@ mod tests {
     fn shared_help_uses_resume_annotation_copy() {
         let help = commands::render_slash_command_help();
         assert!(help.contains("Slash commands"));
-        assert!(help.contains("works with --resume SESSION.jsonl"));
+        assert!(help.contains("works with --resume SESSION.json"));
     }
 
     #[test]
@@ -3193,7 +3112,7 @@ mod tests {
         assert!(help.contains("/diff"));
         assert!(help.contains("/version"));
         assert!(help.contains("/export [file]"));
-        assert!(help.contains("/session [list|switch <session-id>|fork [branch-name]]"));
+        assert!(help.contains("/session [list|switch <session-id>]"));
         assert!(help.contains("/exit"));
     }
 
@@ -3214,9 +3133,9 @@ mod tests {
 
     #[test]
     fn resume_report_uses_sectioned_layout() {
-        let report = format_resume_report("session.jsonl", 14, 6);
+        let report = format_resume_report("session.json", 14, 6);
         assert!(report.contains("Session resumed"));
-        assert!(report.contains("Session file     session.jsonl"));
+        assert!(report.contains("Session file     session.json"));
         assert!(report.contains("Messages         14"));
         assert!(report.contains("Turns            6"));
     }
@@ -3318,7 +3237,7 @@ mod tests {
             "workspace-write",
             &super::StatusContext {
                 cwd: PathBuf::from("/tmp/project"),
-                session_path: Some(PathBuf::from("session.jsonl")),
+                session_path: Some(PathBuf::from("session.json")),
                 loaded_config_files: 2,
                 discovered_config_files: 3,
                 memory_file_count: 4,
@@ -3335,7 +3254,7 @@ mod tests {
         assert!(status.contains("Cwd              /tmp/project"));
         assert!(status.contains("Project root     /tmp"));
         assert!(status.contains("Git branch       main"));
-        assert!(status.contains("Session          session.jsonl"));
+        assert!(status.contains("Session          session.json"));
         assert!(status.contains("Config files     loaded 2/3"));
         assert!(status.contains("Memory files     4"));
     }
@@ -3410,9 +3329,9 @@ mod tests {
     #[test]
     fn parses_resume_and_config_slash_commands() {
         assert_eq!(
-            SlashCommand::parse("/resume saved-session.jsonl"),
+            SlashCommand::parse("/resume saved-session.json"),
             Some(SlashCommand::Resume {
-                session_path: Some("saved-session.jsonl".to_string())
+                session_path: Some("saved-session.json".to_string())
             })
         );
         assert_eq!(
@@ -3431,65 +3350,6 @@ mod tests {
         );
         assert_eq!(SlashCommand::parse("/memory"), Some(SlashCommand::Memory));
         assert_eq!(SlashCommand::parse("/init"), Some(SlashCommand::Init));
-        assert_eq!(
-            SlashCommand::parse("/session fork incident-review"),
-            Some(SlashCommand::Session {
-                action: Some("fork".to_string()),
-                target: Some("incident-review".to_string())
-            })
-        );
-    }
-
-    #[test]
-    fn help_mentions_jsonl_resume_examples() {
-        let mut help = Vec::new();
-        print_help_to(&mut help).expect("help should render");
-        let help = String::from_utf8(help).expect("help should be utf8");
-        assert!(help.contains("claw --resume SESSION.jsonl"));
-        assert!(help.contains("claw --resume session.jsonl /status /diff /export notes.txt"));
-    }
-
-    #[test]
-    fn managed_sessions_default_to_jsonl_and_resolve_legacy_json() {
-        let _guard = cwd_lock().lock().expect("cwd lock");
-        let workspace = temp_workspace("session-resolution");
-        std::fs::create_dir_all(&workspace).expect("workspace should create");
-        let previous = std::env::current_dir().expect("cwd");
-        std::env::set_current_dir(&workspace).expect("switch cwd");
-
-        let handle = create_managed_session_handle("session-alpha").expect("jsonl handle");
-        assert!(handle.path.ends_with("session-alpha.jsonl"));
-
-        let legacy_path = workspace.join(".claude/sessions/legacy.json");
-        std::fs::create_dir_all(
-            legacy_path
-                .parent()
-                .expect("legacy path should have parent directory"),
-        )
-        .expect("session dir should exist");
-        Session::new()
-            .with_persistence_path(legacy_path.clone())
-            .save_to_path(&legacy_path)
-            .expect("legacy session should save");
-
-        let resolved = resolve_session_reference("legacy").expect("legacy session should resolve");
-        assert_eq!(resolved.path, legacy_path);
-
-        std::env::set_current_dir(previous).expect("restore cwd");
-        std::fs::remove_dir_all(workspace).expect("workspace should clean up");
-    }
-
-    fn cwd_lock() -> &'static Mutex<()> {
-        static LOCK: OnceLock<Mutex<()>> = OnceLock::new();
-        LOCK.get_or_init(|| Mutex::new(()))
-    }
-
-    fn temp_workspace(label: &str) -> PathBuf {
-        let nanos = std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)
-            .expect("system time should be after epoch")
-            .as_nanos();
-        std::env::temp_dir().join(format!("claw-cli-{label}-{nanos}"))
     }
 
     #[test]

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(&self, state: &mut RenderState, level: u8, output: &mut String) {
+    fn start_heading(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

@@ -0,0 +1,13 @@
+[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

@@ -0,0 +1,526 @@
+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, TokenUsage, ToolError, ToolExecutor,
+    RuntimeError, Session, ToolError, ToolExecutor,
 };
 use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
@@ -1723,12 +1723,7 @@ impl ApiClient for AnthropicRuntimeClient {
                         }
                     }
                     ApiStreamEvent::MessageDelta(delta) => {
-                        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,
-                        }));
+                        events.push(AssistantEvent::Usage(delta.usage.token_usage()));
                     }
                     ApiStreamEvent::MessageStop(_) => {
                         saw_stop = true;
@@ -1874,12 +1869,7 @@ fn response_to_events(response: MessageResponse) -> Vec<AssistantEvent> {
         }
     }
 
-    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::Usage(response.usage.token_usage()));
     events.push(AssistantEvent::MessageStop);
     events
 }