An agent-managed museum exhibit, built in Rust with Gajae-Code / LazyCodex — developed and maintained with no human intervention.
Rust
Revert "Merge pull request #3318 from ultraworkers/pr-3292"
clawdbotf021597942f9
diff --git a/rust/crates/api/src/error.rs b/rust/crates/api/src/error.rsindex d4dc0daa..e8ec73a4 100644--- a/rust/crates/api/src/error.rs+++ b/rust/crates/api/src/error.rs@@ -52,13 +52,19 @@ pub enum ApiError {body_snippet: String,source: serde_json::Error,},- /// A provider returned an error response.- ///- /// Boxed: the payload is ~139 bytes, and `ApiError` is the `Err` half of nearly every- /// `Result` in this crate, so inlining it inflates the size of every one of those returns- /// (clippy::result_large_err). Boxing keeps `ApiError` small and means adding a field here- /// cannot silently re-inflate every signature in the crate.- Api(Box<ApiErrorDetails>),+ Api {+ status: reqwest::StatusCode,+ error_type: Option<String>,+ message: Option<String>,+ request_id: Option<String>,+ body: String,+ retryable: bool,+ /// Suggested user action based on error type (e.g., "Reduce prompt size" for 413)+ suggested_action: Option<String>,+ /// Parsed Retry-After header value (seconds) for 429 responses.+ /// When present, overrides the exponential backoff delay.+ retry_after: Option<Duration>,+ },RetriesExhausted {attempts: u32,last_error: Box<ApiError>,@@ -75,38 +81,7 @@ pub enum ApiError {},}-/// Payload of [`ApiError::Api`], held behind a `Box` so the enum stays small.-#[derive(Debug)]-pub struct ApiErrorDetails {- pub status: reqwest::StatusCode,- pub error_type: Option<String>,- pub message: Option<String>,- pub request_id: Option<String>,- pub body: String,- pub retryable: bool,- /// Suggested user action based on error type (e.g., "Reduce prompt size" for 413)- pub suggested_action: Option<String>,- /// Parsed Retry-After header value (seconds) for 429 responses.- /// When present, overrides the exponential backoff delay.- pub retry_after: Option<Duration>,-}-impl ApiError {- /// Convenience constructor so callers do not have to spell out the `Box` at every site.- #[must_use]- pub fn api(details: ApiErrorDetails) -> Self {- Self::Api(Box::new(details))- }-- /// Borrow the provider-error payload, if this is one.- #[must_use]- pub fn api_details(&self) -> Option<&ApiErrorDetails> {- match self {- Self::Api(details) => Some(details),- _ => None,- }- }-#[must_use]pub const fn missing_credentials(provider: &'static str,@@ -162,7 +137,7 @@ impl ApiError {/// over the computed backoff delay when it exists.pub fn retry_after(&self) -> Option<Duration> {match self {- Self::Api(details) => details.retry_after,+ Self::Api { retry_after, .. } => *retry_after,Self::RetriesExhausted { last_error, .. } => last_error.retry_after(),_ => None,}@@ -171,7 +146,7 @@ impl ApiError {pub fn is_retryable(&self) -> bool {match self {Self::Http(error) => error.is_connect() || error.is_timeout() || error.is_request(),- Self::Api(details) => details.retryable,+ Self::Api { retryable, .. } => *retryable,Self::RetriesExhausted { last_error, .. } => last_error.is_retryable(),Self::MissingCredentials { .. }| Self::ContextWindowExceeded { .. }@@ -189,7 +164,7 @@ impl ApiError {#[must_use]pub fn request_id(&self) -> Option<&str> {match self {- Self::Api(details) => details.request_id.as_deref(),+ Self::Api { request_id, .. } => request_id.as_deref(),Self::RetriesExhausted { last_error, .. } => last_error.request_id(),Self::MissingCredentials { .. }| Self::ContextWindowExceeded { .. }@@ -216,12 +191,12 @@ impl ApiError {Self::MissingCredentials { .. } | Self::ExpiredOAuthToken | Self::Auth(_) => {"provider_auth"}- Self::Api(details) if matches!(details.status.as_u16(), 401 | 403) => "provider_auth",+ Self::Api { status, .. } if matches!(status.as_u16(), 401 | 403) => "provider_auth",Self::ContextWindowExceeded { .. } => "context_window",- Self::Api(_) if self.is_context_window_failure() => "context_window",- Self::Api(details) if details.status.as_u16() == 429 => "provider_rate_limit",- Self::Api(_) if self.is_generic_fatal_wrapper() => "provider_internal",- Self::Api(_) => "provider_error",+ Self::Api { .. } if self.is_context_window_failure() => "context_window",+ Self::Api { status, .. } if status.as_u16() == 429 => "provider_rate_limit",+ Self::Api { .. } if self.is_generic_fatal_wrapper() => "provider_internal",+ Self::Api { .. } => "provider_error",Self::Http(_) | Self::InvalidSseFrame(_) | Self::BackoffOverflow { .. } => {"provider_transport"}@@ -233,12 +208,11 @@ impl ApiError {#[must_use]pub fn is_generic_fatal_wrapper(&self) -> bool {match self {- Self::Api(details) => {- details- .message+ Self::Api { message, body, .. } => {+ message.as_deref().is_some_and(looks_like_generic_fatal_wrapper)- || looks_like_generic_fatal_wrapper(&details.body)+ || looks_like_generic_fatal_wrapper(body)}Self::RetriesExhausted { last_error, .. } => last_error.is_generic_fatal_wrapper(),Self::MissingCredentials { .. }@@ -255,36 +229,21 @@ impl ApiError {}}- /// True for failures whose own text cannot say what went wrong: transport, decode, and frame- /// errors.- ///- /// These matter because a server that answers an oversized request with a non-SSE HTTP 500- /// body lands here rather than in [`Self::is_context_window_failure`] — reqwest reports- /// "error decoding response body" and the real cause is lost. Callers that know how large the- /// request was can combine the two signals; callers that do not must treat this as unknown,- /// never as an overflow.- #[must_use]- pub fn is_ambiguous_transport_failure(&self) -> bool {- match self {- Self::Http(_) | Self::Json { .. } | Self::InvalidSseFrame(_) => true,- Self::RetriesExhausted { last_error, .. } => {- last_error.is_ambiguous_transport_failure()- }- _ => false,- }- }-#[must_use]pub fn is_context_window_failure(&self) -> bool {match self {Self::ContextWindowExceeded { .. } => true,- Self::Api(details) => {- matches!(details.status.as_u16(), 400 | 413 | 422)- && (details- .message+ Self::Api {+ status,+ message,+ body,+ ..+ } => {+ matches!(status.as_u16(), 400 | 413 | 422)+ && (message.as_deref().is_some_and(looks_like_context_window_error)- || looks_like_context_window_error(&details.body))+ || looks_like_context_window_error(body))}Self::RetriesExhausted { last_error, .. } => last_error.is_context_window_failure(),Self::MissingCredentials { .. }@@ -368,14 +327,14 @@ impl Display for ApiError {"failed to parse {provider} response for model {model}: {source}; first 200 chars of body: {body_snippet}"),// #28: enhance 401/403 errors with actionable auth guidance- Self::Api(details) if matches!(details.status.as_u16(), 401 | 403) => {- let (status, error_type, message, request_id, body) = (- &details.status,- &details.error_type,- &details.message,- &details.request_id,- &details.body,- );+ Self::Api {+ status,+ error_type,+ message,+ request_id,+ body,+ ..+ } if matches!(status.as_u16(), 401 | 403) => {if let (Some(error_type), Some(message)) = (error_type, message) {write!(f, "api returned {status} ({error_type})")?;if let Some(request_id) = request_id {@@ -397,14 +356,14 @@ impl Display for ApiError {Run `claw doctor` to verify your credential configuration.")}- Self::Api(details) => {- let (status, error_type, message, request_id, body) = (- &details.status,- &details.error_type,- &details.message,- &details.request_id,- &details.body,- );+ Self::Api {+ status,+ error_type,+ message,+ request_id,+ body,+ ..+ } => {if let (Some(error_type), Some(message)) = (error_type, message) {write!(f, "api returned {status} ({error_type})")?;if let Some(request_id) = request_id {@@ -510,7 +469,6 @@ fn truncate_body_snippet(body: &str, max_chars: usize) -> String {#[cfg(test)]mod tests {- use super::ApiErrorDetails;use super::{truncate_body_snippet, ApiError};#[test]@@ -575,7 +533,7 @@ mod tests {#[test]fn detects_generic_fatal_wrapper_and_classifies_it_as_provider_internal() {- let error = ApiError::Api(Box::new(ApiErrorDetails {+ let error = ApiError::Api {status: reqwest::StatusCode::INTERNAL_SERVER_ERROR,error_type: Some("api_error".to_string()),message: Some(@@ -587,7 +545,7 @@ mod tests {retryable: true,suggested_action: None,retry_after: None,- }));+ };assert!(error.is_generic_fatal_wrapper());assert_eq!(error.safe_failure_class(), "provider_internal");@@ -599,7 +557,7 @@ mod tests {fn retries_exhausted_preserves_nested_request_id_and_failure_class() {let error = ApiError::RetriesExhausted {attempts: 3,- last_error: Box::new(ApiError::Api(Box::new(ApiErrorDetails {+ last_error: Box::new(ApiError::Api {status: reqwest::StatusCode::BAD_GATEWAY,error_type: Some("api_error".to_string()),message: Some(@@ -611,7 +569,7 @@ mod tests {retryable: true,suggested_action: None,retry_after: None,- }))),+ }),};assert!(error.is_generic_fatal_wrapper());@@ -621,7 +579,7 @@ mod tests {#[test]fn classifies_provider_context_window_errors() {- let error = ApiError::Api(Box::new(ApiErrorDetails {+ let error = ApiError::Api {status: reqwest::StatusCode::BAD_REQUEST,error_type: Some("invalid_request_error".to_string()),message: Some(@@ -633,7 +591,7 @@ mod tests {retryable: false,suggested_action: None,retry_after: None,- }));+ };assert!(error.is_context_window_failure());assert_eq!(error.safe_failure_class(), "context_window");@@ -642,7 +600,7 @@ mod tests {#[test]fn classifies_openai_configured_limit_errors_as_context_window_failures() {- let error = ApiError::Api(Box::new(ApiErrorDetails {+ let error = ApiError::Api {status: reqwest::StatusCode::BAD_REQUEST,error_type: Some("invalid_request_error".to_string()),message: Some(@@ -654,7 +612,7 @@ mod tests {retryable: false,suggested_action: None,retry_after: None,- }));+ };assert!(error.is_context_window_failure());assert_eq!(error.safe_failure_class(), "context_window");diff --git a/rust/crates/api/src/lib.rs b/rust/crates/api/src/lib.rsindex a4774f5a..e03d78ee 100644--- a/rust/crates/api/src/lib.rs+++ b/rust/crates/api/src/lib.rs@@ -12,7 +12,7 @@ pub use client::{resolve_startup_auth_source, MessageStream, OAuthTokenSet, ProviderClient, ProviderConfig,ProviderConfigKind,};-pub use error::{ApiError, ApiErrorDetails};+pub use error::ApiError;pub use http_client::{build_http_client, build_http_client_or_default, build_http_client_with,build_http_client_with_opts, ProxyConfig, TimeoutConfig,@@ -29,10 +29,9 @@ pub use providers::openai_compat::{OpenAiCompatClient, OpenAiCompatConfig,};pub use providers::{- context_window_override, detect_provider_kind, estimate_message_request_input_tokens,- max_tokens_for_model, max_tokens_for_model_with_override, model_family_identity_for,- model_family_identity_for_kind, model_token_limit, provider_diagnostics_for_model,- resolve_model_alias, ModelTokenLimit, ProviderDiagnostics, ProviderKind,+ detect_provider_kind, max_tokens_for_model, max_tokens_for_model_with_override,+ model_family_identity_for, model_family_identity_for_kind, provider_diagnostics_for_model,+ resolve_model_alias, ProviderDiagnostics, ProviderKind,};pub use sse::{parse_frame, SseParser};pub use types::{diff --git a/rust/crates/api/src/providers/anthropic.rs b/rust/crates/api/src/providers/anthropic.rsindex be6eb3a4..430b3eff 100644--- a/rust/crates/api/src/providers/anthropic.rs+++ b/rust/crates/api/src/providers/anthropic.rs@@ -12,7 +12,7 @@ use serde::Deserialize;use serde_json::{Map, Value};use telemetry::{AnalyticsEvent, AnthropicRequestProfile, ClientIdentity, SessionTracer};-use crate::error::{ApiError, ApiErrorDetails};+use crate::error::ApiError;use crate::http_client::build_http_client_or_default;use crate::prompt_cache::{PromptCache, PromptCacheRecord, PromptCacheStats};@@ -892,7 +892,7 @@ async fn expect_success(response: reqwest::Response) -> Result<reqwest::Responselet retryable = is_retryable_status(status);let retry_after = parse_retry_after(&headers, status);- Err(ApiError::Api(Box::new(ApiErrorDetails {+ Err(ApiError::Api {status,error_type: parsed_error.as_ref()@@ -905,7 +905,7 @@ async fn expect_success(response: reqwest::Response) -> Result<reqwest::Responseretryable,suggested_action: None,retry_after,- })))+ })}fn parse_retry_after(@@ -952,30 +952,86 @@ fn is_retryable_400(status: reqwest::StatusCode, body: &str) -> bool {const SK_ANT_BEARER_HINT: &str = "sk-ant-* keys go in ANTHROPIC_API_KEY (x-api-key header), not ANTHROPIC_AUTH_TOKEN (Bearer header). Move your key to ANTHROPIC_API_KEY.";fn enrich_bearer_auth_error(error: ApiError, auth: &AuthSource) -> ApiError {- let ApiError::Api(mut details) = error else {+ let ApiError::Api {+ status,+ error_type,+ message,+ request_id,+ body,+ retryable,+ suggested_action,+ retry_after,+ ..+ } = error+ else {return error;};- if details.status.as_u16() != 401 {- return ApiError::Api(details);+ if status.as_u16() != 401 {+ return ApiError::Api {+ status,+ error_type,+ message,+ request_id,+ body,+ retryable,+ suggested_action,+ retry_after,+ };}let Some(bearer_token) = auth.bearer_token() else {- return ApiError::Api(details);+ return ApiError::Api {+ status,+ error_type,+ message,+ request_id,+ body,+ retryable,+ suggested_action,+ retry_after,+ };};if !bearer_token.starts_with("sk-ant-") {- return ApiError::Api(details);+ return ApiError::Api {+ status,+ error_type,+ message,+ request_id,+ body,+ retryable,+ suggested_action,+ retry_after,+ };}// Only append the hint when the AuthSource is pure BearerToken. If both// api_key and bearer_token are present (`ApiKeyAndBearer`), the x-api-key// header is already being sent alongside the Bearer header and the 401// is coming from a different cause — adding the hint would be misleading.if auth.api_key().is_some() {- return ApiError::Api(details);+ return ApiError::Api {+ status,+ error_type,+ message,+ request_id,+ body,+ retryable,+ suggested_action,+ retry_after,+ };+ }+ let enriched_message = match message {+ Some(existing) => Some(format!("{existing} — hint: {SK_ANT_BEARER_HINT}")),+ None => Some(format!("hint: {SK_ANT_BEARER_HINT}")),+ };+ ApiError::Api {+ status,+ error_type,+ message: enriched_message,+ request_id,+ body,+ retryable,+ suggested_action,+ retry_after,}- details.message = Some(match details.message.take() {- Some(existing) => format!("{existing} — hint: {SK_ANT_BEARER_HINT}"),- None => format!("hint: {SK_ANT_BEARER_HINT}"),- });- ApiError::Api(details)}fn anthropic_wire_model(model: &str) -> &str {@@ -1027,7 +1083,6 @@ struct AnthropicErrorBody {#[cfg(test)]mod tests {use super::{ALT_REQUEST_ID_HEADER, REQUEST_ID_HEADER};- use crate::error::ApiErrorDetails;use std::io::{Read, Write};use std::net::TcpListener;use std::sync::{Mutex, OnceLock};@@ -1592,7 +1647,7 @@ mod tests {fn enrich_bearer_auth_error_appends_sk_ant_hint_on_401_with_pure_bearer_token() {// givenlet auth = AuthSource::BearerToken("sk-ant-api03-deadbeef".to_string());- let error = crate::error::ApiError::Api(Box::new(ApiErrorDetails {+ let error = crate::error::ApiError::Api {status: reqwest::StatusCode::UNAUTHORIZED,error_type: Some("authentication_error".to_string()),message: Some("Invalid bearer token".to_string()),@@ -1601,7 +1656,7 @@ mod tests {retryable: false,suggested_action: None,retry_after: None,- }));+ };// whenlet enriched = super::enrich_bearer_auth_error(error, &auth);@@ -1623,8 +1678,8 @@ mod tests {"request id should still flow through the enriched error: {rendered}");match enriched {- crate::error::ApiError::Api(details) => {- assert_eq!(details.status, reqwest::StatusCode::UNAUTHORIZED);+ crate::error::ApiError::Api { status, .. } => {+ assert_eq!(status, reqwest::StatusCode::UNAUTHORIZED);}other => panic!("expected Api variant, got {other:?}"),}@@ -1634,7 +1689,7 @@ mod tests {fn enrich_bearer_auth_error_leaves_non_401_errors_unchanged() {// givenlet auth = AuthSource::BearerToken("sk-ant-api03-deadbeef".to_string());- let error = crate::error::ApiError::Api(Box::new(ApiErrorDetails {+ let error = crate::error::ApiError::Api {status: reqwest::StatusCode::INTERNAL_SERVER_ERROR,error_type: Some("api_error".to_string()),message: Some("internal server error".to_string()),@@ -1643,7 +1698,7 @@ mod tests {retryable: true,suggested_action: None,retry_after: None,- }));+ };// whenlet enriched = super::enrich_bearer_auth_error(error, &auth);@@ -1664,7 +1719,7 @@ mod tests {fn enrich_bearer_auth_error_ignores_401_when_bearer_token_is_not_sk_ant() {// givenlet auth = AuthSource::BearerToken("oauth-access-token-opaque".to_string());- let error = crate::error::ApiError::Api(Box::new(ApiErrorDetails {+ let error = crate::error::ApiError::Api {status: reqwest::StatusCode::UNAUTHORIZED,error_type: Some("authentication_error".to_string()),message: Some("Invalid bearer token".to_string()),@@ -1673,7 +1728,7 @@ mod tests {retryable: false,suggested_action: None,retry_after: None,- }));+ };// whenlet enriched = super::enrich_bearer_auth_error(error, &auth);@@ -1693,7 +1748,7 @@ mod tests {api_key: "sk-ant-api03-legitimate".to_string(),bearer_token: "sk-ant-api03-deadbeef".to_string(),};- let error = crate::error::ApiError::Api(Box::new(ApiErrorDetails {+ let error = crate::error::ApiError::Api {status: reqwest::StatusCode::UNAUTHORIZED,error_type: Some("authentication_error".to_string()),message: Some("Invalid bearer token".to_string()),@@ -1702,7 +1757,7 @@ mod tests {retryable: false,suggested_action: None,retry_after: None,- }));+ };// whenlet enriched = super::enrich_bearer_auth_error(error, &auth);@@ -1719,7 +1774,7 @@ mod tests {fn enrich_bearer_auth_error_ignores_401_when_auth_source_has_no_bearer() {// givenlet auth = AuthSource::ApiKey("sk-ant-api03-legitimate".to_string());- let error = crate::error::ApiError::Api(Box::new(ApiErrorDetails {+ let error = crate::error::ApiError::Api {status: reqwest::StatusCode::UNAUTHORIZED,error_type: Some("authentication_error".to_string()),message: Some("Invalid x-api-key".to_string()),@@ -1728,7 +1783,7 @@ mod tests {retryable: false,suggested_action: None,retry_after: None,- }));+ };// whenlet enriched = super::enrich_bearer_auth_error(error, &auth);diff --git a/rust/crates/api/src/providers/mod.rs b/rust/crates/api/src/providers/mod.rsindex 9c567a06..993a4e7d 100644--- a/rust/crates/api/src/providers/mod.rs+++ b/rust/crates/api/src/providers/mod.rs@@ -619,43 +619,16 @@ fn web_passthrough_diagnostic(}}-/// Overrides the context window every sizing guard is computed against.-///-/// The model *name* is not a reliable statement of the window when the endpoint is a local-/// server: the harness sends its compiled-in default name (a Claude alias) while the backend-/// serves whatever `-c` it was started with. Every guard downstream of [`model_token_limit`]-/// then sizes itself against the name's window instead of the real one, which makes the-/// preflights unable to fire rather than merely inaccurate. This variable is the operator's-/// statement of the truth, and it wins over the table.-const CONTEXT_WINDOW_ENV_VAR: &str = "CLAW_CONTEXT_WINDOW";--/// Fraction of the window a single response may be allowed to claim when the window is-/// declared. Output and input share one budget on a local server, so reserving a quarter for-/// the reply leaves three quarters for prompt plus transcript.-const MAX_OUTPUT_SHARE_OF_WINDOW: u32 = 4;--/// The operator-declared context window, when set and parseable as a positive token count.-#[must_use]-pub fn context_window_override() -> Option<u32> {- parse_context_window_override(std::env::var(CONTEXT_WINDOW_ENV_VAR).ok().as_deref())-}--#[must_use]-fn parse_context_window_override(value: Option<&str>) -> Option<u32> {- value- .and_then(|raw| raw.trim().parse::<u32>().ok())- .filter(|window| *window > 0)-}-#[must_use]pub fn max_tokens_for_model(model: &str) -> u32 {- // A declared window caps the reply too. Asking a 65k server for 32k of output reserves half- // the window for a single message, which the server then silently clamps — leaving the- // client's own accounting wrong by the difference.- model_token_limit(model).map_or_else(- || max_tokens_for_model_by_name(model),- |limit| max_tokens_for_model_by_name(model).min(limit.max_output_tokens),- )+ let canonical = resolve_model_alias(model);+ let heuristic = if canonical.contains("opus") {+ 32_000+ } else {+ 64_000+ };++ model_token_limit(model).map_or(heuristic, |limit| heuristic.min(limit.max_output_tokens))}/// Returns the effective max output tokens for a model, preferring a plugin@@ -668,33 +641,6 @@ pub fn max_tokens_for_model_with_override(model: &str, plugin_override: Option<u#[must_use]pub fn model_token_limit(model: &str) -> Option<ModelTokenLimit> {- // A declared window replaces the table's, and supplies one for models the table has never- // heard of. Returning `Some` for an unknown model is the point: `None` makes both preflights- // return `Ok` without looking at anything, so an unrecognised local model gets no guard at all.- if let Some(context_window_tokens) = context_window_override() {- return Some(ModelTokenLimit {- max_output_tokens: max_tokens_for_model_by_name(model)- .min(context_window_tokens / MAX_OUTPUT_SHARE_OF_WINDOW),- context_window_tokens,- });- }- model_token_limit_by_name(model)-}--#[must_use]-fn max_tokens_for_model_by_name(model: &str) -> u32 {- let canonical = resolve_model_alias(model);- let heuristic = if canonical.contains("opus") {- 32_000- } else {- 64_000- };- model_token_limit_by_name(model)- .map_or(heuristic, |limit| heuristic.min(limit.max_output_tokens))-}--#[must_use]-fn model_token_limit_by_name(model: &str) -> Option<ModelTokenLimit> {let canonical = resolve_model_alias(model);let base_model = canonical.rsplit('/').next().unwrap_or(canonical.as_str());match base_model {@@ -777,7 +723,7 @@ pub fn preflight_message_request(request: &MessageRequest) -> Result<(), ApiErroOk(())}-pub fn estimate_message_request_input_tokens(request: &MessageRequest) -> u32 {+fn estimate_message_request_input_tokens(request: &MessageRequest) -> u32 {let mut estimate = estimate_serialized_tokens(&request.messages);estimate = estimate.saturating_add(estimate_serialized_tokens(&request.system));estimate = estimate.saturating_add(estimate_serialized_tokens(&request.tools));diff --git a/rust/crates/api/src/providers/openai_compat.rs b/rust/crates/api/src/providers/openai_compat.rsindex 183bd35d..e1cca048 100644--- a/rust/crates/api/src/providers/openai_compat.rs+++ b/rust/crates/api/src/providers/openai_compat.rs@@ -7,7 +7,7 @@ use std::time::{Duration, SystemTime, UNIX_EPOCH};use serde::Deserialize;use serde_json::{json, Value};-use crate::error::{ApiError, ApiErrorDetails};+use crate::error::ApiError;use crate::http_client::build_http_client_or_default;use crate::types::{ContentBlockDelta, ContentBlockDeltaEvent, ContentBlockStartEvent, ContentBlockStopEvent,@@ -239,7 +239,7 @@ impl OpenAiCompatClient {.get("code").and_then(serde_json::Value::as_u64).map(|c| c as u16);- return Err(ApiError::Api(Box::new(ApiErrorDetails {+ return Err(ApiError::Api {status: reqwest::StatusCode::from_u16(code.unwrap_or(400)).unwrap_or(reqwest::StatusCode::BAD_REQUEST),error_type: err_obj@@ -255,7 +255,7 @@ impl OpenAiCompatClient {.unwrap_or(reqwest::StatusCode::BAD_REQUEST),),retry_after: None,- })));+ });}}let payload = serde_json::from_str::<ChatCompletionResponse>(&body).map_err(|error| {@@ -1613,7 +1613,7 @@ fn parse_sse_frame(.map(|c| c as u16);let status = reqwest::StatusCode::from_u16(code.unwrap_or(500)).unwrap_or(reqwest::StatusCode::INTERNAL_SERVER_ERROR);- return Err(ApiError::Api(Box::new(ApiErrorDetails {+ return Err(ApiError::Api {status,error_type: err_obj.get("type")@@ -1625,12 +1625,12 @@ fn parse_sse_frame(retryable: false,suggested_action: suggested_action_for_status(status),retry_after: None,- })));+ });}}// Detect HTML responsesif trimmed.starts_with('<') || trimmed.starts_with("<!") {- return Err(ApiError::Api(Box::new(ApiErrorDetails {+ return Err(ApiError::Api {status: reqwest::StatusCode::BAD_REQUEST,error_type: Some("invalid_response".to_string()),message: Some(@@ -1641,7 +1641,7 @@ fn parse_sse_frame(retryable: false,suggested_action: Some("verify the API endpoint URL is correct".to_string()),retry_after: None,- })));+ });}return Ok(None);}@@ -1665,7 +1665,7 @@ fn parse_sse_frame(.map(|c| c as u16);let status = reqwest::StatusCode::from_u16(code.unwrap_or(400)).unwrap_or(reqwest::StatusCode::BAD_REQUEST);- return Err(ApiError::Api(Box::new(ApiErrorDetails {+ return Err(ApiError::Api {status,error_type: err_obj.get("type")@@ -1677,13 +1677,13 @@ fn parse_sse_frame(retryable: false,suggested_action: suggested_action_for_status(status),retry_after: None,- })));+ });}}// Detect HTML or other non-JSON responses early for better error messageslet trimmed_payload = payload.trim();if trimmed_payload.starts_with('<') || trimmed_payload.starts_with("<!") {- return Err(ApiError::Api(Box::new(ApiErrorDetails {+ return Err(ApiError::Api {status: reqwest::StatusCode::BAD_REQUEST,error_type: Some("invalid_response".to_string()),message: Some(@@ -1694,7 +1694,7 @@ fn parse_sse_frame(retryable: false,suggested_action: Some("verify the API endpoint URL is correct".to_string()),retry_after: None,- })));+ });}serde_json::from_str::<ChatCompletionChunk>(&payload).map(Some)@@ -1754,7 +1754,7 @@ async fn expect_success(response: reqwest::Response) -> Result<reqwest::Responselet suggested_action = suggested_action_for_status(status);- Err(ApiError::Api(Box::new(ApiErrorDetails {+ Err(ApiError::Api {status,error_type: parsed_error.as_ref()@@ -1767,7 +1767,7 @@ async fn expect_success(response: reqwest::Response) -> Result<reqwest::Responseretryable,suggested_action,retry_after,- })))+ })}fn parse_retry_after(diff --git a/rust/crates/api/tests/client_integration.rs b/rust/crates/api/tests/client_integration.rsindex 82501c28..c53e34c5 100644--- a/rust/crates/api/tests/client_integration.rs+++ b/rust/crates/api/tests/client_integration.rs@@ -585,11 +585,14 @@ async fn surfaces_retry_exhaustion_for_persistent_retryable_errors() {last_error,} => {assert_eq!(attempts, 2);- let details = last_error- .api_details()- .expect("last error should be a provider Api error");- assert_eq!(details.status, reqwest::StatusCode::SERVICE_UNAVAILABLE);- assert!(details.retryable);+ assert!(matches!(+ *last_error,+ ApiError::Api {+ status: reqwest::StatusCode::SERVICE_UNAVAILABLE,+ retryable: true,+ ..+ }+ ));}other => panic!("expected retries exhausted, got {other:?}"),}diff --git a/rust/crates/claw-rag-service/src/ingest.rs b/rust/crates/claw-rag-service/src/ingest.rsindex c7083d14..eae43629 100644--- a/rust/crates/claw-rag-service/src/ingest.rs+++ b/rust/crates/claw-rag-service/src/ingest.rs@@ -66,7 +66,7 @@ async fn flush_path_batch(#[cfg(feature = "qdrant-index")]let mut qdrant_points: Vec<ChunkPoint> = Vec::with_capacity(batch.len());- for ((ord, t), vec) in batch.drain(..).zip(vecs) {+ for ((ord, t), vec) in batch.drain(..).zip(vecs.into_iter()) {let dim = vec.len();let cid = insert_chunk(conn, path, ord, &t)?;insert_embedding(conn, cid, dim, &vec)?;diff --git a/rust/crates/runtime/src/compact.rs b/rust/crates/runtime/src/compact.rsindex d0273f44..797d3a6b 100644--- a/rust/crates/runtime/src/compact.rs+++ b/rust/crates/runtime/src/compact.rs@@ -95,21 +95,10 @@ pub fn get_compact_continuation_message(#[must_use]pub fn compact_session(session: &Session, config: CompactionConfig) -> CompactionResult {if !should_compact(session, config) {- // "Nothing to drop" is not the same as "nothing to do". A session can exceed the window- // while holding fewer messages than `preserve_recent_messages` — a single read of a large- // file does it — and message-granular compaction has no move to make there. Trim the- // payloads anyway, so the one lever that still works is not gated behind the one that- // does not.- let mut trimmed_session = session.clone();- trimmed_session.messages = session- .messages- .iter()- .map(truncate_oversized_tool_results)- .collect();return CompactionResult {summary: String::new(),formatted_summary: String::new(),- compacted_session: trimmed_session,+ compacted_session: session.clone(),removed_message_count: 0,};}@@ -176,14 +165,7 @@ pub fn compact_session(session: &Session, config: CompactionConfig) -> Compactiok};let removed = &session.messages[compacted_prefix_len..keep_from];- // Dropping whole messages is not enough on its own. An agentic turn is five messages- // (user / assistant+tool_use / tool_result / assistant+tool_use / tool_result), so the- // preserved tail IS the pair of tool results that overflowed the window, and the only- // message compaction may drop is the short user prompt. Trim the payloads that must stay.- let preserved = session.messages[keep_from..]- .iter()- .map(truncate_oversized_tool_results)- .collect::<Vec<_>>();+ let preserved = session.messages[keep_from..].to_vec();let summary =merge_compact_summaries(existing_summary.as_deref(), &summarize_messages(removed));let formatted_summary = format_compact_summary(&summary);@@ -208,78 +190,6 @@ pub fn compact_session(session: &Session, config: CompactionConfig) -> Compactio}}-/// Largest tool-result payload compaction will preserve verbatim, in characters.-///-/// ~16 KB is ~4 k tokens: big enough that ordinary tool output is never touched, small enough-/// that several preserved results still fit a small window.-const MAX_PRESERVED_TOOL_RESULT_CHARS: usize = 16 * 1024;--/// Characters kept from the tail of a trimmed payload. The head carries the structure a model-/// needs to recognise what it read; the tail is where a file's most recent edits usually are.-const PRESERVED_TOOL_RESULT_TAIL_CHARS: usize = 2 * 1024;--/// Returns `message` with any oversized `ToolResult` payload replaced by a head/tail excerpt.-///-/// Clones only when something is actually trimmed, so the common path stays cheap.-fn truncate_oversized_tool_results(message: &ConversationMessage) -> ConversationMessage {- let needs_trim = message.blocks.iter().any(|block| match block {- ContentBlock::ToolResult { output, .. } => {- output.chars().count() > MAX_PRESERVED_TOOL_RESULT_CHARS- }- _ => false,- });- if !needs_trim {- return message.clone();- }-- let blocks = message- .blocks- .iter()- .map(|block| match block {- ContentBlock::ToolResult {- tool_use_id,- tool_name,- output,- is_error,- } => ContentBlock::ToolResult {- tool_use_id: tool_use_id.clone(),- tool_name: tool_name.clone(),- output: excerpt_tool_result(output),- is_error: *is_error,- },- other => other.clone(),- })- .collect();-- ConversationMessage {- role: message.role,- blocks,- usage: message.usage,- }-}--/// Builds a head + marker + tail excerpt of an oversized tool-result payload.-///-/// Operates on chars, not bytes, so a multi-byte boundary can never be split.-fn excerpt_tool_result(output: &str) -> String {- let chars: Vec<char> = output.chars().collect();- let total = chars.len();- if total <= MAX_PRESERVED_TOOL_RESULT_CHARS {- return output.to_string();- }-- let tail_len = PRESERVED_TOOL_RESULT_TAIL_CHARS.min(total);- let head_len = MAX_PRESERVED_TOOL_RESULT_CHARS.saturating_sub(tail_len);- let elided = total.saturating_sub(head_len + tail_len);- if elided == 0 {- return output.to_string();- }-- let head: String = chars[..head_len].iter().collect();- let tail: String = chars[total - tail_len..].iter().collect();- format!("{head}\n\n[... {elided} characters elided by compaction; re-read this file if you need the omitted portion ...]\n\n{tail}")-}-fn compacted_summary_prefix_len(session: &Session) -> usize {usize::from(session@@ -663,7 +573,7 @@ fn extract_summary_timeline(summary: &str) -> Vec<String> {#[cfg(test)]mod tests {use super::{- collect_key_files, compact_session, estimate_session_tokens, format_compact_summary,+ collect_key_files, compact_session, format_compact_summary,get_compact_continuation_message, infer_pending_work, should_compact, CompactionConfig,};use crate::session::{ContentBlock, ConversationMessage, MessageRole, Session};@@ -853,185 +763,6 @@ mod tests {/// user(ToolResult) pair at the boundary. An orphaned tool-result message/// without the preceding assistant `tool_calls` causes a 400 on the/// OpenAI-compat path (gaebal-gajae repro 2026-04-09).- /// The failure this exists for: an agentic turn is 5 messages (user / assistant+tool_use /- /// tool_result / assistant+tool_use / tool_result), so `preserve_recent_messages: 4` protects- /// exactly the two giant tool results that overflow the window. Message-granular compaction- /// can only drop the tiny user prompt, so the payloads themselves must be trimmed.- #[test]- fn compaction_truncates_oversized_tool_results_it_must_preserve() {- let huge = "z".repeat(80_000);- let mut session = Session::new();- session- .push_message(ConversationMessage::user_text("read two files"))- .expect("user message");- session- .push_message(ConversationMessage::assistant(vec![- ContentBlock::ToolUse {- id: "call-1".to_string(),- name: "read_file".to_string(),- input: "{\"path\":\"a.rs\"}".to_string(),- },- ]))- .expect("assistant tool use");- session- .push_message(ConversationMessage::tool_result(- "call-1",- "read_file",- huge.clone(),- false,- ))- .expect("tool result");- session- .push_message(ConversationMessage::assistant(vec![- ContentBlock::ToolUse {- id: "call-2".to_string(),- name: "read_file".to_string(),- input: "{\"path\":\"b.rs\"}".to_string(),- },- ]))- .expect("second assistant tool use");- session- .push_message(ConversationMessage::tool_result(- "call-2",- "read_file",- huge.clone(),- false,- ))- .expect("second tool result");-- let before = estimate_session_tokens(&session);- let result = compact_session(- &session,- CompactionConfig {- preserve_recent_messages: 4,- max_estimated_tokens: 0,- },- );- let after = estimate_session_tokens(&result.compacted_session);-- assert!(- after < before / 2,- "compaction must shrink an oversized preserved tool result: {before} -> {after}"- );-- let preserved_output = result- .compacted_session- .messages- .iter()- .flat_map(|message| &message.blocks)- .find_map(|block| match block {- ContentBlock::ToolResult { output, .. } => Some(output.clone()),- _ => None,- })- .expect("the tool result must still be present, not deleted");-- assert!(- preserved_output.len() < huge.len(),- "the payload must actually be trimmed"- );- assert!(- preserved_output.contains("elided"),- "the model must be told the view is partial, got: {}",- &preserved_output[..preserved_output.len().min(200)]- );- assert!(- preserved_output.starts_with('z'),- "the head of the output must be kept"- );- assert!(- preserved_output.ends_with('z'),- "the tail of the output must be kept"- );- }-- /// A session can exceed the window while holding FEWER messages than- /// `preserve_recent_messages` — one read of a large file does it. `should_compact` returns- /// false there (nothing is droppable), so trimming must not be gated behind it.- #[test]- fn oversized_tool_results_are_trimmed_even_when_no_message_can_be_dropped() {- let huge = "q".repeat(80_000);- let mut session = Session::new();- session- .push_message(ConversationMessage::user_text("read one enormous file"))- .expect("user message");- session- .push_message(ConversationMessage::assistant(vec![- ContentBlock::ToolUse {- id: "call-1".to_string(),- name: "read_file".to_string(),- input: "{\"path\":\"huge.rs\"}".to_string(),- },- ]))- .expect("assistant tool use");- session- .push_message(ConversationMessage::tool_result(- "call-1",- "read_file",- huge,- false,- ))- .expect("tool result");-- // 3 messages, preserve 4: there is nothing to remove, yet the session is far too big.- let before = estimate_session_tokens(&session);- let result = compact_session(- &session,- CompactionConfig {- preserve_recent_messages: 4,- max_estimated_tokens: 0,- },- );- let after = estimate_session_tokens(&result.compacted_session);-- assert!(- after < before / 2,- "an untrimmable session must still have its payloads trimmed: {before} -> {after}"- );- }-- /// Trimming must not touch payloads that already fit — otherwise every ordinary tool result- /// would grow an elision marker it does not need.- #[test]- fn compaction_leaves_small_tool_results_untouched() {- let small = "ok".repeat(50);- let mut session = Session::new();- for index in 0..6 {- session- .push_message(ConversationMessage::user_text(format!("turn {index}")))- .expect("user message");- session- .push_message(ConversationMessage::tool_result(- format!("call-{index}"),- "read_file",- small.clone(),- false,- ))- .expect("tool result");- }-- let result = compact_session(- &session,- CompactionConfig {- preserve_recent_messages: 4,- max_estimated_tokens: 0,- },- );-- for block in result- .compacted_session- .messages- .iter()- .flat_map(|message| &message.blocks)- {- if let ContentBlock::ToolResult { output, .. } = block {- assert_eq!(- output, &small,- "a small tool result must pass through as-is"- );- }- }- }-#[test]fn compaction_does_not_split_tool_use_tool_result_pair() {use crate::session::{ContentBlock, Session};diff --git a/rust/crates/runtime/src/conversation.rs b/rust/crates/runtime/src/conversation.rsindex 851149b9..5a0ebc72 100644--- a/rust/crates/runtime/src/conversation.rs+++ b/rust/crates/runtime/src/conversation.rs@@ -18,47 +18,6 @@ use crate::usage::{TokenUsage, UsageTracker};const DEFAULT_AUTO_COMPACTION_INPUT_TOKENS_THRESHOLD: u32 = 100_000;const AUTO_COMPACTION_THRESHOLD_ENV_VAR: &str = "CLAUDE_CODE_AUTO_COMPACT_INPUT_TOKENS";-const DEFAULT_MAX_STALL_NUDGES: usize = 3;-const MAX_STALL_NUDGES_ENV_VAR: &str = "CLAW_MAX_STALL_NUDGES";-/// Placeholder recorded in the trace when a turn is resumed rather than started, so the trace-/// does not attribute a second user message to a turn that only had one.-const RESUMED_TURN_MARKER: &str = "[resumed turn]";-/// Operator-declared context window. Kept as a literal rather than imported because `runtime`-/// sits below `api` in the dependency graph; `api::context_window_override` reads the same name.-const CONTEXT_WINDOW_ENV_VAR: &str = "CLAW_CONTEXT_WINDOW";-/// Share of a declared context window at which compaction is triggered, leaving the remainder-/// as headroom for the reply plus whatever the next tool result carries.-const AUTO_COMPACTION_WINDOW_PERCENT: u32 = 70;--/// Injected when the model narrates its next step (or asks for a go-ahead mid-task)-/// instead of emitting the tool call that would perform it.-const STALL_NUDGE_PROMPT: &str = "[auto-continue] You ended the turn without calling a tool, \- but the work is not finished. Do not describe the next step and do not ask for \- confirmation — issue the tool call now and keep going until the task is done. If \- everything asked for is genuinely complete, reply with a one-line summary containing \- no forward-looking sentence.";--/// Phrases that mark text as an announcement of work the model has not performed yet.-/// Matched against the final non-empty line of the assistant's reply.-const PENDING_ACTION_MARKERS: [&str; 16] = [- "let me ",- "let's ",- "lets ",- "i'll ",- "i will ",- "i'm going to",- "i am going to",- "going to run",- "about to ",- "now running",- "now checking",- "now i",- "next i",- "next, i",- "proceeding to",- "moving on to",-];-/// Fully assembled request payload sent to the upstream model client.#[derive(Debug, Clone, PartialEq, Eq)]pub struct ApiRequest {@@ -131,7 +90,6 @@ impl std::error::Error for ToolError {}#[derive(Debug, Clone, PartialEq, Eq)]pub struct RuntimeError {message: String,- context_window: bool,}impl RuntimeError {@@ -139,28 +97,8 @@ impl RuntimeError {pub fn new(message: impl Into<String>) -> Self {Self {message: message.into(),- context_window: false,}}-- /// A failure the caller may be able to clear by shrinking the session.- ///- /// This is a decision the API layer makes and hands up, not one the caller reconstructs by- /// matching substrings against the rendered message. Recovering from context exhaustion means- /// discarding conversation history, so a transport hiccup misread as an overflow destroys the- /// session for no reason — the classification has to come from whoever saw the real error.- #[must_use]- pub fn context_window(message: impl Into<String>) -> Self {- Self {- message: message.into(),- context_window: true,- }- }-- #[must_use]- pub const fn is_context_window_failure(&self) -> bool {- self.context_window- }}impl Display for RuntimeError {@@ -202,7 +140,6 @@ pub struct ConversationRuntime<C, T> {hook_abort_signal: HookAbortSignal,hook_progress_reporter: Option<Box<dyn HookProgressReporter>>,session_tracer: Option<SessionTracer>,- max_stall_nudges: usize,}impl<C, T> ConversationRuntime<C, T>@@ -257,17 +194,9 @@ wherehook_abort_signal: HookAbortSignal::default(),hook_progress_reporter: None,session_tracer: None,- max_stall_nudges: max_stall_nudges_from_env(),}}- /// Override how many auto-continue nudges a stalled turn may receive. `0` disables them.- #[must_use]- pub fn with_max_stall_nudges(mut self, max_stall_nudges: usize) -> Self {- self.max_stall_nudges = max_stall_nudges;- self- }-#[must_use]pub fn with_max_iterations(mut self, max_iterations: usize) -> Self {self.max_iterations = max_iterations;@@ -397,33 +326,14 @@ where}}+ #[allow(clippy::too_many_lines)]pub fn run_turn(&mut self,user_input: impl Into<String>,- prompter: Option<&mut dyn PermissionPrompter>,- ) -> Result<TurnSummary, RuntimeError> {- self.drive_turn(Some(user_input.into()), prompter)- }-- /// Continues the turn already recorded in the session, without adding a user message.- ///- /// Recovery paths retry a turn that failed part-way through. Calling [`Self::run_turn`] again- /// with the original input would append that input a second time and invite the model to redo- /// tool calls whose side effects have already landed. Resuming reads the transcript as it- /// stands — including the tool results that did complete — and carries on from there.- pub fn resume_turn(- &mut self,- prompter: Option<&mut dyn PermissionPrompter>,- ) -> Result<TurnSummary, RuntimeError> {- self.drive_turn(None, prompter)- }-- #[allow(clippy::too_many_lines)]- fn drive_turn(- &mut self,- user_input: Option<String>,mut prompter: Option<&mut dyn PermissionPrompter>,) -> Result<TurnSummary, RuntimeError> {+ let user_input = user_input.into();+// ROADMAP #38: Session-health canary - probe if context was compactedif self.session.compaction.is_some() {if let Err(error) = self.run_session_health_probe() {@@ -435,24 +345,16 @@ where}}- match user_input {- Some(user_input) => {- self.record_turn_started(&user_input);- self.session- .push_user_text(user_input)- .map_err(|error| RuntimeError::new(error.to_string()))?;- }- None => self.record_turn_started(RESUMED_TURN_MARKER),- }+ self.record_turn_started(&user_input);+ self.session+ .push_user_text(user_input)+ .map_err(|error| RuntimeError::new(error.to_string()))?;let mut assistant_messages = Vec::new();let mut tool_results = Vec::new();let mut prompt_cache_events = Vec::new();let mut iterations = 0;let mut auto_compaction = None;- let max_stall_nudges = self.max_stall_nudges;- let mut stall_nudges = 0;- let mut tools_ran = false;loop {iterations += 1;@@ -464,23 +366,6 @@ wherereturn Err(error);}- // Compact BEFORE the request goes out, not only after a reply lands.- //- // The usage-based check below is post-hoc: it can only see the context once a call- // has returned and reported its counters. Between that measurement and the next- // request the session can grow enormously — a reasoning model emitting a long- // <think> block, then a tool result carrying a large file. Observed live: a call- // measured at 17,858 prompt tokens generated 10,842 more, a read_file added ~19k on- // top, and the next request hit the provider at 47,755 tokens and was rejected- // outright. No amount of tuning the post-hoc threshold prevents that, because- // nothing measures the session in between.- //- // `estimate_session_tokens` is a local heuristic over the transcript, so this costs- // no API call and works before any usage has ever been recorded.- if let Some(compaction) = self.maybe_auto_compact_before_request() {- auto_compaction = Some(compaction);- }-let request = ApiRequest {system_prompt: self.system_prompt.clone(),messages: self.session.messages.clone(),@@ -496,7 +381,6 @@ wherematch build_assistant_message(events) {Ok(result) => result,Err(error) => {- let error = self.classify_empty_reply(error);self.record_turn_failed(iterations, &error);return Err(error);}@@ -533,35 +417,8 @@ where}if pending_tool_uses.is_empty() {- // A reply with no tool call usually means the turn is done. On small local- // models it just as often means the model narrated the next step — or asked- // for a go-ahead mid-task — and then emitted EOS, leaving the announced work- // undone. Nudge it back into the loop instead of dropping the user at the- // prompt, bounded so a model that insists it is finished still gets to stop.- let stalled = stall_nudges < max_stall_nudges- && is_stalled_reply(- &assistant_text(- assistant_messages- .last()- .expect("assistant message pushed above"),- ),- tools_ran,- );- if stalled {- stall_nudges += 1;- // Pushed as a system turn, not a user one. The model needs to see it, but the- // transcript must not claim the user asked for it: this text is persisted,- // re-sent on every later request, and folded into the next compaction summary,- // where a user-labelled nudge becomes indistinguishable from something the- // user actually said.- self.session- .push_message(ConversationMessage::system_text(STALL_NUDGE_PROMPT))- .map_err(|error| RuntimeError::new(error.to_string()))?;- continue;- }break;}- tools_ran = true;for (tool_use_id, tool_name, input) in pending_tool_uses {let pre_hook_result = self.run_pre_tool_use_hook(&tool_name, &input);@@ -716,62 +573,13 @@ whereself.session}- /// Compaction check run immediately before a request is sent, based on a locally estimated- /// transcript size rather than on provider-reported usage.- ///- /// This is the guard that actually keeps a session inside the context window: it sees growth- /// that usage counters cannot, because it runs after tool results and long generations have- /// been appended but before the request that would carry them is built.- /// Decides whether an empty or unreadable reply was an overflow, by size rather than by text.- ///- /// A stream that produces no content says nothing about why. Some backends answer an- /// oversized request that way instead of with a typed error, so the failure is worth- /// recovering from — but only when the session was already large enough for that to be the- /// plausible cause. Below the compaction threshold it is a blip, and discarding the- /// transcript would cost more than the retry could win.- fn classify_empty_reply(&self, error: RuntimeError) -> RuntimeError {- if error.is_context_window_failure() {- return error;- }- if estimate_session_tokens(&self.session)- >= self.auto_compaction_input_tokens_threshold as usize- {- return RuntimeError::context_window(error.to_string());- }- error- }-- fn maybe_auto_compact_before_request(&mut self) -> Option<AutoCompactionEvent> {- let estimated = estimate_session_tokens(&self.session);- if estimated < self.auto_compaction_input_tokens_threshold as usize {- return None;- }- self.compact_now()- }-fn maybe_auto_compact(&mut self) -> Option<AutoCompactionEvent> {- // Gate on the LIVE context size — the most recent call's input counters — not on a- // cumulative running total, and count cached input as the context it is.- //- // The previous gate (`cumulative_usage().input_tokens`) was wrong twice over:- // 1. It ignored `cache_read_input_tokens`. With prompt caching a warm call reports- // `input_tokens: 2`, so the counter crawled and compaction never fired however- // large the context grew.- // 2. Summing across calls is not a context measurement, and the sum never decreased,- // so once it did trip, every later iteration compacted forever.- // Reading the latest turn fixes both: it rises with the real context and falls back- // below the threshold as soon as a compaction has done its job.- if self.usage_tracker.current_turn_usage().total_input_tokens()+ if self.usage_tracker.cumulative_usage().input_tokens< self.auto_compaction_input_tokens_threshold{return None;}- self.compact_now()- }-- /// Compacts the session unconditionally, returning `None` when nothing actually changed.- fn compact_now(&mut self) -> Option<AutoCompactionEvent> {let result = compact_session(&self.session,CompactionConfig {@@ -780,12 +588,7 @@ where},);- // `removed_message_count` alone is the wrong test for "did anything happen": compaction- // also trims oversized tool-result payloads in messages it must PRESERVE, and on a- // session too short to have anything droppable that trimming is the entire result.- // Gating on the count would compute the smaller session and then throw it away.- let shrank = result.compacted_session.messages != self.session.messages;- if result.removed_message_count == 0 && !shrank {+ if result.removed_message_count == 0 {return None;}@@ -906,88 +709,19 @@ where/// Reads the automatic compaction threshold from the environment.#[must_use]pub fn auto_compaction_threshold_from_env() -> u32 {- resolve_auto_compaction_threshold(+ parse_auto_compaction_threshold(std::env::var(AUTO_COMPACTION_THRESHOLD_ENV_VAR).ok().as_deref(),- std::env::var(CONTEXT_WINDOW_ENV_VAR).ok().as_deref(),)}-/// Resolves the threshold from an explicit setting, else from the declared context window.-///-/// `DEFAULT_AUTO_COMPACTION_INPUT_TOKENS_THRESHOLD` is a 200k-window number. Against a smaller-/// server it sits above the window entirely, so the pre-request guard can never fire and the-/// first sign of trouble is the backend rejecting the request. Deriving from the declared window-/// keeps the guard meaningful without every caller having to compute a second number by hand.#[must_use]-fn resolve_auto_compaction_threshold(explicit: Option<&str>, context_window: Option<&str>) -> u32 {- if let Some(threshold) = parse_positive_u32(explicit) {- return threshold;- }- parse_positive_u32(context_window).map_or(- DEFAULT_AUTO_COMPACTION_INPUT_TOKENS_THRESHOLD,- |window| {- (u64::from(window) * u64::from(AUTO_COMPACTION_WINDOW_PERCENT) / 100)- .try_into()- .unwrap_or(DEFAULT_AUTO_COMPACTION_INPUT_TOKENS_THRESHOLD)- },- )-}--#[must_use]-fn parse_positive_u32(value: Option<&str>) -> Option<u32> {+fn parse_auto_compaction_threshold(value: Option<&str>) -> u32 {value.and_then(|raw| raw.trim().parse::<u32>().ok())- .filter(|parsed| *parsed > 0)-}--/// How many auto-continue nudges a single turn may inject. `0` disables the behaviour.-#[must_use]-pub fn max_stall_nudges_from_env() -> usize {- parse_max_stall_nudges(std::env::var(MAX_STALL_NUDGES_ENV_VAR).ok().as_deref())-}--#[must_use]-fn parse_max_stall_nudges(value: Option<&str>) -> usize {- value- .and_then(|raw| raw.trim().parse::<usize>().ok())- .unwrap_or(DEFAULT_MAX_STALL_NUDGES)-}--/// Concatenated text of an assistant message, ignoring thinking and tool blocks.-#[must_use]-fn assistant_text(message: &ConversationMessage) -> String {- message- .blocks- .iter()- .filter_map(|block| match block {- ContentBlock::Text { text } => Some(text.as_str()),- _ => None,- })- .collect::<Vec<_>>()- .join("\n")-}--/// True when a tool-less reply is a stall rather than a finished turn.-///-/// Small local models routinely narrate the next tool call in prose and then emit EOS, which-/// ends the turn with the announced work never performed. `after_tool_use` additionally treats-/// a mid-task question as a stall: once tools have run in this turn, stopping to ask for a-/// go-ahead is the same failure wearing a different hat.-#[must_use]-fn is_stalled_reply(text: &str, after_tool_use: bool) -> bool {- let Some(last_line) = text.lines().map(str::trim).rfind(|line| !line.is_empty()) else {- return false;- };- let lowered = last_line.to_lowercase();-- if after_tool_use && last_line.ends_with('?') {- return true;- }- PENDING_ACTION_MARKERS- .iter()- .any(|marker| lowered.contains(marker))+ .filter(|threshold| *threshold > 0)+ .unwrap_or(DEFAULT_AUTO_COMPACTION_INPUT_TOKENS_THRESHOLD)}fn build_assistant_message(@@ -1119,13 +853,11 @@ impl ToolExecutor for StaticToolExecutor {#[cfg(test)]mod tests {use super::{- assistant_text, build_assistant_message, is_stalled_reply, parse_max_stall_nudges,- resolve_auto_compaction_threshold, ApiClient, ApiRequest, AssistantEvent,- AutoCompactionEvent, ConversationRuntime, PromptCacheEvent, RuntimeError,+ build_assistant_message, parse_auto_compaction_threshold, ApiClient, ApiRequest,+ AssistantEvent, AutoCompactionEvent, ConversationRuntime, PromptCacheEvent, RuntimeError,StaticToolExecutor, ToolExecutor, DEFAULT_AUTO_COMPACTION_INPUT_TOKENS_THRESHOLD,- DEFAULT_MAX_STALL_NUDGES,};- use crate::compact::{estimate_session_tokens, CompactionConfig};+ use crate::compact::CompactionConfig;use crate::config::{RuntimeFeatureConfig, RuntimeHookConfig};use crate::permissions::{PermissionMode, PermissionPolicy, PermissionPromptDecision, PermissionPrompter,@@ -1969,246 +1701,19 @@ mod tests {assert_eq!(runtime.session().messages.len(), 2);}- /// Prompt caching reports the bulk of the context as `cache_read_input_tokens` and leaves- /// `input_tokens` at a token or two, so a gate that reads `input_tokens` alone never fires- /// on a cached session no matter how large the context has grown.- #[test]- fn auto_compaction_counts_cached_context_toward_threshold() {- struct CachedApi;- impl ApiClient for CachedApi {- fn stream(- &mut self,- _request: ApiRequest,- ) -> Result<Vec<AssistantEvent>, RuntimeError> {- Ok(vec![- AssistantEvent::TextDelta("done".to_string()),- AssistantEvent::Usage(TokenUsage {- input_tokens: 2,- output_tokens: 4,- cache_creation_input_tokens: 1_804,- cache_read_input_tokens: 112_639,- }),- AssistantEvent::MessageStop,- ])- }- }-- let mut session = Session::new();- session.messages = vec![- crate::session::ConversationMessage::user_text("one"),- crate::session::ConversationMessage::assistant(vec![ContentBlock::Text {- text: "two".to_string(),- }]),- crate::session::ConversationMessage::user_text("three"),- crate::session::ConversationMessage::assistant(vec![ContentBlock::Text {- text: "four".to_string(),- }]),- ];-- let mut runtime = ConversationRuntime::new(- session,- CachedApi,- StaticToolExecutor::new(),- PermissionPolicy::new(PermissionMode::DangerFullAccess),- vec!["system".to_string()],- )- .with_auto_compaction_input_tokens_threshold(100_000);-- let summary = runtime- .run_turn("trigger", None)- .expect("turn should succeed");-- assert_eq!(- summary.auto_compaction,- Some(AutoCompactionEvent {- removed_message_count: 2,- })- );- }-- /// The threshold describes the LIVE context, not a monotonic running total. Once compaction- /// has shrunk the context back down, later small turns must not keep compacting.- #[test]- fn auto_compaction_stops_once_the_context_shrinks_again() {- struct ShrinkingApi {- calls: u32,- }- impl ApiClient for ShrinkingApi {- fn stream(- &mut self,- _request: ApiRequest,- ) -> Result<Vec<AssistantEvent>, RuntimeError> {- let call = self.calls;- self.calls += 1;- // The first call is over budget; every call after it is small.- let input_tokens = if call == 0 { 150_000 } else { 900 };- Ok(vec![- AssistantEvent::TextDelta("done".to_string()),- AssistantEvent::Usage(TokenUsage {- input_tokens,- output_tokens: 4,- cache_creation_input_tokens: 0,- cache_read_input_tokens: 0,- }),- AssistantEvent::MessageStop,- ])- }- }-- let mut session = Session::new();- session.messages = vec![- crate::session::ConversationMessage::user_text("one"),- crate::session::ConversationMessage::assistant(vec![ContentBlock::Text {- text: "two".to_string(),- }]),- crate::session::ConversationMessage::user_text("three"),- crate::session::ConversationMessage::assistant(vec![ContentBlock::Text {- text: "four".to_string(),- }]),- ];-- let mut runtime = ConversationRuntime::new(- session,- ShrinkingApi { calls: 0 },- // Every turn after a compaction runs the session health probe, which calls- // `glob_search`; without it the probe fails the turn before the assertion is reached.- StaticToolExecutor::new().register("glob_search", |_| Ok(String::new())),- PermissionPolicy::new(PermissionMode::DangerFullAccess),- vec!["system".to_string()],- )- .with_auto_compaction_input_tokens_threshold(100_000);-- let first = runtime.run_turn("trigger", None).expect("first turn");- assert!(- first.auto_compaction.is_some(),- "the over-budget turn should compact"- );-- let second = runtime.run_turn("again", None).expect("second turn");- assert_eq!(- second.auto_compaction, None,- "a small turn after compaction must not compact again"- );- let third = runtime.run_turn("and again", None).expect("third turn");- assert_eq!(- third.auto_compaction, None,- "compaction must not latch on once the threshold has been crossed"- );- }-- /// Usage-based compaction is post-hoc: it only sees the context AFTER a call returns. A- /// large tool result (or a long reasoning block) appended after that measurement can blow- /// the window on the very next request, which the provider rejects outright — so there must- /// also be a check BEFORE the request goes out, based on a locally estimated session size.- #[test]- fn auto_compaction_fires_before_the_first_request_when_the_session_is_already_oversized() {- struct RecordingApi {- largest_request_messages: std::rc::Rc<std::cell::Cell<usize>>,- }- impl ApiClient for RecordingApi {- fn stream(&mut self, request: ApiRequest) -> Result<Vec<AssistantEvent>, RuntimeError> {- self.largest_request_messages.set(- self.largest_request_messages- .get()- .max(request.messages.len()),- );- Ok(vec![- AssistantEvent::TextDelta("done".to_string()),- // Deliberately no Usage event: nothing has been measured yet, which is- // exactly the situation the pre-send check has to cover.- AssistantEvent::MessageStop,- ])- }- }-- // Six messages that are individually large — the shape of a session that has just- // absorbed a couple of big file reads.- let bulk = "x".repeat(40_000);- let mut session = Session::new();- for _ in 0..3 {- session- .messages- .push(crate::session::ConversationMessage::user_text(bulk.clone()));- session- .messages- .push(crate::session::ConversationMessage::assistant(vec![- ContentBlock::Text { text: bulk.clone() },- ]));- }- let before = estimate_session_tokens(&session);- assert!(- before > 24_000,- "test fixture must start over the threshold, got {before}"- );-- let largest = std::rc::Rc::new(std::cell::Cell::new(0usize));- let mut runtime = ConversationRuntime::new(- session,- RecordingApi {- largest_request_messages: std::rc::Rc::clone(&largest),- },- StaticToolExecutor::new().register("glob_search", |_| Ok(String::new())),- PermissionPolicy::new(PermissionMode::DangerFullAccess),- vec!["system".to_string()],- )- .with_auto_compaction_input_tokens_threshold(24_000);-- let summary = runtime- .run_turn("trigger", None)- .expect("turn should succeed");-- assert!(- summary.auto_compaction.is_some(),- "an already-oversized session must compact before the request is sent"- );- assert!(- estimate_session_tokens(runtime.session()) < before,- "compaction must actually shrink the session"- );- assert!(- largest.get() < 8,- "the request must be sent with the compacted history, not the original 7 messages"- );- }-#[test]fn auto_compaction_threshold_defaults_and_parses_values() {assert_eq!(- resolve_auto_compaction_threshold(None, None),+ parse_auto_compaction_threshold(None),DEFAULT_AUTO_COMPACTION_INPUT_TOKENS_THRESHOLD);- assert_eq!(resolve_auto_compaction_threshold(Some("4321"), None), 4321);+ assert_eq!(parse_auto_compaction_threshold(Some("4321")), 4321);assert_eq!(- resolve_auto_compaction_threshold(Some("0"), None),+ parse_auto_compaction_threshold(Some("0")),DEFAULT_AUTO_COMPACTION_INPUT_TOKENS_THRESHOLD);assert_eq!(- resolve_auto_compaction_threshold(Some("not-a-number"), None),- DEFAULT_AUTO_COMPACTION_INPUT_TOKENS_THRESHOLD- );- }-- #[test]- fn auto_compaction_threshold_derives_from_a_declared_context_window() {- // 70% of 65536, so the guard sits inside the window instead of 34k above it.- assert_eq!(- resolve_auto_compaction_threshold(None, Some("65536")),- 45875- );- }-- #[test]- fn an_explicit_threshold_still_wins_over_the_declared_window() {- assert_eq!(- resolve_auto_compaction_threshold(Some("48000"), Some("65536")),- 48000- );- }-- #[test]- fn an_unparseable_context_window_falls_back_to_the_default_threshold() {- assert_eq!(- resolve_auto_compaction_threshold(None, Some("plenty")),+ parse_auto_compaction_threshold(Some("not-a-number")),DEFAULT_AUTO_COMPACTION_INPUT_TOKENS_THRESHOLD);}@@ -2380,146 +1885,6 @@ mod tests {assert_eq!(error.to_string(), "unknown tool: missing");}- /// Replays a fixed script of stream outcomes, one per call.- struct ScriptedApi {- steps: Vec<Result<Vec<AssistantEvent>, String>>,- calls: usize,- }-- impl ScriptedApi {- fn new(steps: Vec<Result<Vec<AssistantEvent>, String>>) -> Self {- Self { steps, calls: 0 }- }- }-- impl ApiClient for ScriptedApi {- fn stream(&mut self, _request: ApiRequest) -> Result<Vec<AssistantEvent>, RuntimeError> {- let step = self- .steps- .get(self.calls)- .cloned()- .unwrap_or_else(|| Err("script exhausted".to_string()));- self.calls += 1;- step.map_err(RuntimeError::new)- }- }-- fn tool_call_events(id: &str) -> Vec<AssistantEvent> {- vec![- AssistantEvent::ToolUse {- id: id.to_string(),- name: "echo".to_string(),- input: "payload".to_string(),- },- AssistantEvent::MessageStop,- ]- }-- fn scripted_runtime(- steps: Vec<Result<Vec<AssistantEvent>, String>>,- ) -> ConversationRuntime<ScriptedApi, StaticToolExecutor> {- ConversationRuntime::new(- Session::new(),- ScriptedApi::new(steps),- StaticToolExecutor::new().register("echo", |input| Ok(input.to_string())),- PermissionPolicy::new(PermissionMode::DangerFullAccess),- vec!["system".to_string()],- )- }-- #[test]- fn a_failed_turn_keeps_the_results_of_tools_that_already_ran() {- // given: a turn whose first iteration runs a tool, and whose second call dies- let mut runtime = scripted_runtime(vec![- Ok(tool_call_events("tool-1")),- Err("upstream failed".to_string()),- ]);-- // when- runtime- .run_turn("do the thing", None)- .expect_err("the second call fails");-- // then: the executed tool's result is still in the transcript. The side effect happened;- // a caller that discards this record will let the model run the same tool again.- let tool_results = runtime- .session()- .messages- .iter()- .filter(|message| {- message- .blocks- .iter()- .any(|block| matches!(block, ContentBlock::ToolResult { .. }))- })- .count();- assert_eq!(tool_results, 1);- }-- #[test]- fn resume_turn_continues_without_appending_another_user_message() {- // given: a session that already carries a user turn and a completed tool result- let mut runtime = scripted_runtime(vec![- Ok(tool_call_events("tool-1")),- Err("upstream failed".to_string()),- Ok(vec![- AssistantEvent::TextDelta("done".to_string()),- AssistantEvent::MessageStop,- ]),- ]);- runtime.run_turn("do the thing", None).expect_err("fails");- let user_messages_before = runtime- .session()- .messages- .iter()- .filter(|message| message.role == MessageRole::User)- .count();-- // when- runtime- .resume_turn(None)- .expect("the resumed turn succeeds");-- // then: the prompt was not repeated- let user_messages_after = runtime- .session()- .messages- .iter()- .filter(|message| message.role == MessageRole::User)- .count();- assert_eq!(user_messages_before, user_messages_after);- }-- #[test]- fn a_stall_nudge_is_recorded_as_a_system_turn_not_a_user_one() {- // given: a reply that announces work and stops, so the nudge fires once- let mut runtime = nudge_runtime(- vec![- text_only("Let me check the logs."),- text_only("The logs were clean."),- ],- 1,- );- runtime- .run_turn("check the logs", None)- .expect("the nudged turn completes");-- // then: exactly one user message — the real one- let user_messages = runtime- .session()- .messages- .iter()- .filter(|message| message.role == MessageRole::User)- .count();- assert_eq!(user_messages, 1);- assert!(runtime- .session()- .messages- .iter()- .any(|message| message.role == MessageRole::System- && assistant_text(message).contains("[auto-continue]")));- }-#[test]fn run_turn_errors_when_max_iterations_is_exceeded() {struct LoopingApi;@@ -2591,136 +1956,4 @@ mod tests {// thenassert_eq!(error.to_string(), "upstream failed");}-- fn text_only(text: &str) -> Vec<AssistantEvent> {- vec![- AssistantEvent::TextDelta(text.to_string()),- AssistantEvent::MessageStop,- ]- }-- struct CountingApi {- calls: usize,- replies: Vec<Vec<AssistantEvent>>,- }-- impl ApiClient for CountingApi {- fn stream(&mut self, _request: ApiRequest) -> Result<Vec<AssistantEvent>, RuntimeError> {- let reply = self- .replies- .get(self.calls)- .cloned()- .unwrap_or_else(|| text_only("Now running the next probe:"));- self.calls += 1;- Ok(reply)- }- }-- fn nudge_runtime(- replies: Vec<Vec<AssistantEvent>>,- max_stall_nudges: usize,- ) -> ConversationRuntime<CountingApi, StaticToolExecutor> {- ConversationRuntime::new(- Session::new(),- CountingApi { calls: 0, replies },- StaticToolExecutor::new().register("probe", |_| Ok("probe output".to_string())),- PermissionPolicy::new(PermissionMode::DangerFullAccess),- vec!["system".to_string()],- )- .with_max_stall_nudges(max_stall_nudges)- }-- #[test]- fn announced_but_uncalled_tool_is_auto_continued() {- // given: the model narrates the next probe instead of calling it- let mut runtime = nudge_runtime(- vec![- text_only("Now running the Ford EEC-V tuner probe (ATSP1):"),- vec![- AssistantEvent::ToolUse {- id: "tool-1".to_string(),- name: "probe".to_string(),- input: "atsp1".to_string(),- },- AssistantEvent::MessageStop,- ],- text_only("No response on ATSP1, which is expected here."),- ],- 3,- );-- // when- let summary = runtime.run_turn("run the probes", None).expect("turn runs");-- // then: the nudge pulled it back into the loop and the tool actually ran- assert_eq!(summary.iterations, 3);- assert_eq!(summary.tool_results.len(), 1);- }-- #[test]- fn nudges_are_bounded_so_a_stuck_model_still_stops() {- // given: every reply is an announcement and nothing is ever called- let mut runtime = nudge_runtime(Vec::new(), 2);-- // when- let summary = runtime.run_turn("run the probes", None).expect("turn runs");-- // then: initial reply plus exactly two nudged retries- assert_eq!(summary.iterations, 3);- assert!(summary.tool_results.is_empty());- }-- #[test]- fn a_plain_completion_is_not_nudged() {- // given- let mut runtime = nudge_runtime(vec![text_only("The DTC scan came back clean.")], 3);-- // when- let summary = runtime.run_turn("scan for codes", None).expect("turn runs");-- // then- assert_eq!(summary.iterations, 1);- }-- #[test]- fn zero_budget_disables_auto_continue() {- // given- let mut runtime = nudge_runtime(vec![text_only("Let me run the DTC scan.")], 0);-- // when- let summary = runtime.run_turn("scan for codes", None).expect("turn runs");-- // then- assert_eq!(summary.iterations, 1);- }-- #[test]- fn a_question_stalls_only_after_a_tool_has_run() {- assert!(is_stalled_reply("Should I run the DTC scan next?", true));- assert!(!is_stalled_reply("Which port is the adapter on?", false));- }-- #[test]- fn stall_detection_reads_the_last_line_not_the_whole_reply() {- // an announcement earlier in the reply does not make a finished turn look stalled- assert!(!is_stalled_reply(- "Let me check the port.\nThe scan finished with no codes stored.",- true- ));- assert!(is_stalled_reply(- "The scan finished.\nNext I'll read the freeze-frame data.",- true- ));- }-- #[test]- fn stall_nudge_budget_parses_from_env_value() {- // asserted against the literal, not the constant: comparing the parser to the same- // constant it falls back to would pass no matter what the default became- assert_eq!(DEFAULT_MAX_STALL_NUDGES, 3);- assert_eq!(parse_max_stall_nudges(None), 3);- assert_eq!(parse_max_stall_nudges(Some("not a number")), 3);- assert_eq!(parse_max_stall_nudges(Some(" 5 ")), 5);- assert_eq!(parse_max_stall_nudges(Some("0")), 0);- }}diff --git a/rust/crates/runtime/src/file_ops.rs b/rust/crates/runtime/src/file_ops.rsindex 6e034f29..7a62447a 100644--- a/rust/crates/runtime/src/file_ops.rs+++ b/rust/crates/runtime/src/file_ops.rs@@ -11,48 +11,8 @@ use serde::{Deserialize, Serialize};use walkdir::{DirEntry, WalkDir};/// Maximum file size that can be read (10 MB).-///-/// This is a *process* guard — it stops us slurping a huge or binary blob into memory. It is-/// not a context guard: 10 MB is on the order of 2.5 M tokens, so it never fires on the files-/// that actually blow a model's context window. `DEFAULT_READ_LINES` / `MAX_READ_CHARS` below-/// are the context guard.const MAX_READ_SIZE: u64 = 10 * 1024 * 1024;-/// Lines returned by `read_file` when the caller does not pass an explicit `limit`.-///-/// This is a *paging* size, not a refusal. An unbounded read is the easiest way for a model to-/// destroy its own context: one 100 KB source file is ~25 k tokens, which does not fit alongside-/// a system prompt in a 32 k window. When that happens the backend rejects the whole request and-/// the session dies — so reading everything at once is what makes it stop. Returning a page plus-/// `nextOffset` means the read always succeeds and the model can keep going.-const DEFAULT_READ_LINES: usize = 2000;--/// Hard ceiling on the characters `read_file` returns, applied even when `limit` is explicit.-///-/// `DEFAULT_READ_LINES` alone does not bound the payload: minified bundles, JSON blobs and-/// generated sources routinely put megabytes on a handful of lines. ~64 KB is ~16 k tokens.-///-/// That default assumes a large (200 k) context window. Against a small self-hosted backend it-/// is far too generous: two reads at this size put a request over 47 k tokens, which a 32 k-/// window rejects outright — and compaction cannot recover it, because the preserved recent-/// messages ARE the oversized tool results. Override with [`MAX_READ_CHARS_ENV_VAR`].-const DEFAULT_MAX_READ_CHARS: usize = 64 * 1024;--/// Environment override for [`DEFAULT_MAX_READ_CHARS`], in characters.-const MAX_READ_CHARS_ENV_VAR: &str = "CLAW_MAX_READ_CHARS";--/// Effective character ceiling for one `read_file` page.-///-/// Read per call rather than cached: a long-lived process should pick up a changed budget, and-/// this runs once per read, not per line.-fn max_read_chars() -> usize {- std::env::var(MAX_READ_CHARS_ENV_VAR)- .ok()- .and_then(|raw| raw.trim().parse::<usize>().ok())- .filter(|chars| *chars > 0)- .unwrap_or(DEFAULT_MAX_READ_CHARS)-}-/// Maximum file size that can be written (10 MB).const MAX_WRITE_SIZE: usize = 10 * 1024 * 1024;@@ -120,17 +80,6 @@ pub struct TextFilePayload {pub start_line: usize,#[serde(rename = "totalLines")]pub total_lines: usize,- /// True when the file has more lines past this page. Signals the caller that it has NOT seen- /// the whole file, so it does not silently reason over a partial view.- #[serde(default)]- pub truncated: bool,- /// Line index to pass back as `offset` to continue reading. Absent once the file is exhausted.- #[serde(- rename = "nextOffset",- default,- skip_serializing_if = "Option::is_none"- )]- pub next_offset: Option<usize>,}/// Output envelope for the `read_file` tool.@@ -279,28 +228,10 @@ pub fn read_file(let content = fs::read_to_string(&absolute_path)?;let lines: Vec<&str> = content.lines().collect();let start_index = offset.unwrap_or(0).min(lines.len());- // An absent `limit` pages rather than reading to EOF: see DEFAULT_READ_LINES.- let requested_end = start_index- .saturating_add(limit.unwrap_or(DEFAULT_READ_LINES))- .min(lines.len());-- // Apply the character ceiling on top of the line window, so a file with very long lines- // cannot blow the budget the line cap was meant to enforce. Always yield at least one line,- // otherwise an oversized single line would return nothing and the caller could not advance.- let mut end_index = start_index;- let mut chars = 0usize;- let char_ceiling = max_read_chars();- for line in &lines[start_index..requested_end] {- let next = chars + line.chars().count() + 1;- if next > char_ceiling && end_index > start_index {- break;- }- chars = next;- end_index += 1;- }-+ let end_index = limit.map_or(lines.len(), |limit| {+ start_index.saturating_add(limit).min(lines.len())+ });let selected = lines[start_index..end_index].join("\n");- let truncated = end_index < lines.len();Ok(ReadFileOutput {kind: String::from("text"),@@ -310,8 +241,6 @@ pub fn read_file(num_lines: end_index.saturating_sub(start_index),start_line: start_index.saturating_add(1),total_lines: lines.len(),- truncated,- next_offset: truncated.then_some(end_index),},})}@@ -883,18 +812,11 @@ mod tests {use super::{component_contains_glob, derive_glob_walk_root, edit_file, expand_braces, glob_search,- grep_search, is_symlink_escape, max_read_chars, normalize_for_comparison, read_file,+ grep_search, is_symlink_escape, normalize_for_comparison, read_file,read_file_in_workspace, write_file, write_file_in_workspace, GrepSearchInput,- DEFAULT_MAX_READ_CHARS, DEFAULT_READ_LINES, MAX_READ_CHARS_ENV_VAR, MAX_WRITE_SIZE,+ MAX_WRITE_SIZE,};- /// Serializes the tests that mutate `CLAW_MAX_READ_CHARS`; env vars are process-global.- fn env_lock() -> std::sync::MutexGuard<'static, ()> {- static LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());- LOCK.lock()- .unwrap_or_else(std::sync::PoisonError::into_inner)- }-fn temp_path(name: &str) -> std::path::PathBuf {let unique = SystemTime::now().duration_since(UNIX_EPOCH)@@ -915,132 +837,6 @@ mod tests {assert_eq!(read_output.file.content, "two");}- #[test]- fn unbounded_read_of_a_large_file_pages_instead_of_returning_everything() {- // Regression: an unbounded read used to return the whole file, which on a small-context- // backend overflows the window and the request is rejected outright — the session dies.- let path = temp_path("paged-read.txt");- let total = DEFAULT_READ_LINES + 500;- let body = (0..total)- .map(|i| format!("line {i}"))- .collect::<Vec<_>>()- .join("\n");- write_file(path.to_string_lossy().as_ref(), &body).expect("write should succeed");-- let first = read_file(path.to_string_lossy().as_ref(), None, None).expect("first page");- assert_eq!(first.file.num_lines, DEFAULT_READ_LINES);- assert_eq!(first.file.total_lines, total);- assert!(first.file.truncated, "caller must be told it is partial");- assert_eq!(first.file.next_offset, Some(DEFAULT_READ_LINES));- assert!(first.file.content.starts_with("line 0\n"));-- // The advertised next_offset must actually resume where the last page stopped.- let second = read_file(- path.to_string_lossy().as_ref(),- first.file.next_offset,- None,- )- .expect("second page");- assert_eq!(second.file.num_lines, 500);- assert!(!second.file.truncated, "the tail is the final page");- assert_eq!(second.file.next_offset, None);- assert!(second- .file- .content- .starts_with(&format!("line {DEFAULT_READ_LINES}\n")));- }-- #[test]- fn char_ceiling_bounds_files_whose_lines_are_enormous() {- // A line cap alone does not bound the payload: minified bundles put megabytes on a few- // lines, so the byte ceiling has to apply too — and must still yield forward progress.- let _guard = env_lock();- std::env::remove_var(MAX_READ_CHARS_ENV_VAR);- let path = temp_path("long-lines.txt");- let huge = "x".repeat(DEFAULT_MAX_READ_CHARS);- let body = format!("{huge}\n{huge}\n{huge}");- write_file(path.to_string_lossy().as_ref(), &body).expect("write should succeed");-- let page = read_file(path.to_string_lossy().as_ref(), None, None).expect("first page");- assert_eq!(page.file.num_lines, 1, "one oversized line still advances");- assert!(page.file.truncated);- assert_eq!(page.file.next_offset, Some(1));-- // An explicit limit must not be able to defeat the ceiling.- let greedy = read_file(path.to_string_lossy().as_ref(), None, Some(3)).expect("greedy");- assert_eq!(greedy.file.num_lines, 1);- assert!(greedy.file.truncated);- }-- /// The 64 KB default is a 200 k-context number. A small self-hosted backend must be able to- /// shrink it, or two reads overflow a 32 k window in a single turn.- #[test]- fn read_char_ceiling_is_configurable_via_the_environment() {- let _guard = env_lock();- let path = temp_path("configurable-ceiling.txt");- // 40 lines of 100 chars = ~4 KB: far under the default ceiling, over a 1 KB one.- let body = (0..40)- .map(|_| "y".repeat(100))- .collect::<Vec<_>>()- .join("\n");- write_file(path.to_string_lossy().as_ref(), &body).expect("write should succeed");-- std::env::remove_var(MAX_READ_CHARS_ENV_VAR);- let whole = read_file(path.to_string_lossy().as_ref(), None, None).expect("default read");- assert_eq!(- whole.file.num_lines, 40,- "default ceiling returns the file whole"- );- assert!(!whole.file.truncated);-- std::env::set_var(MAX_READ_CHARS_ENV_VAR, "1024");- let clipped = read_file(path.to_string_lossy().as_ref(), None, None).expect("clipped read");- std::env::remove_var(MAX_READ_CHARS_ENV_VAR);- assert!(- clipped.file.num_lines < 40,- "a smaller ceiling must actually clip, got {} lines",- clipped.file.num_lines- );- assert!(- clipped.file.truncated,- "a clipped page must report truncated"- );- assert_eq!(- clipped.file.next_offset,- Some(clipped.file.num_lines),- "the caller must be told where to resume"- );- }-- #[test]- fn read_char_ceiling_ignores_junk_and_zero_values() {- let _guard = env_lock();- for value in ["", "0", "-5", "not-a-number"] {- std::env::set_var(MAX_READ_CHARS_ENV_VAR, value);- assert_eq!(- max_read_chars(),- DEFAULT_MAX_READ_CHARS,- "{value:?} must fall back to the default rather than disabling reads"- );- }- std::env::set_var(MAX_READ_CHARS_ENV_VAR, "24000");- assert_eq!(max_read_chars(), 24_000);- std::env::remove_var(MAX_READ_CHARS_ENV_VAR);- assert_eq!(max_read_chars(), DEFAULT_MAX_READ_CHARS);- }-- #[test]- fn small_files_are_returned_whole_and_not_marked_truncated() {- let path = temp_path("small-read.txt");- write_file(path.to_string_lossy().as_ref(), "one\ntwo\nthree").expect("write");-- let output = read_file(path.to_string_lossy().as_ref(), None, None).expect("read");- assert_eq!(output.file.content, "one\ntwo\nthree");- assert_eq!(output.file.num_lines, 3);- assert!(!output.file.truncated);- assert_eq!(output.file.next_offset, None);- }-#[test]fn edits_file_contents() {let path = temp_path("edit.txt");diff --git a/rust/crates/runtime/src/prompt.rs b/rust/crates/runtime/src/prompt.rsindex ae5bf66b..98683112 100644--- a/rust/crates/runtime/src/prompt.rs+++ b/rust/crates/runtime/src/prompt.rs@@ -42,25 +42,7 @@ pub const SYSTEM_PROMPT_DYNAMIC_BOUNDARY: &str = "__SYSTEM_PROMPT_DYNAMIC_BOUNDApub const FRONTIER_MODEL_NAME: &str = "Claude Opus 4.6";const MAX_INSTRUCTION_FILE_CHARS: usize = 4_000;const MAX_TOTAL_INSTRUCTION_CHARS: usize = 12_000;-/// Character budget for the git diff snapshot embedded in the system prompt.-///-/// This lives in the *system prompt*, so its cost is paid on every session whose-/// working tree has changed — and a diff changes on essentially every edit. The-/// previous 50_000 budget was four times the entire instruction-file budget and-/// could add ~15_000 tokens to the prompt from a single modified file, which is-/// affordable against a hosted frontier model and ruinous against a local one.-///-/// Override with `CLAW_MAX_GIT_DIFF_CHARS`. `0` drops the diff snapshot entirely;-/// git status and the recent-commit list are unaffected.-const DEFAULT_MAX_GIT_DIFF_CHARS: usize = 4_000;-const MAX_GIT_DIFF_CHARS_ENV_VAR: &str = "CLAW_MAX_GIT_DIFF_CHARS";--fn max_git_diff_chars() -> usize {- std::env::var(MAX_GIT_DIFF_CHARS_ENV_VAR)- .ok()- .and_then(|value| value.trim().parse().ok())- .unwrap_or(DEFAULT_MAX_GIT_DIFF_CHARS)-}+const MAX_GIT_DIFF_CHARS: usize = 50_000;/// Neutral identity for the model family line in generated prompts.#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]@@ -516,15 +498,8 @@ fn read_git_diff(cwd: &Path) -> Option<String> {}fn truncate_diff(mut diff: String) -> String {- let budget = max_git_diff_chars();- // A zero budget means "omit the diff", not "truncate to nothing" -- returning- // an empty string here would still push an empty "Git diff snapshot:" heading- // into the prompt.- if budget == 0 {- return String::new();- }- if diff.len() > budget {- let mut end = budget;+ if diff.len() > MAX_GIT_DIFF_CHARS {+ let mut end = MAX_GIT_DIFF_CHARS;while !diff.is_char_boundary(end) {end -= 1;}@@ -783,7 +758,6 @@ fn get_simple_doing_tasks_section() -> String {"Do not add speculative abstractions, compatibility shims, or unrelated cleanup.".to_string(),"Do not create files unless they are required to complete the task.".to_string(),"If an approach fails, diagnose the failure before switching tactics.".to_string(),- "Act in the turn you plan in: when the next step is a tool call, make the call. Never end a turn describing a step you have not taken, and do not stop to ask for a go-ahead on work already requested.".to_string(),"Be careful not to introduce security vulnerabilities such as command injection, XSS, or SQL injection.".to_string(),"Report outcomes faithfully: if verification fails or was not run, say so explicitly.".to_string(),]);@@ -808,8 +782,7 @@ mod tests {collapse_blank_lines, display_context_path, normalize_instruction_content,render_instruction_content, render_instruction_files, truncate_diff,truncate_instruction_content, ContextFile, ModelFamilyIdentity, ProjectContext,- SystemPromptBuilder, DEFAULT_MAX_GIT_DIFF_CHARS, MAX_GIT_DIFF_CHARS_ENV_VAR,- SYSTEM_PROMPT_DYNAMIC_BOUNDARY,+ SystemPromptBuilder, MAX_GIT_DIFF_CHARS, SYSTEM_PROMPT_DYNAMIC_BOUNDARY,};use crate::config::ConfigLoader;use std::fs;@@ -1471,69 +1444,33 @@ mod tests {assert!(rendered.contains("Project rules"));}- /// Serializes the tests that read or mutate `CLAW_MAX_GIT_DIFF_CHARS`; env vars- /// are process-global and the default-budget tests fail if another test leaves- /// an override set.- fn diff_env_lock() -> std::sync::MutexGuard<'static, ()> {- static LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());- LOCK.lock()- .unwrap_or_else(std::sync::PoisonError::into_inner)- }-#[test]fn truncate_diff_preserves_short_content() {- let _guard = diff_env_lock();- std::env::remove_var(MAX_GIT_DIFF_CHARS_ENV_VAR);let short = "a".repeat(1_000);let result = truncate_diff(short.clone());assert_eq!(result, short);assert!(!result.contains("[diff truncated"));}- #[test]- fn truncate_diff_honors_env_override() {- let _guard = diff_env_lock();- std::env::set_var(MAX_GIT_DIFF_CHARS_ENV_VAR, "100");- let result = truncate_diff("z".repeat(1_000));- std::env::remove_var(MAX_GIT_DIFF_CHARS_ENV_VAR);- let marker = "\n\n... [diff truncated — too large for system prompt]";- assert!(result.ends_with(marker));- assert_eq!(result.len() - marker.len(), 100);- }-- #[test]- fn truncate_diff_zero_budget_omits_the_snapshot_entirely() {- // Zero must yield nothing at all -- a truncated-to-empty body would still- // drag a "Git diff snapshot:" heading and the truncation marker into the- // prompt, which is the opposite of what the operator asked for.- let _guard = diff_env_lock();- std::env::set_var(MAX_GIT_DIFF_CHARS_ENV_VAR, "0");- let result = truncate_diff("z".repeat(1_000));- std::env::remove_var(MAX_GIT_DIFF_CHARS_ENV_VAR);- assert!(result.is_empty());- }-#[test]fn truncate_diff_caps_oversized_content() {- let _guard = diff_env_lock();- std::env::remove_var(MAX_GIT_DIFF_CHARS_ENV_VAR);- let large = "x".repeat(DEFAULT_MAX_GIT_DIFF_CHARS + 5_000);+ let large = "x".repeat(MAX_GIT_DIFF_CHARS + 5_000);let result = truncate_diff(large);assert!(result.contains("... [diff truncated — too large for system prompt]"));- // The body before the marker must be at most DEFAULT_MAX_GIT_DIFF_CHARS bytes+ // The body before the marker must be at most MAX_GIT_DIFF_CHARS byteslet marker = "\n\n... [diff truncated — too large for system prompt]";let body_len = result.len() - marker.len();- assert!(body_len <= DEFAULT_MAX_GIT_DIFF_CHARS);+ assert!(body_len <= MAX_GIT_DIFF_CHARS);}#[test]fn truncate_diff_respects_utf8_char_boundaries() {- // Build a string where DEFAULT_MAX_GIT_DIFF_CHARS falls in the middle of a+ // Build a string where MAX_GIT_DIFF_CHARS falls in the middle of a// multi-byte character (U+1F600 = 4 bytes in UTF-8).- let prefix_len = DEFAULT_MAX_GIT_DIFF_CHARS - 2;+ let prefix_len = MAX_GIT_DIFF_CHARS - 2;let mut input = "a".repeat(prefix_len);// Append a 4-byte emoji so bytes [prefix_len..prefix_len+4] are the- // emoji. DEFAULT_MAX_GIT_DIFF_CHARS lands at prefix_len+2, inside the emoji.+ // emoji. MAX_GIT_DIFF_CHARS lands at prefix_len+2, inside the emoji.input.push('\u{1F600}');input.push_str(&"b".repeat(10_000));@@ -1545,7 +1482,7 @@ mod tests {// inside it would be invalid UTF-8.let marker = "\n\n... [diff truncated — too large for system prompt]";let body = &result[..result.len() - marker.len()];- assert!(body.len() <= DEFAULT_MAX_GIT_DIFF_CHARS);+ assert!(body.len() <= MAX_GIT_DIFF_CHARS);assert!(body.is_char_boundary(body.len()));}}diff --git a/rust/crates/runtime/src/session.rs b/rust/crates/runtime/src/session.rsindex 61cca8c8..2ecfd97d 100644--- a/rust/crates/runtime/src/session.rs+++ b/rust/crates/runtime/src/session.rs@@ -718,20 +718,6 @@ impl ConversationMessage {}}- /// Text the harness injected on its own initiative, not something the user typed.- ///- /// Reaches the model as an ordinary turn — the wire protocol has nowhere else to put it — but- /// stays labelled in the transcript, so a replay, an export, or a compaction summary does not- /// present the harness's own prompting back as the user's words.- #[must_use]- pub fn system_text(text: impl Into<String>) -> Self {- Self {- role: MessageRole::System,- blocks: vec![ContentBlock::Text { text: text.into() }],- usage: None,- }- }-#[must_use]pub fn assistant(blocks: Vec<ContentBlock>) -> Self {Self {diff --git a/rust/crates/runtime/src/trident.rs b/rust/crates/runtime/src/trident.rsindex 07576822..2346a4ea 100644--- a/rust/crates/runtime/src/trident.rs+++ b/rust/crates/runtime/src/trident.rs@@ -29,7 +29,7 @@ impl Default for TridentConfig {}/// Statistics from a Trident compaction run.-#[derive(Debug, Clone, PartialEq, Eq, Default)]+#[derive(Debug, Clone, PartialEq, Eq)]pub struct TridentStats {pub superseded_count: usize,pub collapsed_chains: usize,@@ -41,6 +41,21 @@ pub struct TridentStats {pub final_message_count: usize,}+impl Default for TridentStats {+ fn default() -> Self {+ Self {+ superseded_count: 0,+ collapsed_chains: 0,+ messages_collapsed: 0,+ clusters_found: 0,+ messages_clustered: 0,+ tokens_saved_estimate: 0,+ original_message_count: 0,+ final_message_count: 0,+ }+ }+}+impl TridentStats {pub fn format_report(&self) -> String {let compression = if self.final_message_count > 0 {@@ -177,7 +192,7 @@ fn stage1_supersede(messages: &[ConversationMessage]) -> (Vec<ConversationMessaglet mut obsolete_indices: BTreeSet<usize> = BTreeSet::new();- for ops in file_ops.values() {+ for (_path, ops) in &file_ops {if ops.len() < 2 {continue;}@@ -190,8 +205,10 @@ fn stage1_supersede(messages: &[ConversationMessage]) -> (Vec<ConversationMessagif let Some(last_write) = last_write_idx {for op in ops {- if op.index < last_write- && matches!(op.op_type, FileOp::Read | FileOp::Write | FileOp::Edit)+ if op.op_type == FileOp::Read && op.index < last_write {+ obsolete_indices.insert(op.index);+ } else if (op.op_type == FileOp::Write || op.op_type == FileOp::Edit)+ && op.index < last_write{obsolete_indices.insert(op.index);}@@ -308,7 +325,7 @@ fn stage2_collapse(usage: None,});} else {- result.append(&mut buffer);+ result.extend(buffer.drain(..));}buffer.clear();result.push(msg.clone());@@ -459,7 +476,7 @@ fn stage3_cluster(}let total_clustered: usize = cluster_assignments.len();- let clusters_found = cluster_id;+ let clusters_found = cluster_id as usize;let mut result: Vec<ConversationMessage> = Vec::new();let mut cluster_buffers: BTreeMap<usize, Vec<usize>> = BTreeMap::new();@@ -660,7 +677,7 @@ fn truncate_text(text: &str, max_chars: usize) -> String {mod tests {use super::*;use crate::compact::CompactionConfig;- use crate::session::{ContentBlock, ConversationMessage, Session};+ use crate::session::{ContentBlock, ConversationMessage, MessageRole, Session};#[test]fn stage1_removes_obsolete_file_reads() {@@ -719,7 +736,7 @@ mod tests {fn stage2_collapses_chatty_messages() {let mut messages = vec![];for i in 0..6 {- messages.push(ConversationMessage::user_text(format!("ok {i}")));+ messages.push(ConversationMessage::user_text(&format!("ok {i}")));messages.push(ConversationMessage::assistant(vec![ContentBlock::Text {text: format!("got {i}"),}]));@@ -750,9 +767,9 @@ mod tests {},]));messages.push(ConversationMessage::tool_result(- format!("read_{i}"),+ &format!("read_{i}"),"read_file",- format!(r#"{{"path":"src/{i}.rs","content":"data {i}"}}"#),+ &format!(r#"{{"path":"src/{i}.rs","content":"data {i}"}}"#),false,));}diff --git a/rust/crates/runtime/src/usage.rs b/rust/crates/runtime/src/usage.rsindex ceafa7d0..9241f7c2 100644--- a/rust/crates/runtime/src/usage.rs+++ b/rust/crates/runtime/src/usage.rs@@ -89,19 +89,6 @@ impl TokenUsage {+ self.cache_read_input_tokens}- /// Total tokens the provider had to read to serve this call, i.e. the live size of the- /// context window.- ///- /// `input_tokens` alone is NOT that number. With prompt caching a warm call reports- /// `input_tokens: 2` and puts the real bulk in `cache_read_input_tokens`, so anything- /// budgeting against the context window must sum all three input counters.- #[must_use]- pub fn total_input_tokens(self) -> u32 {- self.input_tokens- .saturating_add(self.cache_creation_input_tokens)- .saturating_add(self.cache_read_input_tokens)- }-#[must_use]pub fn estimate_cost_usd(self) -> UsageCostEstimate {self.estimate_cost_usd_with_pricing(ModelPricing::default_sonnet_tier())@@ -256,41 +243,6 @@ mod tests {assert_eq!(tracker.cumulative_usage().total_tokens(), 48);}- #[test]- fn total_input_tokens_includes_cached_context() {- // The shape a warm prompt-cached call actually reports: input_tokens is ~nothing and- // the real context size is in the cache counters.- let cached = TokenUsage {- input_tokens: 2,- output_tokens: 1_133,- cache_creation_input_tokens: 1_453,- cache_read_input_tokens: 111_186,- };- assert_eq!(cached.total_input_tokens(), 112_641);- // Output tokens are not part of the input budget.- assert_ne!(cached.total_input_tokens(), cached.total_tokens());-- // A backend without prompt caching reports the whole prompt as input_tokens.- let uncached = TokenUsage {- input_tokens: 29_056,- output_tokens: 73,- cache_creation_input_tokens: 0,- cache_read_input_tokens: 0,- };- assert_eq!(uncached.total_input_tokens(), 29_056);- }-- #[test]- fn total_input_tokens_saturates_instead_of_overflowing() {- let usage = TokenUsage {- input_tokens: u32::MAX,- output_tokens: 0,- cache_creation_input_tokens: u32::MAX,- cache_read_input_tokens: u32::MAX,- };- assert_eq!(usage.total_input_tokens(), u32::MAX);- }-#[test]fn computes_cost_summary_lines() {let usage = TokenUsage {diff --git a/rust/crates/rusty-claude-cli/src/main.rs b/rust/crates/rusty-claude-cli/src/main.rsindex 1de5e233..455d3189 100644--- a/rust/crates/rusty-claude-cli/src/main.rs+++ b/rust/crates/rusty-claude-cli/src/main.rs@@ -74,22 +74,6 @@ use tools::{const DEFAULT_MODEL: &str = "anthropic/claude-opus-4-7";-/// Ceiling on model/tool round trips within one turn.-///-/// `ConversationRuntime` defaults to `usize::MAX`, which for the interactive and `-p` paths means-/// no ceiling at all: a model that keeps re-reading the same file loops until the user kills it.-/// Spawned subagents have always been bounded; this gives the top-level loop the same treatment.-const DEFAULT_MAX_TURN_ITERATIONS: usize = 32;-const MAX_TURN_ITERATIONS_ENV_VAR: &str = "CLAW_MAX_TURN_ITERATIONS";--fn max_turn_iterations_from_env() -> usize {- std::env::var(MAX_TURN_ITERATIONS_ENV_VAR)- .ok()- .and_then(|raw| raw.trim().parse::<usize>().ok())- .filter(|iterations| *iterations > 0)- .unwrap_or(DEFAULT_MAX_TURN_ITERATIONS)-}-/// #148: Model provenance for `claw status` JSON/text output. Records where/// the resolved model string came from so claws don't have to re-read argv/// to audit whether their `--model` flag was honored vs falling back to env@@ -1957,7 +1941,9 @@ fn parse_args(args: &[String]) -> Result<CliAction, String> {// Only reject for known top-level subcommands that don't use compact.let first = rest[0].as_str();if is_known_top_level_subcommand(first) && first != "prompt" {- return Err("invalid_flag_value: --compact is only supported with prompt mode.\nUsage: claw --compact \"<prompt>\" or echo \"<prompt>\" | claw --compact".to_string());+ return Err(format!(+ "invalid_flag_value: --compact is only supported with prompt mode.\nUsage: claw --compact \"<prompt>\" or echo \"<prompt>\" | claw --compact"+ ));}}@@ -3161,11 +3147,10 @@ fn print_model_validation_warning_status(usage,permission_mode,context,- &StatusJsonExtras {- allowed_tools,- format_selection: Some(&format_selection),- ..StatusJsonExtras::default()- },+ None,+ None,+ allowed_tools,+ Some(&format_selection),);let object = value.as_object_mut()@@ -3241,7 +3226,9 @@ fn parse_system_prompt_args(})?;// #99: validate --date is a plausible date string (no newlines, reasonable length)if value.contains('\n') || value.contains('\r') {- return Err("invalid_flag_value: --date value contains invalid characters.\nUsage: --date <YYYY-MM-DD>".to_string());+ return Err(format!(+ "invalid_flag_value: --date value contains invalid characters.\nUsage: --date <YYYY-MM-DD>"+ ));}if value.len() > 20 {return Err(format!(@@ -3478,7 +3465,11 @@ impl DiagnosticCheck {fn json_value(&self) -> Value {// Derive a stable snake_case id from the check name for machine-readable keying (#704).- let id = self.name.to_ascii_lowercase().replace([' ', '-'], "_");+ let id = self+ .name+ .to_ascii_lowercase()+ .replace(' ', "_")+ .replace('-', "_");let mut value = Map::from_iter([("id".to_string(), Value::String(id.clone())),(@@ -6659,8 +6650,10 @@ fn run_resume_command(},default_permission_mode().as_str(),&context,- // #148: resumed sessions don't have flag provenance- &StatusJsonExtras::default(),+ None, // #148: resumed sessions don't have flag provenance+ None,+ None,+ None,)),})}@@ -6841,15 +6834,16 @@ fn run_resume_command(}SlashCommand::Plugins { action, target } => {// Only list is supported in resume mode (no runtime to reload)- if let Some(action @ ("install" | "uninstall" | "enable" | "disable" | "update")) =- action.as_deref()- {- // #777: use interactive_only: prefix + \n hint so #776's classify/split- // emits error_kind:interactive_only + non-null hint instead of unknown+null.- // Orchestrators can now detect this and switch to a live REPL instead of retrying.- return Err(format!(- "interactive_only: /plugins {action} requires a live session to reload the plugin runtime.\nStart `claw` and run `/plugins {action}` inside the REPL, or use `claw plugins {action}` as a direct CLI command."- ).into());+ match action.as_deref() {+ Some(action @ ("install" | "uninstall" | "enable" | "disable" | "update")) => {+ // #777: use interactive_only: prefix + \n hint so #776's classify/split+ // emits error_kind:interactive_only + non-null hint instead of unknown+null.+ // Orchestrators can now detect this and switch to a live REPL instead of retrying.+ return Err(format!(+ "interactive_only: /plugins {action} requires a live session to reload the plugin runtime.\nStart `claw` and run `/plugins {action}` inside the REPL, or use `claw plugins {action}` as a direct CLI command."+ ).into());+ }+ _ => {}}let cwd = env::current_dir()?;let payload = plugins_command_payload_for(@@ -7913,15 +7907,6 @@ impl LiveCli {Ok(())}Err(error) => {- // Salvage the transcript before the failed runtime is torn down.- //- // `prepare_turn_runtime` handed `run_turn` a CLONE of the session, and the turn- // mutated only that clone — appending the user message, each assistant reply, and- // a tool_result for every tool that actually executed. Dropping the clone throws- // all of that away while the side effects of those tools remain on disk, so the- // retry below would re-issue them against a session that shows no sign they ever- // ran. Adopting the clone keeps the record and the reality in step.- *self.runtime.session_mut() = runtime.session().clone();runtime.shutdown_plugins()?;// Same ownership rule as the success arm: `fail` clears the current// line, so it may only do so when the emitter stopped on a line@@ -7948,17 +7933,37 @@ impl LiveCli {// This eliminates the need for users to manually run /compact when they// hit context limits - the recovery happens automatically.//- // Detection: the API layer classified this when it still had the typed error and- // the outgoing request in hand — see `AnthropicRuntimeClient::runtime_error_from_api`.- // It is deliberately NOT re-derived from the rendered message here: compaction- // discards conversation history, and the substrings that used to gate it- // ("error decoding response body", "Failed to parse input at pos") are emitted by- // ordinary transport failures as well as by overflow, so a dropped connection cost- // the session its transcript.+ // Detection: We look for "context_window" or "Context window" in the error+ // message, which covers error types like:+ // - "context_window_blocked"+ // - "Context window blocked"+ // - "This model's maximum context length is X tokens..."// ============================================================================let error_str = error.to_string();- if error.is_context_window_failure() {+ // Detect context window overflow. Some providers (e.g. OpenAI-compat backends)+ // return 400 with "no parseable body" instead of a proper context_length_exceeded+ // error when the request is too large to even parse — treat that as context overflow too.+ // Also detect model-specific context error markers (e.g. llama.cpp returns+ // "Context size has been exceeded." / "exceed_context_size_error" / "exceeds the available context size").+ let is_context_window = error_str.contains("context_window")+ || error_str.contains("Context window")+ || error_str.contains("no parseable body")+ || error_str.contains("exceed_context_size")+ || error_str.contains("exceeds the available context size")+ || error_str+ .to_ascii_lowercase()+ .contains("context size has been exceeded");++ // Also treat "assistant stream produced no content" and reqwest decode failures+ // as recoverable errors that may benefit from auto-compaction. Some backends (e.g.+ // llama.cpp) return a non-SSE HTTP 500 body when context overflows, causing+ // reqwest to fail with "error decoding response body" — treat that as context overflow too.+ let is_no_content = error_str.contains("assistant stream produced no content")+ || error_str.contains("Failed to parse input at pos")+ || error_str.contains("error decoding response body");++ if is_context_window || is_no_content {// If the error tells us the server's actual context window, adapt our// auto-compaction threshold so future auto-compact-trigger checks are accurate.if let Some(window) = extract_context_window_tokens_from_error(&error_str) {@@ -7978,7 +7983,8 @@ impl LiveCli {let max_compact_rounds = 4;let preserve_schedule = [4, 2, 1, 0];- for (round, &preserve) in preserve_schedule.iter().enumerate() {+ for round in 0..max_compact_rounds {+ let preserve = preserve_schedule[round];println!(" Auto-compacting session (round {}/{}, preserving {} recent messages)...",round + 1,@@ -8025,11 +8031,7 @@ impl LiveCli {drop(hook_abort_monitor);let mut rp = CliPermissionPrompter::new(self.permission_mode);- // Resume, do not replay. The salvaged session already carries this turn's- // user message and every tool result that completed before the failure;- // re-running `run_turn(input, ..)` would duplicate the prompt and invite a- // second execution of tools that are not idempotent.- match new_runtime.resume_turn(Some(&mut rp)) {+ match new_runtime.run_turn(input, Some(&mut rp)) {Ok(summary) => {self.replace_runtime(new_runtime)?;if !terminal_tail.at_line_start() {@@ -8056,7 +8058,20 @@ impl LiveCli {}Err(retry_error) => {let retry_str = retry_error.to_string();- if retry_error.is_context_window_failure()+ let still_context_window = retry_str.contains("context_window")+ || retry_str.contains("Context window")+ || retry_str.contains("no parseable body")+ || retry_str.contains("exceed_context_size")+ || retry_str.contains("exceeds the available context size")+ || retry_str+ .to_ascii_lowercase()+ .contains("context size has been exceeded");+ let still_no_content = retry_str+ .contains("assistant stream produced no content")+ || retry_str.contains("Failed to parse input at pos")+ || retry_str.contains("error decoding response body");++ if (still_context_window || still_no_content)&& round + 1 < max_compact_rounds{// If the retry error reveals the context window, adapt threshold.@@ -8783,8 +8798,8 @@ impl LiveCli {let cwd = env::current_dir()?;// #803: reject flag-shaped tokens in list filter for BOTH text and JSON modes.// Previously the guard was JSON-only (#793); text mode silently returned empty success.- if action == Some("list") {- if let Some(filter) = target {+ if action.as_deref() == Some("list") {+ if let Some(filter) = target.as_deref() {if filter.starts_with('-') {if matches!(output_format, CliOutputFormat::Json) {// ROADMAP #817: this is a handled local inventory parse error.@@ -9779,49 +9794,31 @@ fn print_status_snapshot(usage,permission_mode.mode.as_str(),&context,- &StatusJsonExtras {- provenance: Some(&provenance),- permission_provenance: Some(&permission_mode),- allowed_tools,- format_selection: Some(&format_selection),- },+ Some(&provenance),+ Some(&permission_mode),+ allowed_tools,+ Some(&format_selection),))?),}Ok(())}-/// Optional provenance and selection inputs for [`status_json_value`].-///-/// Grouped into a struct rather than trailing positional parameters: they are all-/// `Option<&_>` and most callers pass `None` for most of them, which makes a-/// positional tail easy to transpose silently.-///-/// `provenance` (#148) drives the `model_source` field ("flag" | "env" | "config" |-/// "default") and `model_raw` (user input before alias resolution, or null when the-/// source is "default"). Callers without provenance (legacy resume paths) leave it-/// `None`, in which case both fields are omitted.-#[derive(Default)]-struct StatusJsonExtras<'a> {- provenance: Option<&'a ModelProvenance>,- permission_provenance: Option<&'a PermissionModeProvenance>,- allowed_tools: Option<&'a AllowedToolSet>,- format_selection: Option<&'a OutputFormatSelection>,-}-fn status_json_value(model: Option<&str>,usage: StatusUsage,permission_mode: &str,context: &StatusContext,- extras: &StatusJsonExtras<'_>,+ // #148: optional provenance for `model` field. Surfaces `model_source`+ // ("flag" | "env" | "config" | "default") and `model_raw` (user input+ // before alias resolution, or null when source is "default"). Callers+ // that don't have provenance (legacy resume paths) pass None, in which+ // case both new fields are omitted.+ provenance: Option<&ModelProvenance>,+ permission_provenance: Option<&PermissionModeProvenance>,+ allowed_tools: Option<&AllowedToolSet>,+ format_selection: Option<&OutputFormatSelection>,) -> serde_json::Value {- let StatusJsonExtras {- provenance,- permission_provenance,- allowed_tools,- format_selection,- } = *extras;// #143: top-level `status` marker so claws can distinguish// a clean run from a degraded run (config parse failed but other fields// are still populated). `config_load_error` carries the parse-error string@@ -10303,7 +10300,9 @@ fn sandbox_json_value(status: &runtime::SandboxStatus) -> serde_json::Value {// (#731: "not supported on macOS" is a degraded state, not a hard error;// filesystem_active:true means partial containment is working)// error = enabled but unsupported AND no filesystem sandbox either (nothing active)- let top_status = if !status.enabled || status.active {+ let top_status = if !status.enabled {+ "ok"+ } else if status.active {"ok"} else if status.supported {"warn"@@ -10678,20 +10677,18 @@ fn render_doctor_help_json() -> serde_json::Value {}/// #683-#692: extract structured metadata from help prose-/// Parsed fields of a help topic: usage, purpose, output description, formats,-/// related topics, aliases, local-only, requires-credentials.-type HelpMetadata = (- Option<String>,- Option<String>,- Option<String>,- Option<Vec<String>>,- Option<Vec<String>>,- Option<Vec<String>>,- bool,- bool,-);--fn extract_help_metadata(topic: LocalHelpTopic) -> HelpMetadata {+fn extract_help_metadata(+ topic: LocalHelpTopic,+) -> (+ Option<String>, // usage+ Option<String>, // purpose+ Option<String>, // output description+ Option<Vec<String>>, // formats+ Option<Vec<String>>, // related+ Option<Vec<String>>, // aliases+ bool, // local_only+ bool, // requires_credentials+) {let text = render_help_topic(topic);let mut usage = None;let mut purpose = None;@@ -12735,8 +12732,7 @@ fn build_runtime_with_plugin_state(policy,system_prompt,&feature_config,- )- .with_max_iterations(max_turn_iterations_from_env());+ );if emit_output {runtime = runtime.with_hook_progress_reporter(Box::new(CliHookProgressReporter));}@@ -13150,49 +13146,7 @@ impl ApiClient for AnthropicRuntimeClient {}}-/// How full a request must be, as a percentage of the declared context window, before an-/// unreadable failure is taken to mean the window overflowed.-const AMBIGUOUS_FAILURE_WINDOW_PERCENT: u64 = 85;--/// True when a request was close enough to the window that an otherwise unreadable failure is-/// most likely an overflow.-///-/// This is the piece that lets transport errors be classified without matching on their prose.-/// A backend can answer an oversized request with a non-SSE 500 that reqwest reports as-/// "error decoding response body"; the same string also appears when the connection simply-/// dropped. What separates them is not the text, it is whether the request we just sent had any-/// room left. Requires a declared window — with none, every request looks small and this-/// correctly returns false.-fn request_fills_context_window(request: &MessageRequest) -> bool {- let Some(limit) = api::model_token_limit(&request.model) else {- return false;- };- let estimated =- api::estimate_message_request_input_tokens(request).saturating_add(request.max_tokens);- u64::from(estimated) * 100- >= u64::from(limit.context_window_tokens) * AMBIGUOUS_FAILURE_WINDOW_PERCENT-}-impl AnthropicRuntimeClient {- /// Converts an API failure into a runtime error, carrying the overflow verdict with it.- ///- /// The verdict is made here, where the error still has its type and the request is still in- /// hand, rather than reconstructed downstream from the rendered message.- fn runtime_error_from_api(- &self,- error: &api::ApiError,- request: &MessageRequest,- ) -> RuntimeError {- let message = format_user_visible_api_error(&self.session_id, error);- if error.is_context_window_failure()- || (error.is_ambiguous_transport_failure() && request_fills_context_window(request))- {- RuntimeError::context_window(message)- } else {- RuntimeError::new(message)- }- }-/// Consume a single streaming response, optionally applying a stall/// timeout on the first event for post-tool continuations.#[allow(clippy::too_many_lines)]@@ -13205,7 +13159,9 @@ impl AnthropicRuntimeClient {.client.stream_message(message_request).await- .map_err(|error| self.runtime_error_from_api(&error, message_request))?;+ .map_err(|error| {+ RuntimeError::new(format_user_visible_api_error(&self.session_id, &error))+ })?;let mut stdout = io::stdout();let mut sink = io::sink();let mut tracked = TailTrackingWriter::new(&mut stdout, self.terminal_tail.clone());@@ -13227,8 +13183,9 @@ impl AnthropicRuntimeClient {loop {let next = if apply_stall_timeout && !received_any_event {match tokio::time::timeout(POST_TOOL_STALL_TIMEOUT, stream.next_event()).await {- Ok(inner) => inner- .map_err(|error| self.runtime_error_from_api(&error, message_request))?,+ Ok(inner) => inner.map_err(|error| {+ RuntimeError::new(format_user_visible_api_error(&self.session_id, &error))+ })?,Err(_elapsed) => {return Err(RuntimeError::new("post-tool stall: model did not respond within timeout",@@ -13236,10 +13193,9 @@ impl AnthropicRuntimeClient {}}} else {- stream- .next_event()- .await- .map_err(|error| self.runtime_error_from_api(&error, message_request))?+ stream.next_event().await.map_err(|error| {+ RuntimeError::new(format_user_visible_api_error(&self.session_id, &error))+ })?};let Some(event) = next else {@@ -13379,7 +13335,9 @@ impl AnthropicRuntimeClient {..message_request.clone()}).await- .map_err(|error| self.runtime_error_from_api(&error, message_request))?;+ .map_err(|error| {+ RuntimeError::new(format_user_visible_api_error(&self.session_id, &error))+ })?;let mut events = response_to_events(response, out)?;push_prompt_cache_record(&self.client, &mut events);Ok(events)@@ -13503,8 +13461,8 @@ fn format_context_window_blocked_error(session_id: &str, error: &api::ApiError)));lines.push(format!(" Context window {context_window_tokens} tokens"));}- api::ApiError::Api(details) => {- let detail = details.message.as_deref().unwrap_or(&details.body).trim();+ api::ApiError::Api { message, body, .. } => {+ let detail = message.as_deref().unwrap_or(body).trim();if !detail.is_empty() {lines.push(format!(" Detail {}",@@ -13514,7 +13472,7 @@ fn format_context_window_blocked_error(session_id: &str, error: &api::ApiError)}api::ApiError::RetriesExhausted { last_error, .. } => {let detail = match last_error.as_ref() {- api::ApiError::Api(details) => details.message.as_deref().unwrap_or(&details.body),+ api::ApiError::Api { message, body, .. } => message.as_deref().unwrap_or(body),other => return format_context_window_blocked_error(session_id, other),}.trim();@@ -14532,37 +14490,39 @@ fn convert_messages(messages: &[ConversationMessage]) -> Vec<InputMessage> {let content = message.blocks.iter()- .map(|block| match block {- ContentBlock::Text { text } => InputContentBlock::Text { text: text.clone() },+ .filter_map(|block| match block {+ ContentBlock::Text { text } => {+ Some(InputContentBlock::Text { text: text.clone() })+ }ContentBlock::Thinking {thinking,signature,} => {// 保留 Thinking 块:OpenAI 兼容协议会把它转成 reasoning_content 字段// 回传给 DeepSeek V4(避免 400 "reasoning_content must be passed back" 错误)- InputContentBlock::Thinking {+ Some(InputContentBlock::Thinking {thinking: thinking.clone(),signature: signature.clone(),- }+ })}- ContentBlock::ToolUse { id, name, input } => InputContentBlock::ToolUse {+ ContentBlock::ToolUse { id, name, input } => Some(InputContentBlock::ToolUse {id: id.clone(),name: name.clone(),input: serde_json::from_str(input).unwrap_or_else(|_| serde_json::json!({ "raw": input })),- },+ }),ContentBlock::ToolResult {tool_use_id,output,is_error,..- } => InputContentBlock::ToolResult {+ } => Some(InputContentBlock::ToolResult {tool_use_id: tool_use_id.clone(),content: vec![ToolResultContentBlock::Text {text: output.clone(),}],is_error: *is_error,- },+ }),}).collect::<Vec<_>>();(!content.is_empty()).then(|| InputMessage {@@ -14815,7 +14775,7 @@ mod tests {SessionLifecycleSummary, SlashCommand, StatusUsage, TerminalTail, TmuxPaneSnapshot,DEFAULT_MODEL, LATEST_SESSION_REFERENCE, STUB_COMMANDS,};- use api::{ApiError, ApiErrorDetails, MessageResponse, OutputContentBlock, Usage};+ use api::{ApiError, MessageResponse, OutputContentBlock, Usage};use plugins::{PluginManager, PluginManagerConfig, PluginTool, PluginToolDefinition, PluginToolPermission,};@@ -14860,7 +14820,7 @@ mod tests {#[test]fn opaque_provider_wrapper_surfaces_failure_class_session_and_trace() {- let error = ApiError::Api(Box::new(ApiErrorDetails {+ let error = ApiError::Api {status: "500".parse().expect("status"),error_type: Some("api_error".to_string()),message: Some(@@ -14872,7 +14832,7 @@ mod tests {retryable: true,suggested_action: None,retry_after: None,-}));+};let rendered = format_user_visible_api_error("session-issue-22", &error);assert!(rendered.contains("provider_internal"));@@ -14884,7 +14844,7 @@ mod tests {fn retry_exhaustion_uses_retry_failure_class_for_generic_provider_wrapper() {let error = ApiError::RetriesExhausted {attempts: 3,- last_error: Box::new(ApiError::Api(Box::new(ApiErrorDetails {+ last_error: Box::new(ApiError::Api {status: "502".parse().expect("status"),error_type: Some("api_error".to_string()),message: Some(@@ -14896,7 +14856,7 @@ mod tests {retryable: true,suggested_action: None,retry_after: None,-}))),+}),};let rendered = format_user_visible_api_error("session-issue-22", &error);@@ -14949,7 +14909,7 @@ mod tests {#[test]fn provider_context_window_errors_are_reframed_with_same_guidance() {- let error = ApiError::Api(Box::new(ApiErrorDetails {+ let error = ApiError::Api {status: "400".parse().expect("status"),error_type: Some("invalid_request_error".to_string()),message: Some(@@ -14961,7 +14921,7 @@ mod tests {retryable: false,suggested_action: None,retry_after: None,-}));+};let rendered = format_user_visible_api_error("session-issue-32", &error);assert!(rendered.contains("context_window_blocked"), "{rendered}");@@ -14983,7 +14943,7 @@ mod tests {#[test]fn openai_configured_limit_errors_are_rendered_as_context_window_guidance() {- let error = ApiError::Api(Box::new(ApiErrorDetails {+ let error = ApiError::Api {status: "400".parse().expect("status"),error_type: Some("invalid_request_error".to_string()),message: Some(@@ -14995,7 +14955,7 @@ mod tests {retryable: false,suggested_action: None,retry_after: None,- }));+ };let rendered = format_user_visible_api_error("session-issue-32", &error);assert!(rendered.contains("Context window blocked"), "{rendered}");@@ -15021,7 +14981,7 @@ mod tests {fn retry_wrapped_context_window_errors_keep_recovery_guidance() {let error = ApiError::RetriesExhausted {attempts: 2,- last_error: Box::new(ApiError::Api(Box::new(ApiErrorDetails {+ last_error: Box::new(ApiError::Api {status: "413".parse().expect("status"),error_type: Some("invalid_request_error".to_string()),message: Some("Request is too large for this model's context window.".to_string()),@@ -15030,7 +14990,7 @@ mod tests {retryable: false,suggested_action: None,retry_after: None,- }))),+ }),};let rendered = format_user_visible_api_error("session-issue-32", &error);@@ -15077,54 +15037,11 @@ mod tests {);}- /// Serialises tests that mutate process-global state, and isolates them from the- /// developer's real `~/.claw`.- ///- /// `parse_args` resolves defaults — notably `permissions.defaultMode` — through the- /// user-scope config, which `default_config_home()` reads from `CLAW_CONFIG_HOME`,- /// falling back to `$HOME/.claw`. Without an override, these tests therefore assert- /// against whatever the machine running them happens to have configured: a- /// `defaultMode` of `dontAsk` there resolves to `DangerFullAccess` and turns a dozen- /// `WorkspaceWrite` assertions red. Point the config home at a fresh empty directory- /// so "no user config" is the state under test, and restore the caller's value on drop.- ///- /// Tests that need a *populated* config home can still set `CLAW_CONFIG_HOME`- /// themselves after taking this guard; the guard restores the real value afterwards.- struct EnvGuard {- _lock: MutexGuard<'static, ()>,- config_home: PathBuf,- previous_config_home: Option<std::ffi::OsString>,- }-- impl Drop for EnvGuard {- fn drop(&mut self) {- match self.previous_config_home.take() {- Some(previous) => std::env::set_var("CLAW_CONFIG_HOME", previous),- None => std::env::remove_var("CLAW_CONFIG_HOME"),- }- // Best effort: a leftover temp dir must never fail a test.- let _ = std::fs::remove_dir_all(&self.config_home);- }- }-- fn env_lock() -> EnvGuard {+ fn env_lock() -> MutexGuard<'static, ()> {static LOCK: OnceLock<Mutex<()>> = OnceLock::new();- let lock = LOCK- .get_or_init(|| Mutex::new(()))+ LOCK.get_or_init(|| Mutex::new(())).lock()- .unwrap_or_else(std::sync::PoisonError::into_inner);-- // Deliberately empty: the point is that no user settings.json is discoverable.- let config_home = temp_dir();- std::fs::create_dir_all(&config_home).expect("isolated config home should be creatable");- let previous_config_home = std::env::var_os("CLAW_CONFIG_HOME");- std::env::set_var("CLAW_CONFIG_HOME", &config_home);-- EnvGuard {- _lock: lock,- config_home,- previous_config_home,- }+ .unwrap_or_else(std::sync::PoisonError::into_inner)}fn with_current_dir<T>(cwd: &Path, f: impl FnOnce() -> T) -> T {@@ -15851,8 +15768,6 @@ mod tests {#[test]fn removed_login_and_logout_subcommands_error_helpfully() {- // Asserts a `Default`-sourced permission mode, so it must not see a user config.- let _guard = env_lock();let login = parse_args(&["login".to_string()]).expect_err("login should be removed");assert!(login.contains("ANTHROPIC_API_KEY"));let logout = parse_args(&["logout".to_string()]).expect_err("logout should be removed");@@ -16480,7 +16395,10 @@ mod tests {usage,"workspace-write",&context,- &super::StatusJsonExtras::default(),+ None,+ None,+ None,+ None,);assert_eq!(json.get("status").and_then(|v| v.as_str()),@@ -16552,10 +16470,10 @@ mod tests {usage,"workspace-write",&context,- &super::StatusJsonExtras {- allowed_tools: Some(&allowed),- ..super::StatusJsonExtras::default()- },+ None,+ None,+ Some(&allowed),+ None,);assert_eq!(restricted_json@@ -16585,7 +16503,10 @@ mod tests {usage,"workspace-write",&clean_context,- &super::StatusJsonExtras::default(),+ None,+ None,+ None,+ None,);assert_eq!(clean_json.get("status").and_then(|v| v.as_str()),@@ -17533,7 +17454,7 @@ mod tests {for action in ["remove", "uninstall", "delete"] {assert_eq!(parse_args(&["skills".to_string(), action.to_string()])- .unwrap_or_else(|_| panic!("skills {action} should parse")),+ .expect(&format!("skills {action} should parse")),CliAction::Skills {args: Some(action.to_string()),output_format: CliOutputFormat::Text,@@ -18487,7 +18408,10 @@ mod tests {},"workspace-write",&context,- &super::StatusJsonExtras::default(),+ None,+ None,+ None,+ None,);assert_eq!(diff --git a/rust/crates/rusty-claude-cli/src/setup_wizard.rs b/rust/crates/rusty-claude-cli/src/setup_wizard.rsindex aa315dd6..c2f7b6ff 100644--- a/rust/crates/rusty-claude-cli/src/setup_wizard.rs+++ b/rust/crates/rusty-claude-cli/src/setup_wizard.rs@@ -2,6 +2,8 @@ use std::io::{self, IsTerminal, Write};use runtime::{save_user_provider_settings, ConfigLoader, RuntimeProviderConfig};+use serde_json;+const PROVIDERS: &[(&str, &str, &str)] = &[("1", "Anthropic", "anthropic"),("2", "xAI / Grok", "xai"),diff --git a/rust/crates/rusty-claude-cli/tests/output_format_contract.rs b/rust/crates/rusty-claude-cli/tests/output_format_contract.rsindex f620797e..8984675e 100644--- a/rust/crates/rusty-claude-cli/tests/output_format_contract.rs+++ b/rust/crates/rusty-claude-cli/tests/output_format_contract.rs@@ -451,16 +451,11 @@ fn direct_resume_safe_slash_commands_route_to_local_json_actions_831() {.output().expect("git init should launch");- // `/sandbox`'s status reflects the host's real sandbox capability, so it is the one- // entry with more than one legitimate value: "ok" where namespace isolation works,- // "warn" where it is unsupported and only the filesystem sandbox is active (#731).- // This test is about #831 routing — that these commands produce a local JSON action- // instead of `interactive_only` — not about the kernel the suite happens to run on.- for (command, expected_kind, expected_statuses) in [- ("/version", "version", &["ok"][..]),- ("/sandbox", "sandbox", &["ok", "warn"][..]),- ("/diff", "diff", &["ok"][..]),- ("/status", "status", &["ok"][..]),+ for (command, expected_kind, expected_status) in [+ ("/version", "version", "ok"),+ ("/sandbox", "sandbox", "warn"),+ ("/diff", "diff", "ok"),+ ("/status", "status", "ok"),] {let output = run_claw(&root, &["--output-format", "json", command], &[]);assert!(@@ -475,9 +470,9 @@ fn direct_resume_safe_slash_commands_route_to_local_json_actions_831() {.unwrap_or_else(|_| panic!("{command} must emit JSON (#831), got: {stdout:?}"));assert_eq!(parsed["kind"], expected_kind, "{command} kind: {parsed}");- assert!(- expected_statuses.contains(&parsed["status"].as_str().unwrap_or_default()),- "{command} status should be one of {expected_statuses:?}: {parsed}"+ assert_eq!(+ parsed["status"], expected_status,+ "{command} status: {parsed}");assert_ne!(parsed["error_kind"], "interactive_only",@@ -1012,13 +1007,13 @@ fn inventory_commands_emit_structured_json_when_requested() {assert!(!plugins.as_object()- .is_some_and(|o| o.contains_key("reload_runtime")),+ .map_or(false, |o| o.contains_key("reload_runtime")),"plugins list should not include reload_runtime");assert!(!plugins.as_object()- .is_some_and(|o| o.contains_key("target")),+ .map_or(false, |o| o.contains_key("target")),"plugins list should not include target");// #703: structured summary replaces prose message@@ -1712,13 +1707,13 @@ fn resumed_inventory_commands_emit_structured_json_when_requested() {assert!(!plugins.as_object()- .is_some_and(|o| o.contains_key("reload_runtime")),+ .map_or(false, |o| o.contains_key("reload_runtime")),"plugins list should not include reload_runtime");assert!(!plugins.as_object()- .is_some_and(|o| o.contains_key("target")),+ .map_or(false, |o| o.contains_key("target")),"plugins list should not include target");assert!(@@ -2951,7 +2946,7 @@ fn prompt_empty_arg_json_stdout_missing_prompt_823() {"claw prompt empty arg must retain abort action (#823); got: {parsed}");assert!(- parsed["hint"].as_str().is_some_and(|h| !h.is_empty()),+ parsed["hint"].as_str().map_or(false, |h| !h.is_empty()),"claw prompt empty arg missing_prompt hint must be non-empty (#823)");}@@ -2989,9 +2984,9 @@ fn flag_value_errors_have_error_kind_and_hint_756() {"invalid --reasoning-effort must be invalid_flag_value (#756): {parsed}");assert!(- parsed["hint"]- .as_str()- .is_some_and(|h| h.contains("low") || h.contains("medium") || h.contains("high")),+ parsed["hint"].as_str().map_or(false, |h| h.contains("low")+ || h.contains("medium")+ || h.contains("high")),"hint must mention valid values (#756): {parsed}");@@ -3017,7 +3012,7 @@ fn flag_value_errors_have_error_kind_and_hint_756() {"missing --model value must be missing_flag_value (#756): {parsed2}");assert!(- parsed2["hint"].as_str().is_some_and(|h| !h.is_empty()),+ parsed2["hint"].as_str().map_or(false, |h| !h.is_empty()),"missing --model hint must be non-empty (#756): {parsed2}");}@@ -3261,7 +3256,7 @@ fn short_p_flag_swallows_no_flags_755() {"flag-like token after -p must be rejected as missing_prompt (#755): {parsed2}");assert!(- parsed2["hint"].as_str().is_some_and(|h| !h.is_empty()),+ parsed2["hint"].as_str().map_or(false, |h| !h.is_empty()),"missing_prompt hint must be non-empty (#755)");}@@ -3403,7 +3398,7 @@ fn config_unsupported_section_json_hint_741() {assert!(parsed["supported_sections"].as_array()- .is_some_and(|a| !a.is_empty()),+ .map_or(false, |a| !a.is_empty()),"config {section} JSON must include supported_sections (#741)");}@@ -3460,7 +3455,7 @@ fn export_json_has_kind_702() {// On success stdout has kind:export; on failure stderr has type:error.// Either way, both envelopes must be valid JSON.let stdout = String::from_utf8_lossy(&output.stdout);- let _stderr = String::from_utf8_lossy(&output.stderr)+ let stderr = String::from_utf8_lossy(&output.stderr).lines().filter(|l| l.starts_with('{')).collect::<Vec<_>>()@@ -3552,8 +3547,8 @@ fn config_parse_error_has_typed_error_kind_and_hint_764() {!output.status.success(),"malformed settings.json should cause non-zero exit");- let _stdout = String::from_utf8_lossy(&output.stdout);- let _stderr = String::from_utf8_lossy(&output.stderr);+ let stdout = String::from_utf8_lossy(&output.stdout);+ let stderr = String::from_utf8_lossy(&output.stderr);let stdout = String::from_utf8_lossy(&output.stdout);let json_line = stdout.lines()@@ -3587,8 +3582,8 @@ fn login_logout_removed_subcommands_have_error_kind_and_hint_765() {!output.status.success(),"claw {subcmd} should exit non-zero");- let _stdout = String::from_utf8_lossy(&output.stdout);- let _stderr = String::from_utf8_lossy(&output.stderr);+ let stdout = String::from_utf8_lossy(&output.stdout);+ let stderr = String::from_utf8_lossy(&output.stderr);let stdout = String::from_utf8_lossy(&output.stdout);let json_line = stdout.lines()@@ -3727,8 +3722,8 @@ fn resume_non_slash_trailing_arg_has_typed_error_kind_and_hint_768() {!output.status.success(),"claw --resume latest compact should exit non-zero");- let _stdout = String::from_utf8_lossy(&output.stdout);- let _stderr = String::from_utf8_lossy(&output.stderr);+ let stdout = String::from_utf8_lossy(&output.stdout);+ let stderr = String::from_utf8_lossy(&output.stderr);let stdout = String::from_utf8_lossy(&output.stdout);let json_line = stdout.lines()@@ -3767,8 +3762,8 @@ fn session_with_unknown_subcommand_returns_interactive_only_not_credentials_767(!output.status.success(),"claw session {sub} should exit non-zero");- let _stdout = String::from_utf8_lossy(&output.stdout);- let _stderr = String::from_utf8_lossy(&output.stderr);+ let stdout = String::from_utf8_lossy(&output.stdout);+ let stderr = String::from_utf8_lossy(&output.stderr);let stdout = String::from_utf8_lossy(&output.stdout);let json_line = stdout.lines()@@ -3821,7 +3816,7 @@ fn slash_only_verbs_with_args_return_interactive_only_not_credentials_770() {"claw {} should exit non-zero",args.join(" "));- let _stdout = String::from_utf8_lossy(&output.stdout);+ let stdout = String::from_utf8_lossy(&output.stdout);let stderr = String::from_utf8_lossy(&output.stderr);let stdout = String::from_utf8_lossy(&output.stdout);let json_line = stdout@@ -3863,8 +3858,8 @@ fn agents_plugins_mcp_unknown_subcommand_have_hint_774() {{let output = run_claw(&root, &["--output-format", "json", "agents", "bogus"], &[]);assert!(!output.status.success(), "agents bogus should fail");- let _stdout = String::from_utf8_lossy(&output.stdout);- let _stderr = String::from_utf8_lossy(&output.stderr);+ let stdout = String::from_utf8_lossy(&output.stdout);+ let stderr = String::from_utf8_lossy(&output.stderr);let stdout = String::from_utf8_lossy(&output.stdout);let json_line = stdout.lines()@@ -3887,8 +3882,8 @@ fn agents_plugins_mcp_unknown_subcommand_have_hint_774() {{let output = run_claw(&root, &["--output-format", "json", "plugins", "bogus"], &[]);assert!(!output.status.success(), "plugins bogus should fail");- let _stdout = String::from_utf8_lossy(&output.stdout);- let _stderr = String::from_utf8_lossy(&output.stderr);+ let stdout = String::from_utf8_lossy(&output.stdout);+ let stderr = String::from_utf8_lossy(&output.stderr);let stdout = String::from_utf8_lossy(&output.stdout);let json_line = stdout.lines()@@ -3907,7 +3902,7 @@ fn agents_plugins_mcp_unknown_subcommand_have_hint_774() {{let output = run_claw(&root, &["--output-format", "json", "mcp", "bogus"], &[]);assert!(!output.status.success(), "mcp bogus should fail");- let _stdout = String::from_utf8_lossy(&output.stdout);+ let stdout = String::from_utf8_lossy(&output.stdout);let stderr = String::from_utf8_lossy(&output.stderr);let stdout = String::from_utf8_lossy(&output.stdout);let json_str = if stdout.trim().starts_with('{') {@@ -4022,7 +4017,7 @@ fn interactive_only_guard_batch_769_to_771() {"claw {} should exit non-zero",args.join(" "));- let _stdout = String::from_utf8_lossy(&output.stdout);+ let stdout = String::from_utf8_lossy(&output.stdout);let stderr = String::from_utf8_lossy(&output.stderr);let stdout = String::from_utf8_lossy(&output.stdout);let json_line = stdout@@ -4086,7 +4081,7 @@ fn resume_plugin_mutations_are_typed_interactive_only_777() {!output.status.success(),"/plugins {mutation} in resume mode should exit non-zero");- let _stdout = String::from_utf8_lossy(&output.stdout);+ let stdout = String::from_utf8_lossy(&output.stdout);let stderr = String::from_utf8_lossy(&output.stderr);let stdout = String::from_utf8_lossy(&output.stdout);let json_line = stdout@@ -4143,7 +4138,7 @@ fn resume_skills_invocation_is_typed_interactive_only_779() {!output.status.success(),"/skills <skill> in resume mode should exit non-zero");- let _stdout = String::from_utf8_lossy(&output.stdout);+ let stdout = String::from_utf8_lossy(&output.stdout);let stderr = String::from_utf8_lossy(&output.stderr);let stdout = String::from_utf8_lossy(&output.stdout);let json_line = stdout@@ -4184,8 +4179,8 @@ fn acp_unsupported_invocation_has_hint_782() {let output = run_claw(&root, &["--output-format", "json", "acp", "start"], &[]);assert!(!output.status.success(), "acp start should fail");- let _stdout = String::from_utf8_lossy(&output.stdout);- let _stderr = String::from_utf8_lossy(&output.stderr);+ let stdout = String::from_utf8_lossy(&output.stdout);+ let stderr = String::from_utf8_lossy(&output.stderr);let stdout = String::from_utf8_lossy(&output.stdout);let json_line = stdout.lines()@@ -4222,7 +4217,7 @@ fn init_json_envelope_has_hint_and_already_initialized_783() {// Fresh init — already_initialized should be false, hint should mention CLAUDE.mdlet output = run_claw(&root, &["--output-format", "json", "init"], &[]);assert!(output.status.success(), "init should succeed");- let _stdout = String::from_utf8_lossy(&output.stdout);+ let stdout = String::from_utf8_lossy(&output.stdout);let stderr = String::from_utf8_lossy(&output.stderr);let stdout = String::from_utf8_lossy(&output.stdout);let raw = if stdout.trim_start().starts_with('{') {@@ -4291,7 +4286,7 @@ fn init_json_envelope_has_hint_and_already_initialized_783() {// Idempotent re-init — already_initialized should be truelet output2 = run_claw(&root, &["--output-format", "json", "init"], &[]);assert!(output2.status.success(), "re-init should succeed");- let _stdout2 = String::from_utf8_lossy(&output2.stdout);+ let stdout2 = String::from_utf8_lossy(&output2.stdout);let stderr2 = String::from_utf8_lossy(&output2.stderr);let stdout2 = String::from_utf8_lossy(&output2.stdout);let raw2 = if stdout2.trim_start().starts_with('{') {@@ -4372,7 +4367,7 @@ fn export_arg_errors_have_typed_kind_and_hint_784() {&[],);assert!(!out1.status.success(), "--output with no value should fail");- let _stderr1 = String::from_utf8_lossy(&out1.stderr);+ let stderr1 = String::from_utf8_lossy(&out1.stderr);let stdout1 = String::from_utf8_lossy(&out1.stdout);let j1: serde_json::Value = stdout1.lines()@@ -4399,7 +4394,7 @@ fn export_arg_errors_have_typed_kind_and_hint_784() {&[],);assert!(!out2.status.success(), "extra positional should fail");- let _stderr2 = String::from_utf8_lossy(&out2.stderr);+ let stderr2 = String::from_utf8_lossy(&out2.stderr);let stdout2 = String::from_utf8_lossy(&out2.stdout);let j2: serde_json::Value = stdout2.lines()@@ -4436,7 +4431,7 @@ fn unknown_subcommand_returns_typed_kind_785() {// "dump" is close enough to "dump-manifests" to trigger the typo suggestion pathlet output = run_claw(&root, &["--output-format", "json", "dump"], &[]);assert!(!output.status.success(), "unknown subcommand should fail");- let _stderr = String::from_utf8_lossy(&output.stderr);+ let stderr = String::from_utf8_lossy(&output.stderr);let stdout = String::from_utf8_lossy(&output.stdout);let j: serde_json::Value = stdout.lines()@@ -4484,7 +4479,7 @@ fn dump_manifests_missing_dir_has_typed_kind_and_hint_786() {&[],);assert!(!out1.status.success());- let _stderr1 = String::from_utf8_lossy(&out1.stderr);+ let stderr1 = String::from_utf8_lossy(&out1.stderr);let stdout1 = String::from_utf8_lossy(&out1.stdout);let j1: serde_json::Value = stdout1.lines()@@ -4516,7 +4511,7 @@ fn dump_manifests_missing_dir_has_typed_kind_and_hint_786() {&[],);assert!(!out2.status.success());- let _stderr2 = String::from_utf8_lossy(&out2.stderr);+ let stderr2 = String::from_utf8_lossy(&out2.stderr);let stdout2 = String::from_utf8_lossy(&out2.stdout);let j2: serde_json::Value = stdout2.lines()@@ -4566,7 +4561,7 @@ fn resume_directory_path_returns_typed_kind_and_hint_787() {!output.status.success(),"resume with directory should fail");- let _stderr = String::from_utf8_lossy(&output.stderr);+ let stderr = String::from_utf8_lossy(&output.stderr);let stdout = String::from_utf8_lossy(&output.stdout);let j: serde_json::Value = stdout.lines()@@ -4616,7 +4611,7 @@ fn skills_show_not_found_emits_single_json_object_788() {assert!(!output.status.success(), "skills show unknown should fail");// Skills handler emits JSON to stdout; the duplicate was on stderr from the main error path.// After fix: stdout has 1 JSON object, stderr has none (no duplicate).- let _stdout = String::from_utf8_lossy(&output.stdout);+ let stdout = String::from_utf8_lossy(&output.stdout);let stderr = String::from_utf8_lossy(&output.stderr);let stdout = String::from_utf8_lossy(&output.stdout);@@ -4778,7 +4773,7 @@ fn system_prompt_unknown_option_returns_typed_kind_790() {&[],);assert!(!out1.status.success());- let _stderr1 = String::from_utf8_lossy(&out1.stderr);+ let stderr1 = String::from_utf8_lossy(&out1.stderr);let stdout1 = String::from_utf8_lossy(&out1.stdout);let j1: serde_json::Value = stdout1.lines()@@ -4805,7 +4800,7 @@ fn system_prompt_unknown_option_returns_typed_kind_790() {&[],);assert!(!out2.status.success());- let _stderr2 = String::from_utf8_lossy(&out2.stderr);+ let stderr2 = String::from_utf8_lossy(&out2.stderr);let stdout2 = String::from_utf8_lossy(&out2.stdout);let j2: serde_json::Value = stdout2.lines()@@ -4843,7 +4838,7 @@ fn config_extra_args_have_non_null_hint_791() {&[],);assert!(!out1.status.success());- let _stderr1 = String::from_utf8_lossy(&out1.stderr);+ let stderr1 = String::from_utf8_lossy(&out1.stderr);let stdout1 = String::from_utf8_lossy(&out1.stdout);let j1: serde_json::Value = stdout1.lines()@@ -4877,7 +4872,7 @@ fn config_extra_args_have_non_null_hint_791() {&[],);assert!(!out2.status.success());- let _stderr2 = String::from_utf8_lossy(&out2.stderr);+ let stderr2 = String::from_utf8_lossy(&out2.stderr);let stdout2 = String::from_utf8_lossy(&out2.stdout);let j2: serde_json::Value = stdout2.lines()@@ -5063,7 +5058,7 @@ fn plugins_uninstall_not_found_has_hint_793() {"plugins uninstall not-found must exit non-zero (#793)");// Error envelope goes to stderr (propagated via ? to main error handler)- let _stderr = String::from_utf8_lossy(&output.stderr);+ let stderr = String::from_utf8_lossy(&output.stderr);let stdout = String::from_utf8_lossy(&output.stdout);let j: serde_json::Value = stdout.lines()@@ -5108,7 +5103,7 @@ fn plugins_install_not_found_path_returns_typed_kind_794() {!output.status.success(),"plugins install not-found-path must exit non-zero (#794)");- let _stderr = String::from_utf8_lossy(&output.stderr);+ let stderr = String::from_utf8_lossy(&output.stderr);let stdout = String::from_utf8_lossy(&output.stdout);let j: serde_json::Value = stdout.lines()@@ -5372,7 +5367,7 @@ fn agents_create_scaffolds_toml_and_lists_locally_431() {.iter().any(|agent| {agent["name"] == "my-agent"- && Path::new(agent["path"].as_str().expect("listed agent path"))+ && PathBuf::from(agent["path"].as_str().expect("listed agent path"))== fs::canonicalize(&agent_path).expect("canonical listed agent path")}));}@@ -5497,7 +5492,7 @@ fn plugins_extra_args_have_non_null_hint_797() {!output.status.success(),"plugins show with extra arg must exit non-zero (#797)");- let _stderr = String::from_utf8_lossy(&output.stderr);+ let stderr = String::from_utf8_lossy(&output.stderr);let stdout = String::from_utf8_lossy(&output.stdout);let j: serde_json::Value = stdout.lines()@@ -5563,7 +5558,7 @@ fn plugins_list_trailing_dash_text_error_stays_on_stderr_817() {String::from_utf8_lossy(&output.stdout));let stderr = String::from_utf8_lossy(&output.stderr);- let _stdout = String::from_utf8_lossy(&output.stdout);+ let stdout = String::from_utf8_lossy(&output.stdout);assert!(stderr.contains("[error-kind: cli_parse]"), "{stderr}");assert!(stderr.contains("unknown option for `claw plugins list`: --"),@@ -5588,7 +5583,7 @@ fn empty_prompt_has_non_null_hint_798() {!output.status.success(),"empty prompt must exit non-zero (#798)");- let _stderr = String::from_utf8_lossy(&output.stderr);+ let stderr = String::from_utf8_lossy(&output.stderr);let stdout = String::from_utf8_lossy(&output.stdout);let j: serde_json::Value = stdout.lines()diff --git a/rust/crates/tools/src/lib.rs b/rust/crates/tools/src/lib.rsindex e39efd21..2ad7926a 100644--- a/rust/crates/tools/src/lib.rs+++ b/rust/crates/tools/src/lib.rs@@ -506,17 +506,13 @@ pub fn mvp_tool_specs() -> Vec<ToolSpec> {},ToolSpec {name: "read_file",- description: "Read a text file from the workspace. Large files come back one page at \- a time: if the response has \"truncated\": true you have NOT seen the \- whole file, and \"nextOffset\" is the line to pass as `offset` to \- continue. Prefer grep_search to locate what you need over paging \- through a big file, and never re-read a page you already have.",+ description: "Read a text file from the workspace.",input_schema: json!({"type": "object","properties": {"path": { "type": "string" },- "offset": { "type": "integer", "minimum": 0, "description": "First line to read (0-based). Pass the previous response's nextOffset to continue." },- "limit": { "type": "integer", "minimum": 1, "description": "Maximum lines to return. Capped by a byte ceiling regardless." }+ "offset": { "type": "integer", "minimum": 0 },+ "limit": { "type": "integer", "minimum": 1 }},"required": ["path"],"additionalProperties": false@@ -10405,12 +10401,6 @@ mod tests {#[test]fn repl_executes_python_code() {- // Resolving the python runtime reads PATH, and PATH is process-global: the PowerShell- // tests below blank it while they run. Without this guard that races and this test- // intermittently fails with "python runtime not found" on a machine that has python.- let _guard = env_lock()- .lock()- .unwrap_or_else(std::sync::PoisonError::into_inner);let result = execute_tool("REPL",&json!({"language": "python", "code": "print(1 + 1)", "timeout_ms": 500}),