Honor Claude config defaults across runtime sessions

The runtime now discovers both legacy and current Claude config files at
user and project scope, merges them in precedence order, and carries the
resolved model, permission mode, instruction files, and MCP server
configuration into session startup.

This keeps CLI defaults aligned with project policy and exposes configured
MCP tools without requiring manual flags.

Constraint: Must support both legacy .claude.json and current .claude/settings.json layouts
Constraint: Session startup must preserve CLI flag precedence over config defaults
Rejected: Read only project settings files | would ignore user-scoped defaults and MCP servers
Rejected: Delay MCP tool discovery until first tool call | model would not see configured MCP tools during planning
Confidence: high
Scope-risk: moderate
Reversibility: clean
Directive: Keep config precedence synchronized between prompt loading, session startup, and status reporting
Tested: cargo fmt --all --check; cargo clippy --workspace --all-targets --all-features -- -D warnings; cargo test --workspace --all-features
Not-tested: Live remote MCP servers and interactive REPL session startup against external services

rust/README.md

@@ -102,13 +102,6 @@ cd rust
 cargo run -p rusty-claude-cli -- --model claude-sonnet-4-20250514 prompt "List the key crates in this workspace"
 ```
 
-Restrict enabled tools in an interactive session:
-
-```bash
-cd rust
-cargo run -p rusty-claude-cli -- --allowedTools read,glob
-```
-
 ### 2) REPL mode
 
 Start the interactive shell:
@@ -130,10 +123,6 @@ Inside the REPL, useful commands include:
 /memory
 /config
 /init
-/diff
-/version
-/export notes.txt
-/session list
 /exit
 ```
 
@@ -180,10 +169,6 @@ cargo run -p rusty-claude-cli -- --resume session.json /memory /config
 - `/config [env|hooks|model]` — inspect discovered Claude config
 - `/memory` — inspect loaded instruction memory files
 - `/init` — create a starter `CLAUDE.md`
-- `/diff` — show the current git diff for the workspace
-- `/version` — print version and build metadata locally
-- `/export [file]` — export the current conversation transcript
-- `/session [list|switch <session-id>]` — inspect or switch managed local sessions
 - `/exit` — leave the REPL
 
 ## Environment variables

rust/crates/api/src/client.rs

@@ -392,52 +392,8 @@ pub fn resolve_saved_oauth_token(config: &OAuthConfig) -> Result<Option<OAuthTok
     let Some(token_set) = load_saved_oauth_token()? else {
         return Ok(None);
     };
-    resolve_saved_oauth_token_set(config, token_set).map(Some)
-}
-
-pub fn resolve_startup_auth_source<F>(load_oauth_config: F) -> Result<AuthSource, ApiError>
-where
-    F: FnOnce() -> Result<Option<OAuthConfig>, ApiError>,
-{
-    if let Some(api_key) = read_env_non_empty("ANTHROPIC_API_KEY")? {
-        return match read_env_non_empty("ANTHROPIC_AUTH_TOKEN")? {
-            Some(bearer_token) => Ok(AuthSource::ApiKeyAndBearer {
-                api_key,
-                bearer_token,
-            }),
-            None => Ok(AuthSource::ApiKey(api_key)),
-        };
-    }
-    if let Some(bearer_token) = read_env_non_empty("ANTHROPIC_AUTH_TOKEN")? {
-        return Ok(AuthSource::BearerToken(bearer_token));
-    }
-
-    let Some(token_set) = load_saved_oauth_token()? else {
-        return Err(ApiError::MissingApiKey);
-    };
     if !oauth_token_is_expired(&token_set) {
-        return Ok(AuthSource::BearerToken(token_set.access_token));
+        return Ok(Some(token_set));
-    }
-    if token_set.refresh_token.is_none() {
-        return Err(ApiError::ExpiredOAuthToken);
-    }
-
-    let Some(config) = load_oauth_config()? else {
-        return Err(ApiError::Auth(
-            "saved OAuth token is expired; runtime OAuth config is missing".to_string(),
-        ));
-    };
-    Ok(AuthSource::from(resolve_saved_oauth_token_set(
-        &config, token_set,
-    )?))
-}
-
-fn resolve_saved_oauth_token_set(
-    config: &OAuthConfig,
-    token_set: OAuthTokenSet,
-) -> Result<OAuthTokenSet, ApiError> {
-    if !oauth_token_is_expired(&token_set) {
-        return Ok(token_set);
     }
     let Some(refresh_token) = token_set.refresh_token.clone() else {
         return Err(ApiError::ExpiredOAuthToken);
@@ -447,28 +403,18 @@ fn resolve_saved_oauth_token_set(
         client
             .refresh_oauth_token(
                 config,
-                &OAuthRefreshRequest::from_config(
+                &OAuthRefreshRequest::from_config(config, refresh_token, Some(token_set.scopes)),
-                    config,
-                    refresh_token,
-                    Some(token_set.scopes.clone()),
-                ),
             )
             .await
     })?;
-    let resolved = OAuthTokenSet {
-        access_token: refreshed.access_token,
-        refresh_token: refreshed.refresh_token.or(token_set.refresh_token),
-        expires_at: refreshed.expires_at,
-        scopes: refreshed.scopes,
-    };
     save_oauth_credentials(&runtime::OAuthTokenSet {
-        access_token: resolved.access_token.clone(),
+        access_token: refreshed.access_token.clone(),
-        refresh_token: resolved.refresh_token.clone(),
+        refresh_token: refreshed.refresh_token.clone(),
-        expires_at: resolved.expires_at,
+        expires_at: refreshed.expires_at,
-        scopes: resolved.scopes.clone(),
+        scopes: refreshed.scopes.clone(),
     })
     .map_err(ApiError::from)?;
-    Ok(resolved)
+    Ok(Some(refreshed))
 }
 
 fn client_runtime_block_on<F, T>(future: F) -> Result<T, ApiError>
@@ -625,8 +571,8 @@ mod tests {
     use runtime::{clear_oauth_credentials, save_oauth_credentials, OAuthConfig};
 
     use crate::client::{
-        now_unix_timestamp, oauth_token_is_expired, resolve_saved_oauth_token,
+        now_unix_timestamp, oauth_token_is_expired, resolve_saved_oauth_token, AnthropicClient,
-        resolve_startup_auth_source, AnthropicClient, AuthSource, OAuthTokenSet,
+        AuthSource, OAuthTokenSet,
     };
     use crate::types::{ContentBlockDelta, MessageRequest};
 
@@ -814,95 +760,6 @@ mod tests {
         std::fs::remove_dir_all(config_home).expect("cleanup temp dir");
     }
 
-    #[test]
-    fn resolve_startup_auth_source_uses_saved_oauth_without_loading_config() {
-        let _guard = env_lock();
-        let config_home = temp_config_home();
-        std::env::set_var("CLAUDE_CONFIG_HOME", &config_home);
-        std::env::remove_var("ANTHROPIC_AUTH_TOKEN");
-        std::env::remove_var("ANTHROPIC_API_KEY");
-        save_oauth_credentials(&runtime::OAuthTokenSet {
-            access_token: "saved-access-token".to_string(),
-            refresh_token: Some("refresh".to_string()),
-            expires_at: Some(now_unix_timestamp() + 300),
-            scopes: vec!["scope:a".to_string()],
-        })
-        .expect("save oauth credentials");
-
-        let auth = resolve_startup_auth_source(|| panic!("config should not be loaded"))
-            .expect("startup auth");
-        assert_eq!(auth.bearer_token(), Some("saved-access-token"));
-
-        clear_oauth_credentials().expect("clear credentials");
-        std::env::remove_var("CLAUDE_CONFIG_HOME");
-        std::fs::remove_dir_all(config_home).expect("cleanup temp dir");
-    }
-
-    #[test]
-    fn resolve_startup_auth_source_errors_when_refreshable_token_lacks_config() {
-        let _guard = env_lock();
-        let config_home = temp_config_home();
-        std::env::set_var("CLAUDE_CONFIG_HOME", &config_home);
-        std::env::remove_var("ANTHROPIC_AUTH_TOKEN");
-        std::env::remove_var("ANTHROPIC_API_KEY");
-        save_oauth_credentials(&runtime::OAuthTokenSet {
-            access_token: "expired-access-token".to_string(),
-            refresh_token: Some("refresh-token".to_string()),
-            expires_at: Some(1),
-            scopes: vec!["scope:a".to_string()],
-        })
-        .expect("save expired oauth credentials");
-
-        let error =
-            resolve_startup_auth_source(|| Ok(None)).expect_err("missing config should error");
-        assert!(
-            matches!(error, crate::error::ApiError::Auth(message) if message.contains("runtime OAuth config is missing"))
-        );
-
-        let stored = runtime::load_oauth_credentials()
-            .expect("load stored credentials")
-            .expect("stored token set");
-        assert_eq!(stored.access_token, "expired-access-token");
-        assert_eq!(stored.refresh_token.as_deref(), Some("refresh-token"));
-
-        clear_oauth_credentials().expect("clear credentials");
-        std::env::remove_var("CLAUDE_CONFIG_HOME");
-        std::fs::remove_dir_all(config_home).expect("cleanup temp dir");
-    }
-
-    #[test]
-    fn resolve_saved_oauth_token_preserves_refresh_token_when_refresh_response_omits_it() {
-        let _guard = env_lock();
-        let config_home = temp_config_home();
-        std::env::set_var("CLAUDE_CONFIG_HOME", &config_home);
-        std::env::remove_var("ANTHROPIC_AUTH_TOKEN");
-        std::env::remove_var("ANTHROPIC_API_KEY");
-        save_oauth_credentials(&runtime::OAuthTokenSet {
-            access_token: "expired-access-token".to_string(),
-            refresh_token: Some("refresh-token".to_string()),
-            expires_at: Some(1),
-            scopes: vec!["scope:a".to_string()],
-        })
-        .expect("save expired oauth credentials");
-
-        let token_url = spawn_token_server(
-            "{\"access_token\":\"refreshed-token\",\"expires_at\":9999999999,\"scopes\":[\"scope:a\"]}",
-        );
-        let resolved = resolve_saved_oauth_token(&sample_oauth_config(token_url))
-            .expect("resolve refreshed token")
-            .expect("token set present");
-        assert_eq!(resolved.access_token, "refreshed-token");
-        assert_eq!(resolved.refresh_token.as_deref(), Some("refresh-token"));
-        let stored = runtime::load_oauth_credentials()
-            .expect("load stored credentials")
-            .expect("stored token set");
-        assert_eq!(stored.refresh_token.as_deref(), Some("refresh-token"));
-
-        clear_oauth_credentials().expect("clear credentials");
-        std::env::remove_var("CLAUDE_CONFIG_HOME");
-        std::fs::remove_dir_all(config_home).expect("cleanup temp dir");
-    }
-
     #[test]
     fn message_request_stream_helper_sets_stream_true() {
         let request = MessageRequest {
@@ -912,7 +769,6 @@ mod tests {
             system: None,
             tools: None,
             tool_choice: None,
-            thinking: None,
             stream: false,
         };
 

rust/crates/api/src/lib.rs

@@ -4,8 +4,8 @@ mod sse;
 mod types;
 
 pub use client::{
-    oauth_token_is_expired, resolve_saved_oauth_token, resolve_startup_auth_source,
+    oauth_token_is_expired, resolve_saved_oauth_token, AnthropicClient, AuthSource, MessageStream,
-    AnthropicClient, AuthSource, MessageStream, OAuthTokenSet,
+    OAuthTokenSet,
 };
 pub use error::ApiError;
 pub use sse::{parse_frame, SseParser};
@@ -13,5 +13,5 @@ pub use types::{
     ContentBlockDelta, ContentBlockDeltaEvent, ContentBlockStartEvent, ContentBlockStopEvent,
     InputContentBlock, InputMessage, MessageDelta, MessageDeltaEvent, MessageRequest,
     MessageResponse, MessageStartEvent, MessageStopEvent, OutputContentBlock, StreamEvent,
-    ThinkingConfig, ToolChoice, ToolDefinition, ToolResultContentBlock, Usage,
+    ToolChoice, ToolDefinition, ToolResultContentBlock, Usage,
 };

rust/crates/api/src/types.rs

@@ -12,8 +12,6 @@ pub struct MessageRequest {
     pub tools: Option<Vec<ToolDefinition>>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub tool_choice: Option<ToolChoice>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub thinking: Option<ThinkingConfig>,
     #[serde(default, skip_serializing_if = "std::ops::Not::not")]
     pub stream: bool,
 }
@@ -26,23 +24,6 @@ impl MessageRequest {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct ThinkingConfig {
-    #[serde(rename = "type")]
-    pub kind: String,
-    pub budget_tokens: u32,
-}
-
-impl ThinkingConfig {
-    #[must_use]
-    pub fn enabled(budget_tokens: u32) -> Self {
-        Self {
-            kind: "enabled".to_string(),
-            budget_tokens,
-        }
-    }
-}
-
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct InputMessage {
     pub role: String,
@@ -149,11 +130,6 @@ pub enum OutputContentBlock {
     Text {
         text: String,
     },
-    Thinking {
-        thinking: String,
-        #[serde(default, skip_serializing_if = "Option::is_none")]
-        signature: Option<String>,
-    },
     ToolUse {
         id: String,
         name: String,
@@ -213,8 +189,6 @@ pub struct ContentBlockDeltaEvent {
 #[serde(tag = "type", rename_all = "snake_case")]
 pub enum ContentBlockDelta {
     TextDelta { text: String },
-    ThinkingDelta { thinking: String },
-    SignatureDelta { signature: String },
     InputJsonDelta { partial_json: String },
 }
 

rust/crates/api/tests/client_integration.rs

@@ -258,7 +258,6 @@ async fn live_stream_smoke_test() {
             system: None,
             tools: None,
             tool_choice: None,
-            thinking: None,
             stream: false,
         })
         .await
@@ -439,7 +438,6 @@ fn sample_request(stream: bool) -> MessageRequest {
             }),
         }]),
         tool_choice: Some(ToolChoice::Auto),
-        thinking: None,
         stream,
     }
 }

rust/crates/commands/src/lib.rs

@@ -57,12 +57,6 @@ const SLASH_COMMAND_SPECS: &[SlashCommandSpec] = &[
         argument_hint: None,
         resume_supported: true,
     },
-    SlashCommandSpec {
-        name: "thinking",
-        summary: "Show or toggle extended thinking",
-        argument_hint: Some("[on|off]"),
-        resume_supported: false,
-    },
     SlashCommandSpec {
         name: "model",
         summary: "Show or switch the active model",
@@ -142,9 +136,6 @@ pub enum SlashCommand {
     Help,
     Status,
     Compact,
-    Thinking {
-        enabled: Option<bool>,
-    },
     Model {
         model: Option<String>,
     },
@@ -189,13 +180,6 @@ impl SlashCommand {
             "help" => Self::Help,
             "status" => Self::Status,
             "compact" => Self::Compact,
-            "thinking" => Self::Thinking {
-                enabled: match parts.next() {
-                    Some("on") => Some(true),
-                    Some("off") => Some(false),
-                    Some(_) | None => None,
-                },
-            },
             "model" => Self::Model {
                 model: parts.next().map(ToOwned::to_owned),
             },
@@ -295,7 +279,6 @@ pub fn handle_slash_command(
             session: session.clone(),
         }),
         SlashCommand::Status
-        | SlashCommand::Thinking { .. }
         | SlashCommand::Model { .. }
         | SlashCommand::Permissions { .. }
         | SlashCommand::Clear { .. }
@@ -324,22 +307,6 @@ mod tests {
     fn parses_supported_slash_commands() {
         assert_eq!(SlashCommand::parse("/help"), Some(SlashCommand::Help));
         assert_eq!(SlashCommand::parse(" /status "), Some(SlashCommand::Status));
-        assert_eq!(
-            SlashCommand::parse("/thinking on"),
-            Some(SlashCommand::Thinking {
-                enabled: Some(true),
-            })
-        );
-        assert_eq!(
-            SlashCommand::parse("/thinking off"),
-            Some(SlashCommand::Thinking {
-                enabled: Some(false),
-            })
-        );
-        assert_eq!(
-            SlashCommand::parse("/thinking"),
-            Some(SlashCommand::Thinking { enabled: None })
-        );
         assert_eq!(
             SlashCommand::parse("/model claude-opus"),
             Some(SlashCommand::Model {
@@ -407,7 +374,6 @@ mod tests {
         assert!(help.contains("/help"));
         assert!(help.contains("/status"));
         assert!(help.contains("/compact"));
-        assert!(help.contains("/thinking [on|off]"));
         assert!(help.contains("/model [model]"));
         assert!(help.contains("/permissions [read-only|workspace-write|danger-full-access]"));
         assert!(help.contains("/clear [--confirm]"));
@@ -420,7 +386,7 @@ mod tests {
         assert!(help.contains("/version"));
         assert!(help.contains("/export [file]"));
         assert!(help.contains("/session [list|switch <session-id>]"));
-        assert_eq!(slash_command_specs().len(), 16);
+        assert_eq!(slash_command_specs().len(), 15);
         assert_eq!(resume_supported_slash_commands().len(), 11);
     }
 
@@ -468,9 +434,6 @@ mod tests {
         let session = Session::new();
         assert!(handle_slash_command("/unknown", &session, CompactionConfig::default()).is_none());
         assert!(handle_slash_command("/status", &session, CompactionConfig::default()).is_none());
-        assert!(
-            handle_slash_command("/thinking on", &session, CompactionConfig::default()).is_none()
-        );
         assert!(
             handle_slash_command("/model claude", &session, CompactionConfig::default()).is_none()
         );

rust/crates/runtime/src/compact.rs

@@ -130,7 +130,7 @@ fn summarize_messages(messages: &[ConversationMessage]) -> String {
         .filter_map(|block| match block {
             ContentBlock::ToolUse { name, .. } => Some(name.as_str()),
             ContentBlock::ToolResult { tool_name, .. } => Some(tool_name.as_str()),
-            ContentBlock::Text { .. } | ContentBlock::Thinking { .. } => None,
+            ContentBlock::Text { .. } => None,
         })
         .collect::<Vec<_>>();
     tool_names.sort_unstable();
@@ -200,7 +200,6 @@ fn summarize_messages(messages: &[ConversationMessage]) -> String {
 fn summarize_block(block: &ContentBlock) -> String {
     let raw = match block {
         ContentBlock::Text { text } => text.clone(),
-        ContentBlock::Thinking { text, .. } => format!("thinking: {text}"),
         ContentBlock::ToolUse { name, input, .. } => format!("tool_use {name}({input})"),
         ContentBlock::ToolResult {
             tool_name,
@@ -259,7 +258,7 @@ fn collect_key_files(messages: &[ConversationMessage]) -> Vec<String> {
         .iter()
         .flat_map(|message| message.blocks.iter())
         .map(|block| match block {
-            ContentBlock::Text { text } | ContentBlock::Thinking { text, .. } => text.as_str(),
+            ContentBlock::Text { text } => text.as_str(),
             ContentBlock::ToolUse { input, .. } => input.as_str(),
             ContentBlock::ToolResult { output, .. } => output.as_str(),
         })
@@ -281,15 +280,10 @@ fn infer_current_work(messages: &[ConversationMessage]) -> Option<String> {
 
 fn first_text_block(message: &ConversationMessage) -> Option<&str> {
     message.blocks.iter().find_map(|block| match block {
-        ContentBlock::Text { text } | ContentBlock::Thinking { text, .. }
+        ContentBlock::Text { text } if !text.trim().is_empty() => Some(text.as_str()),
-            if !text.trim().is_empty() =>
-        {
-            Some(text.as_str())
-        }
         ContentBlock::ToolUse { .. }
         | ContentBlock::ToolResult { .. }
-        | ContentBlock::Text { .. }
+        | ContentBlock::Text { .. } => None,
-        | ContentBlock::Thinking { .. } => None,
     })
 }
 
@@ -334,7 +328,7 @@ fn estimate_message_tokens(message: &ConversationMessage) -> usize {
         .blocks
         .iter()
         .map(|block| match block {
-            ContentBlock::Text { text } | ContentBlock::Thinking { text, .. } => text.len() / 4 + 1,
+            ContentBlock::Text { text } => text.len() / 4 + 1,
             ContentBlock::ToolUse { name, input, .. } => (name.len() + input.len()) / 4 + 1,
             ContentBlock::ToolResult {
                 tool_name, output, ..

rust/crates/runtime/src/conversation.rs

@@ -17,8 +17,6 @@ pub struct ApiRequest {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum AssistantEvent {
     TextDelta(String),
-    ThinkingDelta(String),
-    ThinkingSignature(String),
     ToolUse {
         id: String,
         name: String,
@@ -249,26 +247,15 @@ fn build_assistant_message(
     events: Vec<AssistantEvent>,
 ) -> Result<(ConversationMessage, Option<TokenUsage>), RuntimeError> {
     let mut text = String::new();
-    let mut thinking = String::new();
-    let mut thinking_signature: Option<String> = None;
     let mut blocks = Vec::new();
     let mut finished = false;
     let mut usage = None;
 
     for event in events {
         match event {
-            AssistantEvent::TextDelta(delta) => {
+            AssistantEvent::TextDelta(delta) => text.push_str(&delta),
-                flush_thinking_block(&mut thinking, &mut thinking_signature, &mut blocks);
-                text.push_str(&delta);
-            }
-            AssistantEvent::ThinkingDelta(delta) => {
-                flush_text_block(&mut text, &mut blocks);
-                thinking.push_str(&delta);
-            }
-            AssistantEvent::ThinkingSignature(signature) => thinking_signature = Some(signature),
             AssistantEvent::ToolUse { id, name, input } => {
                 flush_text_block(&mut text, &mut blocks);
-                flush_thinking_block(&mut thinking, &mut thinking_signature, &mut blocks);
                 blocks.push(ContentBlock::ToolUse { id, name, input });
             }
             AssistantEvent::Usage(value) => usage = Some(value),
@@ -279,7 +266,6 @@ fn build_assistant_message(
     }
 
     flush_text_block(&mut text, &mut blocks);
-    flush_thinking_block(&mut thinking, &mut thinking_signature, &mut blocks);
 
     if !finished {
         return Err(RuntimeError::new(
@@ -304,19 +290,6 @@ fn flush_text_block(text: &mut String, blocks: &mut Vec<ContentBlock>) {
     }
 }
 
-fn flush_thinking_block(
-    thinking: &mut String,
-    signature: &mut Option<String>,
-    blocks: &mut Vec<ContentBlock>,
-) {
-    if !thinking.is_empty() || signature.is_some() {
-        blocks.push(ContentBlock::Thinking {
-            text: std::mem::take(thinking),
-            signature: signature.take(),
-        });
-    }
-}
-
 type ToolHandler = Box<dyn FnMut(&str) -> Result<String, ToolError>>;
 
 #[derive(Default)]
@@ -352,8 +325,8 @@ impl ToolExecutor for StaticToolExecutor {
 #[cfg(test)]
 mod tests {
     use super::{
-        build_assistant_message, ApiClient, ApiRequest, AssistantEvent, ConversationRuntime,
+        ApiClient, ApiRequest, AssistantEvent, ConversationRuntime, RuntimeError,
-        RuntimeError, StaticToolExecutor,
+        StaticToolExecutor,
     };
     use crate::compact::CompactionConfig;
     use crate::permissions::{
@@ -435,7 +408,7 @@ mod tests {
                 .sum::<i32>();
             Ok(total.to_string())
         });
-        let permission_policy = PermissionPolicy::new(PermissionMode::WorkspaceWrite);
+        let permission_policy = PermissionPolicy::new(PermissionMode::Prompt);
         let system_prompt = SystemPromptBuilder::new()
             .with_project_context(ProjectContext {
                 cwd: PathBuf::from("/tmp/project"),
@@ -514,7 +487,7 @@ mod tests {
             Session::new(),
             SingleCallApiClient,
             StaticToolExecutor::new(),
-            PermissionPolicy::new(PermissionMode::WorkspaceWrite),
+            PermissionPolicy::new(PermissionMode::Prompt),
             vec!["system".to_string()],
         );
 
@@ -529,29 +502,6 @@ mod tests {
         ));
     }
 
-    #[test]
-    fn thinking_blocks_are_preserved_separately_from_text() {
-        let (message, usage) = build_assistant_message(vec![
-            AssistantEvent::ThinkingDelta("first ".to_string()),
-            AssistantEvent::ThinkingDelta("second".to_string()),
-            AssistantEvent::ThinkingSignature("sig-1".to_string()),
-            AssistantEvent::TextDelta("final".to_string()),
-            AssistantEvent::MessageStop,
-        ])
-        .expect("assistant message should build");
-
-        assert_eq!(usage, None);
-        assert!(matches!(
-            &message.blocks[0],
-            ContentBlock::Thinking { text, signature }
-                if text == "first second" && signature.as_deref() == Some("sig-1")
-        ));
-        assert!(matches!(
-            &message.blocks[1],
-            ContentBlock::Text { text } if text == "final"
-        ));
-    }
-
     #[test]
     fn reconstructs_usage_tracker_from_restored_session() {
         struct SimpleApi;
@@ -586,7 +536,7 @@ mod tests {
             session,
             SimpleApi,
             StaticToolExecutor::new(),
-            PermissionPolicy::new(PermissionMode::DangerFullAccess),
+            PermissionPolicy::new(PermissionMode::Allow),
             vec!["system".to_string()],
         );
 
@@ -613,7 +563,7 @@ mod tests {
             Session::new(),
             SimpleApi,
             StaticToolExecutor::new(),
-            PermissionPolicy::new(PermissionMode::DangerFullAccess),
+            PermissionPolicy::new(PermissionMode::Allow),
             vec!["system".to_string()],
         );
         runtime.run_turn("a", None).expect("turn a");

rust/crates/runtime/src/permissions.rs

@@ -1,29 +1,16 @@
 use std::collections::BTreeMap;
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum PermissionMode {
-    ReadOnly,
+    Allow,
-    WorkspaceWrite,
+    Deny,
-    DangerFullAccess,
+    Prompt,
-}
-
-impl PermissionMode {
-    #[must_use]
-    pub fn as_str(self) -> &'static str {
-        match self {
-            Self::ReadOnly => "read-only",
-            Self::WorkspaceWrite => "workspace-write",
-            Self::DangerFullAccess => "danger-full-access",
-        }
-    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct PermissionRequest {
     pub tool_name: String,
     pub input: String,
-    pub current_mode: PermissionMode,
-    pub required_mode: PermissionMode,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -44,41 +31,31 @@ pub enum PermissionOutcome {
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct PermissionPolicy {
-    active_mode: PermissionMode,
+    default_mode: PermissionMode,
-    tool_requirements: BTreeMap<String, PermissionMode>,
+    tool_modes: BTreeMap<String, PermissionMode>,
 }
 
 impl PermissionPolicy {
     #[must_use]
-    pub fn new(active_mode: PermissionMode) -> Self {
+    pub fn new(default_mode: PermissionMode) -> Self {
         Self {
-            active_mode,
+            default_mode,
-            tool_requirements: BTreeMap::new(),
+            tool_modes: BTreeMap::new(),
         }
     }
 
     #[must_use]
-    pub fn with_tool_requirement(
+    pub fn with_tool_mode(mut self, tool_name: impl Into<String>, mode: PermissionMode) -> Self {
-        mut self,
+        self.tool_modes.insert(tool_name.into(), mode);
-        tool_name: impl Into<String>,
-        required_mode: PermissionMode,
-    ) -> Self {
-        self.tool_requirements
-            .insert(tool_name.into(), required_mode);
         self
     }
 
     #[must_use]
-    pub fn active_mode(&self) -> PermissionMode {
+    pub fn mode_for(&self, tool_name: &str) -> PermissionMode {
-        self.active_mode
+        self.tool_modes
-    }
-
-    #[must_use]
-    pub fn required_mode_for(&self, tool_name: &str) -> PermissionMode {
-        self.tool_requirements
             .get(tool_name)
             .copied()
-            .unwrap_or(PermissionMode::DangerFullAccess)
+            .unwrap_or(self.default_mode)
     }
 
     #[must_use]
@@ -88,43 +65,23 @@ impl PermissionPolicy {
         input: &str,
         mut prompter: Option<&mut dyn PermissionPrompter>,
     ) -> PermissionOutcome {
-        let current_mode = self.active_mode();
+        match self.mode_for(tool_name) {
-        let required_mode = self.required_mode_for(tool_name);
+            PermissionMode::Allow => PermissionOutcome::Allow,
-        if current_mode >= required_mode {
+            PermissionMode::Deny => PermissionOutcome::Deny {
-            return PermissionOutcome::Allow;
+                reason: format!("tool '{tool_name}' denied by permission policy"),
-        }
+            },
-
+            PermissionMode::Prompt => match prompter.as_mut() {
-        let request = PermissionRequest {
+                Some(prompter) => match prompter.decide(&PermissionRequest {
-            tool_name: tool_name.to_string(),
+                    tool_name: tool_name.to_string(),
-            input: input.to_string(),
+                    input: input.to_string(),
-            current_mode,
+                }) {
-            required_mode,
-        };
-
-        if current_mode == PermissionMode::WorkspaceWrite
-            && required_mode == PermissionMode::DangerFullAccess
-        {
-            return match prompter.as_mut() {
-                Some(prompter) => match prompter.decide(&request) {
                     PermissionPromptDecision::Allow => PermissionOutcome::Allow,
                     PermissionPromptDecision::Deny { reason } => PermissionOutcome::Deny { reason },
                 },
                 None => PermissionOutcome::Deny {
-                    reason: format!(
+                    reason: format!("tool '{tool_name}' requires interactive approval"),
-                        "tool '{tool_name}' requires approval to escalate from {} to {}",
-                        current_mode.as_str(),
-                        required_mode.as_str()
-                    ),
                 },
-            };
+            },
-        }
-
-        PermissionOutcome::Deny {
-            reason: format!(
-                "tool '{tool_name}' requires {} permission; current mode is {}",
-                required_mode.as_str(),
-                current_mode.as_str()
-            ),
         }
     }
 }
@@ -136,92 +93,25 @@ mod tests {
         PermissionPrompter, PermissionRequest,
     };
 
-    struct RecordingPrompter {
+    struct AllowPrompter;
-        seen: Vec<PermissionRequest>,
-        allow: bool,
-    }
 
-    impl PermissionPrompter for RecordingPrompter {
+    impl PermissionPrompter for AllowPrompter {
         fn decide(&mut self, request: &PermissionRequest) -> PermissionPromptDecision {
-            self.seen.push(request.clone());
+            assert_eq!(request.tool_name, "bash");
-            if self.allow {
+            PermissionPromptDecision::Allow
-                PermissionPromptDecision::Allow
-            } else {
-                PermissionPromptDecision::Deny {
-                    reason: "not now".to_string(),
-                }
-            }
         }
     }
 
     #[test]
-    fn allows_tools_when_active_mode_meets_requirement() {
+    fn uses_tool_specific_overrides() {
-        let policy = PermissionPolicy::new(PermissionMode::WorkspaceWrite)
+        let policy = PermissionPolicy::new(PermissionMode::Deny)
-            .with_tool_requirement("read_file", PermissionMode::ReadOnly)
+            .with_tool_mode("bash", PermissionMode::Prompt);
-            .with_tool_requirement("write_file", PermissionMode::WorkspaceWrite);
-
-        assert_eq!(
-            policy.authorize("read_file", "{}", None),
-            PermissionOutcome::Allow
-        );
-        assert_eq!(
-            policy.authorize("write_file", "{}", None),
-            PermissionOutcome::Allow
-        );
-    }
-
-    #[test]
-    fn denies_read_only_escalations_without_prompt() {
-        let policy = PermissionPolicy::new(PermissionMode::ReadOnly)
-            .with_tool_requirement("write_file", PermissionMode::WorkspaceWrite)
-            .with_tool_requirement("bash", PermissionMode::DangerFullAccess);
-
-        assert!(matches!(
-            policy.authorize("write_file", "{}", None),
-            PermissionOutcome::Deny { reason } if reason.contains("requires workspace-write permission")
-        ));
-        assert!(matches!(
-            policy.authorize("bash", "{}", None),
-            PermissionOutcome::Deny { reason } if reason.contains("requires danger-full-access permission")
-        ));
-    }
-
-    #[test]
-    fn prompts_for_workspace_write_to_danger_full_access_escalation() {
-        let policy = PermissionPolicy::new(PermissionMode::WorkspaceWrite)
-            .with_tool_requirement("bash", PermissionMode::DangerFullAccess);
-        let mut prompter = RecordingPrompter {
-            seen: Vec::new(),
-            allow: true,
-        };
-
-        let outcome = policy.authorize("bash", "echo hi", Some(&mut prompter));
 
+        let outcome = policy.authorize("bash", "echo hi", Some(&mut AllowPrompter));
         assert_eq!(outcome, PermissionOutcome::Allow);
-        assert_eq!(prompter.seen.len(), 1);
-        assert_eq!(prompter.seen[0].tool_name, "bash");
-        assert_eq!(
-            prompter.seen[0].current_mode,
-            PermissionMode::WorkspaceWrite
-        );
-        assert_eq!(
-            prompter.seen[0].required_mode,
-            PermissionMode::DangerFullAccess
-        );
-    }
-
-    #[test]
-    fn honors_prompt_rejection_reason() {
-        let policy = PermissionPolicy::new(PermissionMode::WorkspaceWrite)
-            .with_tool_requirement("bash", PermissionMode::DangerFullAccess);
-        let mut prompter = RecordingPrompter {
-            seen: Vec::new(),
-            allow: false,
-        };
-
         assert!(matches!(
-            policy.authorize("bash", "echo hi", Some(&mut prompter)),
+            policy.authorize("edit", "x", None),
-            PermissionOutcome::Deny { reason } if reason == "not now"
+            PermissionOutcome::Deny { .. }
         ));
     }
 }

rust/crates/runtime/src/session.rs

@@ -19,10 +19,6 @@ pub enum ContentBlock {
     Text {
         text: String,
     },
-    Thinking {
-        text: String,
-        signature: Option<String>,
-    },
     ToolUse {
         id: String,
         name: String,
@@ -261,19 +257,6 @@ impl ContentBlock {
                 object.insert("type".to_string(), JsonValue::String("text".to_string()));
                 object.insert("text".to_string(), JsonValue::String(text.clone()));
             }
-            Self::Thinking { text, signature } => {
-                object.insert(
-                    "type".to_string(),
-                    JsonValue::String("thinking".to_string()),
-                );
-                object.insert("text".to_string(), JsonValue::String(text.clone()));
-                if let Some(signature) = signature {
-                    object.insert(
-                        "signature".to_string(),
-                        JsonValue::String(signature.clone()),
-                    );
-                }
-            }
             Self::ToolUse { id, name, input } => {
                 object.insert(
                     "type".to_string(),
@@ -320,13 +303,6 @@ impl ContentBlock {
             "text" => Ok(Self::Text {
                 text: required_string(object, "text")?,
             }),
-            "thinking" => Ok(Self::Thinking {
-                text: required_string(object, "text")?,
-                signature: object
-                    .get("signature")
-                    .and_then(JsonValue::as_str)
-                    .map(ToOwned::to_owned),
-            }),
             "tool_use" => Ok(Self::ToolUse {
                 id: required_string(object, "id")?,
                 name: required_string(object, "name")?,

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

@@ -2,7 +2,7 @@ use std::io::{self, Write};
 use std::path::PathBuf;
 
 use crate::args::{OutputFormat, PermissionMode};
-use crate::input::{LineEditor, ReadOutcome};
+use crate::input::LineEditor;
 use crate::render::{Spinner, TerminalRenderer};
 use runtime::{ConversationClient, ConversationMessage, RuntimeError, StreamEvent, UsageSummary};
 
@@ -111,21 +111,16 @@ impl CliApp {
     }
 
     pub fn run_repl(&mut self) -> io::Result<()> {
-        let mut editor = LineEditor::new("› ", Vec::new());
+        let editor = LineEditor::new("› ");
         println!("Rusty Claude CLI interactive mode");
         println!("Type /help for commands. Shift+Enter or Ctrl+J inserts a newline.");
 
-        loop {
+        while let Some(input) = editor.read_line()? {
-            match editor.read_line()? {
+            if input.trim().is_empty() {
-                ReadOutcome::Submit(input) => {
+                continue;
-                    if input.trim().is_empty() {
-                        continue;
-                    }
-                    self.handle_submission(&input, &mut io::stdout())?;
-                }
-                ReadOutcome::Cancel => continue,
-                ReadOutcome::Exit => break,
             }
+
+            self.handle_submission(&input, &mut io::stdout())?;
         }
 
         Ok(())

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

@@ -1,8 +1,9 @@
 use std::io::{self, IsTerminal, Write};
 
-use crossterm::cursor::{MoveDown, MoveToColumn, MoveUp};
+use crossterm::cursor::MoveToColumn;
 use crossterm::event::{self, Event, KeyCode, KeyEvent, KeyModifiers};
 use crossterm::queue;
+use crossterm::style::Print;
 use crossterm::terminal::{disable_raw_mode, enable_raw_mode, Clear, ClearType};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -84,124 +85,21 @@ impl InputBuffer {
         self.buffer.clear();
         self.cursor = 0;
     }
-
-    pub fn replace(&mut self, value: impl Into<String>) {
-        self.buffer = value.into();
-        self.cursor = self.buffer.len();
-    }
-
-    #[must_use]
-    fn current_command_prefix(&self) -> Option<&str> {
-        if self.cursor != self.buffer.len() {
-            return None;
-        }
-        let prefix = &self.buffer[..self.cursor];
-        if prefix.contains(char::is_whitespace) || !prefix.starts_with('/') {
-            return None;
-        }
-        Some(prefix)
-    }
-
-    pub fn complete_slash_command(&mut self, candidates: &[String]) -> bool {
-        let Some(prefix) = self.current_command_prefix() else {
-            return false;
-        };
-
-        let matches = candidates
-            .iter()
-            .filter(|candidate| candidate.starts_with(prefix))
-            .map(String::as_str)
-            .collect::<Vec<_>>();
-        if matches.is_empty() {
-            return false;
-        }
-
-        let replacement = longest_common_prefix(&matches);
-        if replacement == prefix {
-            return false;
-        }
-
-        self.replace(replacement);
-        true
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct RenderedBuffer {
-    lines: Vec<String>,
-    cursor_row: u16,
-    cursor_col: u16,
-}
-
-impl RenderedBuffer {
-    #[must_use]
-    pub fn line_count(&self) -> usize {
-        self.lines.len()
-    }
-
-    fn write(&self, out: &mut impl Write) -> io::Result<()> {
-        for (index, line) in self.lines.iter().enumerate() {
-            if index > 0 {
-                writeln!(out)?;
-            }
-            write!(out, "{line}")?;
-        }
-        Ok(())
-    }
-
-    #[cfg(test)]
-    #[must_use]
-    pub fn lines(&self) -> &[String] {
-        &self.lines
-    }
-
-    #[cfg(test)]
-    #[must_use]
-    pub fn cursor_position(&self) -> (u16, u16) {
-        (self.cursor_row, self.cursor_col)
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum ReadOutcome {
-    Submit(String),
-    Cancel,
-    Exit,
 }
 
 pub struct LineEditor {
     prompt: String,
-    continuation_prompt: String,
-    history: Vec<String>,
-    history_index: Option<usize>,
-    draft: Option<String>,
-    completions: Vec<String>,
 }
 
 impl LineEditor {
     #[must_use]
-    pub fn new(prompt: impl Into<String>, completions: Vec<String>) -> Self {
+    pub fn new(prompt: impl Into<String>) -> Self {
         Self {
             prompt: prompt.into(),
-            continuation_prompt: String::from("> "),
-            history: Vec::new(),
-            history_index: None,
-            draft: None,
-            completions,
         }
     }
 
-    pub fn push_history(&mut self, entry: impl Into<String>) {
+    pub fn read_line(&self) -> io::Result<Option<String>> {
-        let entry = entry.into();
-        if entry.trim().is_empty() {
-            return;
-        }
-        self.history.push(entry);
-        self.history_index = None;
-        self.draft = None;
-    }
-
-    pub fn read_line(&mut self) -> io::Result<ReadOutcome> {
         if !io::stdin().is_terminal() || !io::stdout().is_terminal() {
             return self.read_line_fallback();
         }
@@ -209,43 +107,29 @@ impl LineEditor {
         enable_raw_mode()?;
         let mut stdout = io::stdout();
         let mut input = InputBuffer::new();
-        let mut rendered_lines = 1usize;
+        self.redraw(&mut stdout, &input)?;
-        self.redraw(&mut stdout, &input, rendered_lines)?;
 
         loop {
             let event = event::read()?;
             if let Event::Key(key) = event {
-                match self.handle_key(key, &mut input) {
+                match Self::handle_key(key, &mut input) {
-                    EditorAction::Continue => {
+                    EditorAction::Continue => self.redraw(&mut stdout, &input)?,
-                        rendered_lines = self.redraw(&mut stdout, &input, rendered_lines)?;
-                    }
                     EditorAction::Submit => {
                         disable_raw_mode()?;
                         writeln!(stdout)?;
-                        self.history_index = None;
+                        return Ok(Some(input.as_str().to_owned()));
-                        self.draft = None;
-                        return Ok(ReadOutcome::Submit(input.as_str().to_owned()));
                     }
                     EditorAction::Cancel => {
                         disable_raw_mode()?;
                         writeln!(stdout)?;
-                        self.history_index = None;
+                        return Ok(None);
-                        self.draft = None;
-                        return Ok(ReadOutcome::Cancel);
-                    }
-                    EditorAction::Exit => {
-                        disable_raw_mode()?;
-                        writeln!(stdout)?;
-                        self.history_index = None;
-                        self.draft = None;
-                        return Ok(ReadOutcome::Exit);
                     }
                 }
             }
         }
     }
 
-    fn read_line_fallback(&self) -> io::Result<ReadOutcome> {
+    fn read_line_fallback(&self) -> io::Result<Option<String>> {
         let mut stdout = io::stdout();
         write!(stdout, "{}", self.prompt)?;
         stdout.flush()?;
@@ -253,32 +137,22 @@ impl LineEditor {
         let mut buffer = String::new();
         let bytes_read = io::stdin().read_line(&mut buffer)?;
         if bytes_read == 0 {
-            return Ok(ReadOutcome::Exit);
+            return Ok(None);
         }
 
         while matches!(buffer.chars().last(), Some('\n' | '\r')) {
             buffer.pop();
         }
-        Ok(ReadOutcome::Submit(buffer))
+        Ok(Some(buffer))
     }
 
-    #[allow(clippy::too_many_lines)]
+    fn handle_key(key: KeyEvent, input: &mut InputBuffer) -> EditorAction {
-    fn handle_key(&mut self, key: KeyEvent, input: &mut InputBuffer) -> EditorAction {
         match key {
             KeyEvent {
                 code: KeyCode::Char('c'),
                 modifiers,
                 ..
-            } if modifiers.contains(KeyModifiers::CONTROL) => {
+            } if modifiers.contains(KeyModifiers::CONTROL) => EditorAction::Cancel,
-                if input.as_str().is_empty() {
-                    EditorAction::Exit
-                } else {
-                    input.clear();
-                    self.history_index = None;
-                    self.draft = None;
-                    EditorAction::Cancel
-                }
-            }
             KeyEvent {
                 code: KeyCode::Char('j'),
                 modifiers,
@@ -320,25 +194,6 @@ impl LineEditor {
                 input.move_right();
                 EditorAction::Continue
             }
-            KeyEvent {
-                code: KeyCode::Up, ..
-            } => {
-                self.navigate_history_up(input);
-                EditorAction::Continue
-            }
-            KeyEvent {
-                code: KeyCode::Down,
-                ..
-            } => {
-                self.navigate_history_down(input);
-                EditorAction::Continue
-            }
-            KeyEvent {
-                code: KeyCode::Tab, ..
-            } => {
-                input.complete_slash_command(&self.completions);
-                EditorAction::Continue
-            }
             KeyEvent {
                 code: KeyCode::Home,
                 ..
@@ -356,8 +211,6 @@ impl LineEditor {
                 code: KeyCode::Esc, ..
             } => {
                 input.clear();
-                self.history_index = None;
-                self.draft = None;
                 EditorAction::Cancel
             }
             KeyEvent {
@@ -366,74 +219,22 @@ impl LineEditor {
                 ..
             } if modifiers.is_empty() || modifiers == KeyModifiers::SHIFT => {
                 input.insert(ch);
-                self.history_index = None;
-                self.draft = None;
                 EditorAction::Continue
             }
             _ => EditorAction::Continue,
         }
     }
 
-    fn navigate_history_up(&mut self, input: &mut InputBuffer) {
+    fn redraw(&self, out: &mut impl Write, input: &InputBuffer) -> io::Result<()> {
-        if self.history.is_empty() {
+        let display = input.as_str().replace('\n', "\\n\n> ");
-            return;
-        }
-
-        match self.history_index {
-            Some(0) => {}
-            Some(index) => {
-                let next_index = index - 1;
-                input.replace(self.history[next_index].clone());
-                self.history_index = Some(next_index);
-            }
-            None => {
-                self.draft = Some(input.as_str().to_owned());
-                let next_index = self.history.len() - 1;
-                input.replace(self.history[next_index].clone());
-                self.history_index = Some(next_index);
-            }
-        }
-    }
-
-    fn navigate_history_down(&mut self, input: &mut InputBuffer) {
-        let Some(index) = self.history_index else {
-            return;
-        };
-
-        if index + 1 < self.history.len() {
-            let next_index = index + 1;
-            input.replace(self.history[next_index].clone());
-            self.history_index = Some(next_index);
-            return;
-        }
-
-        input.replace(self.draft.take().unwrap_or_default());
-        self.history_index = None;
-    }
-
-    fn redraw(
-        &self,
-        out: &mut impl Write,
-        input: &InputBuffer,
-        previous_line_count: usize,
-    ) -> io::Result<usize> {
-        let rendered = render_buffer(&self.prompt, &self.continuation_prompt, input);
-        if previous_line_count > 1 {
-            queue!(out, MoveUp(saturating_u16(previous_line_count - 1)))?;
-        }
-        queue!(out, MoveToColumn(0), Clear(ClearType::FromCursorDown),)?;
-        rendered.write(out)?;
         queue!(
             out,
-            MoveUp(saturating_u16(rendered.line_count().saturating_sub(1))),
             MoveToColumn(0),
+            Clear(ClearType::CurrentLine),
+            Print(&self.prompt),
+            Print(display),
         )?;
-        if rendered.cursor_row > 0 {
+        out.flush()
-            queue!(out, MoveDown(rendered.cursor_row))?;
-        }
-        queue!(out, MoveToColumn(rendered.cursor_col))?;
-        out.flush()?;
-        Ok(rendered.line_count())
     }
 }
 
@@ -442,76 +243,11 @@ enum EditorAction {
     Continue,
     Submit,
     Cancel,
-    Exit,
-}
-
-#[must_use]
-pub fn render_buffer(
-    prompt: &str,
-    continuation_prompt: &str,
-    input: &InputBuffer,
-) -> RenderedBuffer {
-    let before_cursor = &input.as_str()[..input.cursor];
-    let cursor_row = saturating_u16(before_cursor.chars().filter(|ch| *ch == '\n').count());
-    let cursor_line = before_cursor.rsplit('\n').next().unwrap_or_default();
-    let cursor_prompt = if cursor_row == 0 {
-        prompt
-    } else {
-        continuation_prompt
-    };
-    let cursor_col = saturating_u16(cursor_prompt.chars().count() + cursor_line.chars().count());
-
-    let mut lines = Vec::new();
-    for (index, line) in input.as_str().split('\n').enumerate() {
-        let prefix = if index == 0 {
-            prompt
-        } else {
-            continuation_prompt
-        };
-        lines.push(format!("{prefix}{line}"));
-    }
-    if lines.is_empty() {
-        lines.push(prompt.to_string());
-    }
-
-    RenderedBuffer {
-        lines,
-        cursor_row,
-        cursor_col,
-    }
-}
-
-#[must_use]
-fn longest_common_prefix(values: &[&str]) -> String {
-    let Some(first) = values.first() else {
-        return String::new();
-    };
-
-    let mut prefix = (*first).to_string();
-    for value in values.iter().skip(1) {
-        while !value.starts_with(&prefix) {
-            prefix.pop();
-            if prefix.is_empty() {
-                break;
-            }
-        }
-    }
-    prefix
-}
-
-#[must_use]
-fn saturating_u16(value: usize) -> u16 {
-    u16::try_from(value).unwrap_or(u16::MAX)
 }
 
 #[cfg(test)]
 mod tests {
-    use super::{render_buffer, InputBuffer, LineEditor};
+    use super::InputBuffer;
-    use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
-
-    fn key(code: KeyCode) -> KeyEvent {
-        KeyEvent::new(code, KeyModifiers::NONE)
-    }
 
     #[test]
     fn supports_basic_line_editing() {
@@ -530,119 +266,4 @@ mod tests {
         assert_eq!(input.as_str(), "hix");
         assert_eq!(input.cursor(), 2);
     }
-
-    #[test]
-    fn completes_unique_slash_command() {
-        let mut input = InputBuffer::new();
-        for ch in "/he".chars() {
-            input.insert(ch);
-        }
-
-        assert!(input.complete_slash_command(&[
-            "/help".to_string(),
-            "/hello".to_string(),
-            "/status".to_string(),
-        ]));
-        assert_eq!(input.as_str(), "/hel");
-
-        assert!(input.complete_slash_command(&["/help".to_string(), "/status".to_string()]));
-        assert_eq!(input.as_str(), "/help");
-    }
-
-    #[test]
-    fn ignores_completion_when_prefix_is_not_a_slash_command() {
-        let mut input = InputBuffer::new();
-        for ch in "hello".chars() {
-            input.insert(ch);
-        }
-
-        assert!(!input.complete_slash_command(&["/help".to_string()]));
-        assert_eq!(input.as_str(), "hello");
-    }
-
-    #[test]
-    fn history_navigation_restores_current_draft() {
-        let mut editor = LineEditor::new("› ", vec![]);
-        editor.push_history("/help");
-        editor.push_history("status report");
-
-        let mut input = InputBuffer::new();
-        for ch in "draft".chars() {
-            input.insert(ch);
-        }
-
-        let _ = editor.handle_key(key(KeyCode::Up), &mut input);
-        assert_eq!(input.as_str(), "status report");
-
-        let _ = editor.handle_key(key(KeyCode::Up), &mut input);
-        assert_eq!(input.as_str(), "/help");
-
-        let _ = editor.handle_key(key(KeyCode::Down), &mut input);
-        assert_eq!(input.as_str(), "status report");
-
-        let _ = editor.handle_key(key(KeyCode::Down), &mut input);
-        assert_eq!(input.as_str(), "draft");
-    }
-
-    #[test]
-    fn tab_key_completes_from_editor_candidates() {
-        let mut editor = LineEditor::new(
-            "› ",
-            vec![
-                "/help".to_string(),
-                "/status".to_string(),
-                "/session".to_string(),
-            ],
-        );
-        let mut input = InputBuffer::new();
-        for ch in "/st".chars() {
-            input.insert(ch);
-        }
-
-        let _ = editor.handle_key(key(KeyCode::Tab), &mut input);
-        assert_eq!(input.as_str(), "/status");
-    }
-
-    #[test]
-    fn renders_multiline_buffers_with_continuation_prompt() {
-        let mut input = InputBuffer::new();
-        for ch in "hello\nworld".chars() {
-            if ch == '\n' {
-                input.insert_newline();
-            } else {
-                input.insert(ch);
-            }
-        }
-
-        let rendered = render_buffer("› ", "> ", &input);
-        assert_eq!(
-            rendered.lines(),
-            &["› hello".to_string(), "> world".to_string()]
-        );
-        assert_eq!(rendered.cursor_position(), (1, 7));
-    }
-
-    #[test]
-    fn ctrl_c_exits_only_when_buffer_is_empty() {
-        let mut editor = LineEditor::new("› ", vec![]);
-        let mut empty = InputBuffer::new();
-        assert!(matches!(
-            editor.handle_key(
-                KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL),
-                &mut empty,
-            ),
-            super::EditorAction::Exit
-        ));
-
-        let mut filled = InputBuffer::new();
-        filled.insert('x');
-        assert!(matches!(
-            editor.handle_key(
-                KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL),
-                &mut filled,
-            ),
-            super::EditorAction::Cancel
-        ));
-        assert!(filled.as_str().is_empty());
-    }
 }

rust/crates/tools/src/lib.rs

@@ -6,7 +6,7 @@ use std::time::{Duration, Instant};
 use reqwest::blocking::Client;
 use runtime::{
     edit_file, execute_bash, glob_search, grep_search, read_file, write_file, BashCommandInput,
-    GrepSearchInput, PermissionMode,
+    GrepSearchInput,
 };
 use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
@@ -45,7 +45,6 @@ pub struct ToolSpec {
     pub name: &'static str,
     pub description: &'static str,
     pub input_schema: Value,
-    pub required_permission: PermissionMode,
 }
 
 #[must_use]
@@ -67,7 +66,6 @@ pub fn mvp_tool_specs() -> Vec<ToolSpec> {
                 "required": ["command"],
                 "additionalProperties": false
             }),
-            required_permission: PermissionMode::DangerFullAccess,
         },
         ToolSpec {
             name: "read_file",
@@ -82,7 +80,6 @@ pub fn mvp_tool_specs() -> Vec<ToolSpec> {
                 "required": ["path"],
                 "additionalProperties": false
             }),
-            required_permission: PermissionMode::ReadOnly,
         },
         ToolSpec {
             name: "write_file",
@@ -96,7 +93,6 @@ pub fn mvp_tool_specs() -> Vec<ToolSpec> {
                 "required": ["path", "content"],
                 "additionalProperties": false
             }),
-            required_permission: PermissionMode::WorkspaceWrite,
         },
         ToolSpec {
             name: "edit_file",
@@ -112,7 +108,6 @@ pub fn mvp_tool_specs() -> Vec<ToolSpec> {
                 "required": ["path", "old_string", "new_string"],
                 "additionalProperties": false
             }),
-            required_permission: PermissionMode::WorkspaceWrite,
         },
         ToolSpec {
             name: "glob_search",
@@ -126,7 +121,6 @@ pub fn mvp_tool_specs() -> Vec<ToolSpec> {
                 "required": ["pattern"],
                 "additionalProperties": false
             }),
-            required_permission: PermissionMode::ReadOnly,
         },
         ToolSpec {
             name: "grep_search",
@@ -152,7 +146,6 @@ pub fn mvp_tool_specs() -> Vec<ToolSpec> {
                 "required": ["pattern"],
                 "additionalProperties": false
             }),
-            required_permission: PermissionMode::ReadOnly,
         },
         ToolSpec {
             name: "WebFetch",
@@ -167,7 +160,6 @@ pub fn mvp_tool_specs() -> Vec<ToolSpec> {
                 "required": ["url", "prompt"],
                 "additionalProperties": false
             }),
-            required_permission: PermissionMode::ReadOnly,
         },
         ToolSpec {
             name: "WebSearch",
@@ -188,7 +180,6 @@ pub fn mvp_tool_specs() -> Vec<ToolSpec> {
                 "required": ["query"],
                 "additionalProperties": false
             }),
-            required_permission: PermissionMode::ReadOnly,
         },
         ToolSpec {
             name: "TodoWrite",
@@ -216,7 +207,6 @@ pub fn mvp_tool_specs() -> Vec<ToolSpec> {
                 "required": ["todos"],
                 "additionalProperties": false
             }),
-            required_permission: PermissionMode::WorkspaceWrite,
         },
         ToolSpec {
             name: "Skill",
@@ -230,7 +220,6 @@ pub fn mvp_tool_specs() -> Vec<ToolSpec> {
                 "required": ["skill"],
                 "additionalProperties": false
             }),
-            required_permission: PermissionMode::ReadOnly,
         },
         ToolSpec {
             name: "Agent",
@@ -247,7 +236,6 @@ pub fn mvp_tool_specs() -> Vec<ToolSpec> {
                 "required": ["description", "prompt"],
                 "additionalProperties": false
             }),
-            required_permission: PermissionMode::DangerFullAccess,
         },
         ToolSpec {
             name: "ToolSearch",
@@ -261,7 +249,6 @@ pub fn mvp_tool_specs() -> Vec<ToolSpec> {
                 "required": ["query"],
                 "additionalProperties": false
             }),
-            required_permission: PermissionMode::ReadOnly,
         },
         ToolSpec {
             name: "NotebookEdit",
@@ -278,7 +265,6 @@ pub fn mvp_tool_specs() -> Vec<ToolSpec> {
                 "required": ["notebook_path"],
                 "additionalProperties": false
             }),
-            required_permission: PermissionMode::WorkspaceWrite,
         },
         ToolSpec {
             name: "Sleep",
@@ -291,7 +277,6 @@ pub fn mvp_tool_specs() -> Vec<ToolSpec> {
                 "required": ["duration_ms"],
                 "additionalProperties": false
             }),
-            required_permission: PermissionMode::ReadOnly,
         },
         ToolSpec {
             name: "SendUserMessage",
@@ -312,7 +297,6 @@ pub fn mvp_tool_specs() -> Vec<ToolSpec> {
                 "required": ["message", "status"],
                 "additionalProperties": false
             }),
-            required_permission: PermissionMode::ReadOnly,
         },
         ToolSpec {
             name: "Config",
@@ -328,7 +312,6 @@ pub fn mvp_tool_specs() -> Vec<ToolSpec> {
                 "required": ["setting"],
                 "additionalProperties": false
             }),
-            required_permission: PermissionMode::WorkspaceWrite,
         },
         ToolSpec {
             name: "StructuredOutput",
@@ -337,7 +320,6 @@ pub fn mvp_tool_specs() -> Vec<ToolSpec> {
                 "type": "object",
                 "additionalProperties": true
             }),
-            required_permission: PermissionMode::ReadOnly,
         },
         ToolSpec {
             name: "REPL",
@@ -352,7 +334,6 @@ pub fn mvp_tool_specs() -> Vec<ToolSpec> {
                 "required": ["code", "language"],
                 "additionalProperties": false
             }),
-            required_permission: PermissionMode::DangerFullAccess,
         },
         ToolSpec {
             name: "PowerShell",
@@ -368,7 +349,6 @@ pub fn mvp_tool_specs() -> Vec<ToolSpec> {
                 "required": ["command"],
                 "additionalProperties": false
             }),
-            required_permission: PermissionMode::DangerFullAccess,
         },
     ]
 }