Make local environment failures diagnosable from the CLI

Add a non-interactive doctor subcommand that checks API key reachability, OAuth credential state, config files, git, MCP servers, network access, and system metadata in one structured report. The implementation reuses existing runtime/auth plumbing and adds focused tests for parsing and report behavior.

Also update stale runtime permission-mode tests so workspace verification reflects the current enum model rather than historical Prompt/Allow variants.

Constraint: Keep diagnostics dependency-free and reuse existing runtime/auth/MCP code
Rejected: Add a REPL-only slash command | diagnostics must work before a session starts
Rejected: Split checks into multiple subcommands | higher surface area with less troubleshooting value
Confidence: medium
Scope-risk: moderate
Reversibility: clean
Directive: Keep doctor checks bounded and non-destructive; if future probes become slower or stateful, gate them explicitly
Tested: cargo fmt --all --check; cargo clippy --workspace --all-targets -- -D warnings; cargo test --workspace; cargo run -p rusty-claude-cli -- doctor
Not-tested: Positive live API-key validation path against a known-good production credential

rust/crates/commands/src/lib.rs

@@ -51,12 +51,6 @@ const SLASH_COMMAND_SPECS: &[SlashCommandSpec] = &[
         argument_hint: None,
         resume_supported: true,
     },
-    SlashCommandSpec {
-        name: "sandbox",
-        summary: "Show sandbox isolation status",
-        argument_hint: None,
-        resume_supported: true,
-    },
     SlashCommandSpec {
         name: "compact",
         summary: "Compact local session history",
@@ -141,7 +135,6 @@ const SLASH_COMMAND_SPECS: &[SlashCommandSpec] = &[
 pub enum SlashCommand {
     Help,
     Status,
-    Sandbox,
     Compact,
     Model {
         model: Option<String>,
@@ -186,7 +179,6 @@ impl SlashCommand {
         Some(match command {
             "help" => Self::Help,
             "status" => Self::Status,
-            "sandbox" => Self::Sandbox,
             "compact" => Self::Compact,
             "model" => Self::Model {
                 model: parts.next().map(ToOwned::to_owned),
@@ -287,7 +279,6 @@ pub fn handle_slash_command(
             session: session.clone(),
         }),
         SlashCommand::Status
-        | SlashCommand::Sandbox
         | SlashCommand::Model { .. }
         | SlashCommand::Permissions { .. }
         | SlashCommand::Clear { .. }
@@ -316,7 +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("/sandbox"), Some(SlashCommand::Sandbox));
         assert_eq!(
             SlashCommand::parse("/model claude-opus"),
             Some(SlashCommand::Model {
@@ -383,7 +373,6 @@ mod tests {
         assert!(help.contains("works with --resume SESSION.json"));
         assert!(help.contains("/help"));
         assert!(help.contains("/status"));
-        assert!(help.contains("/sandbox"));
         assert!(help.contains("/compact"));
         assert!(help.contains("/model [model]"));
         assert!(help.contains("/permissions [read-only|workspace-write|danger-full-access]"));
@@ -397,8 +386,8 @@ 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(), 12);
+        assert_eq!(resume_supported_slash_commands().len(), 11);
     }
 
     #[test]
@@ -445,7 +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("/sandbox", &session, CompactionConfig::default()).is_none());
         assert!(
             handle_slash_command("/model claude", &session, CompactionConfig::default()).is_none()
         );

rust/crates/runtime/src/bash.rs

@@ -1,4 +1,3 @@
-use std::env;
 use std::io;
 use std::process::{Command, Stdio};
 use std::time::Duration;
@@ -8,12 +7,6 @@ use tokio::process::Command as TokioCommand;
 use tokio::runtime::Builder;
 use tokio::time::timeout;
 
-use crate::sandbox::{
-    build_linux_sandbox_command, resolve_sandbox_status_for_request, FilesystemIsolationMode,
-    SandboxConfig, SandboxStatus,
-};
-use crate::ConfigLoader;
-
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct BashCommandInput {
     pub command: String,
@@ -23,14 +16,6 @@ pub struct BashCommandInput {
     pub run_in_background: Option<bool>,
     #[serde(rename = "dangerouslyDisableSandbox")]
     pub dangerously_disable_sandbox: Option<bool>,
-    #[serde(rename = "namespaceRestrictions")]
-    pub namespace_restrictions: Option<bool>,
-    #[serde(rename = "isolateNetwork")]
-    pub isolate_network: Option<bool>,
-    #[serde(rename = "filesystemMode")]
-    pub filesystem_mode: Option<FilesystemIsolationMode>,
-    #[serde(rename = "allowedMounts")]
-    pub allowed_mounts: Option<Vec<String>>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
@@ -60,17 +45,13 @@ pub struct BashCommandOutput {
     pub persisted_output_path: Option<String>,
     #[serde(rename = "persistedOutputSize")]
     pub persisted_output_size: Option<u64>,
-    #[serde(rename = "sandboxStatus")]
-    pub sandbox_status: Option<SandboxStatus>,
 }
 
 pub fn execute_bash(input: BashCommandInput) -> io::Result<BashCommandOutput> {
-    let cwd = env::current_dir()?;
-    let sandbox_status = sandbox_status_for_input(&input, &cwd);
-
     if input.run_in_background.unwrap_or(false) {
-        let mut child = prepare_command(&input.command, &cwd, &sandbox_status, false);
+        let child = Command::new("sh")
-        let child = child
+            .arg("-lc")
+            .arg(&input.command)
             .stdin(Stdio::null())
             .stdout(Stdio::null())
             .stderr(Stdio::null())
@@ -91,20 +72,16 @@ pub fn execute_bash(input: BashCommandInput) -> io::Result<BashCommandOutput> {
             structured_content: None,
             persisted_output_path: None,
             persisted_output_size: None,
-            sandbox_status: Some(sandbox_status),
         });
     }
 
     let runtime = Builder::new_current_thread().enable_all().build()?;
-    runtime.block_on(execute_bash_async(input, sandbox_status, cwd))
+    runtime.block_on(execute_bash_async(input))
 }
 
-async fn execute_bash_async(
+async fn execute_bash_async(input: BashCommandInput) -> io::Result<BashCommandOutput> {
-    input: BashCommandInput,
+    let mut command = TokioCommand::new("sh");
-    sandbox_status: SandboxStatus,
+    command.arg("-lc").arg(&input.command);
-    cwd: std::path::PathBuf,
-) -> io::Result<BashCommandOutput> {
-    let mut command = prepare_tokio_command(&input.command, &cwd, &sandbox_status, true);
 
     let output_result = if let Some(timeout_ms) = input.timeout {
         match timeout(Duration::from_millis(timeout_ms), command.output()).await {
@@ -125,7 +102,6 @@ async fn execute_bash_async(
                     structured_content: None,
                     persisted_output_path: None,
                     persisted_output_size: None,
-                    sandbox_status: Some(sandbox_status),
                 });
             }
         }
@@ -160,88 +136,12 @@ async fn execute_bash_async(
         structured_content: None,
         persisted_output_path: None,
         persisted_output_size: None,
-        sandbox_status: Some(sandbox_status),
     })
 }
 
-fn sandbox_status_for_input(input: &BashCommandInput, cwd: &std::path::Path) -> SandboxStatus {
-    let config = ConfigLoader::default_for(cwd).load().map_or_else(
-        |_| SandboxConfig::default(),
-        |runtime_config| runtime_config.sandbox().clone(),
-    );
-    let request = config.resolve_request(
-        input.dangerously_disable_sandbox.map(|disabled| !disabled),
-        input.namespace_restrictions,
-        input.isolate_network,
-        input.filesystem_mode,
-        input.allowed_mounts.clone(),
-    );
-    resolve_sandbox_status_for_request(&request, cwd)
-}
-
-fn prepare_command(
-    command: &str,
-    cwd: &std::path::Path,
-    sandbox_status: &SandboxStatus,
-    create_dirs: bool,
-) -> Command {
-    if create_dirs {
-        prepare_sandbox_dirs(cwd);
-    }
-
-    if let Some(launcher) = build_linux_sandbox_command(command, cwd, sandbox_status) {
-        let mut prepared = Command::new(launcher.program);
-        prepared.args(launcher.args);
-        prepared.current_dir(cwd);
-        prepared.envs(launcher.env);
-        return prepared;
-    }
-
-    let mut prepared = Command::new("sh");
-    prepared.arg("-lc").arg(command).current_dir(cwd);
-    if sandbox_status.filesystem_active {
-        prepared.env("HOME", cwd.join(".sandbox-home"));
-        prepared.env("TMPDIR", cwd.join(".sandbox-tmp"));
-    }
-    prepared
-}
-
-fn prepare_tokio_command(
-    command: &str,
-    cwd: &std::path::Path,
-    sandbox_status: &SandboxStatus,
-    create_dirs: bool,
-) -> TokioCommand {
-    if create_dirs {
-        prepare_sandbox_dirs(cwd);
-    }
-
-    if let Some(launcher) = build_linux_sandbox_command(command, cwd, sandbox_status) {
-        let mut prepared = TokioCommand::new(launcher.program);
-        prepared.args(launcher.args);
-        prepared.current_dir(cwd);
-        prepared.envs(launcher.env);
-        return prepared;
-    }
-
-    let mut prepared = TokioCommand::new("sh");
-    prepared.arg("-lc").arg(command).current_dir(cwd);
-    if sandbox_status.filesystem_active {
-        prepared.env("HOME", cwd.join(".sandbox-home"));
-        prepared.env("TMPDIR", cwd.join(".sandbox-tmp"));
-    }
-    prepared
-}
-
-fn prepare_sandbox_dirs(cwd: &std::path::Path) {
-    let _ = std::fs::create_dir_all(cwd.join(".sandbox-home"));
-    let _ = std::fs::create_dir_all(cwd.join(".sandbox-tmp"));
-}
-
 #[cfg(test)]
 mod tests {
     use super::{execute_bash, BashCommandInput};
-    use crate::sandbox::FilesystemIsolationMode;
 
     #[test]
     fn executes_simple_command() {
@@ -251,33 +151,10 @@ mod tests {
             description: None,
             run_in_background: Some(false),
             dangerously_disable_sandbox: Some(false),
-            namespace_restrictions: Some(false),
-            isolate_network: Some(false),
-            filesystem_mode: Some(FilesystemIsolationMode::WorkspaceOnly),
-            allowed_mounts: None,
         })
         .expect("bash command should execute");
 
         assert_eq!(output.stdout, "hello");
         assert!(!output.interrupted);
-        assert!(output.sandbox_status.is_some());
-    }
-
-    #[test]
-    fn disables_sandbox_when_requested() {
-        let output = execute_bash(BashCommandInput {
-            command: String::from("printf 'hello'"),
-            timeout: Some(1_000),
-            description: None,
-            run_in_background: Some(false),
-            dangerously_disable_sandbox: Some(true),
-            namespace_restrictions: None,
-            isolate_network: None,
-            filesystem_mode: None,
-            allowed_mounts: None,
-        })
-        .expect("bash command should execute");
-
-        assert!(!output.sandbox_status.expect("sandbox status").enabled);
     }
 }

rust/crates/runtime/src/config.rs

@@ -4,7 +4,6 @@ use std::fs;
 use std::path::{Path, PathBuf};
 
 use crate::json::JsonValue;
-use crate::sandbox::{FilesystemIsolationMode, SandboxConfig};
 
 pub const CLAUDE_CODE_SETTINGS_SCHEMA_NAME: &str = "SettingsSchema";
 
@@ -41,7 +40,6 @@ pub struct RuntimeFeatureConfig {
     oauth: Option<OAuthConfig>,
     model: Option<String>,
     permission_mode: Option<ResolvedPermissionMode>,
-    sandbox: SandboxConfig,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Default)]
@@ -227,7 +225,6 @@ impl ConfigLoader {
             oauth: parse_optional_oauth_config(&merged_value, "merged settings.oauth")?,
             model: parse_optional_model(&merged_value),
             permission_mode: parse_optional_permission_mode(&merged_value)?,
-            sandbox: parse_optional_sandbox_config(&merged_value)?,
         };
 
         Ok(RuntimeConfig {
@@ -292,11 +289,6 @@ impl RuntimeConfig {
     pub fn permission_mode(&self) -> Option<ResolvedPermissionMode> {
         self.feature_config.permission_mode
     }
-
-    #[must_use]
-    pub fn sandbox(&self) -> &SandboxConfig {
-        &self.feature_config.sandbox
-    }
 }
 
 impl RuntimeFeatureConfig {
@@ -319,11 +311,6 @@ impl RuntimeFeatureConfig {
     pub fn permission_mode(&self) -> Option<ResolvedPermissionMode> {
         self.permission_mode
     }
-
-    #[must_use]
-    pub fn sandbox(&self) -> &SandboxConfig {
-        &self.sandbox
-    }
 }
 
 impl McpConfigCollection {
@@ -458,42 +445,6 @@ fn parse_permission_mode_label(
     }
 }
 
-fn parse_optional_sandbox_config(root: &JsonValue) -> Result<SandboxConfig, ConfigError> {
-    let Some(object) = root.as_object() else {
-        return Ok(SandboxConfig::default());
-    };
-    let Some(sandbox_value) = object.get("sandbox") else {
-        return Ok(SandboxConfig::default());
-    };
-    let sandbox = expect_object(sandbox_value, "merged settings.sandbox")?;
-    let filesystem_mode = optional_string(sandbox, "filesystemMode", "merged settings.sandbox")?
-        .map(parse_filesystem_mode_label)
-        .transpose()?;
-    Ok(SandboxConfig {
-        enabled: optional_bool(sandbox, "enabled", "merged settings.sandbox")?,
-        namespace_restrictions: optional_bool(
-            sandbox,
-            "namespaceRestrictions",
-            "merged settings.sandbox",
-        )?,
-        network_isolation: optional_bool(sandbox, "networkIsolation", "merged settings.sandbox")?,
-        filesystem_mode,
-        allowed_mounts: optional_string_array(sandbox, "allowedMounts", "merged settings.sandbox")?
-            .unwrap_or_default(),
-    })
-}
-
-fn parse_filesystem_mode_label(value: &str) -> Result<FilesystemIsolationMode, ConfigError> {
-    match value {
-        "off" => Ok(FilesystemIsolationMode::Off),
-        "workspace-only" => Ok(FilesystemIsolationMode::WorkspaceOnly),
-        "allow-list" => Ok(FilesystemIsolationMode::AllowList),
-        other => Err(ConfigError::Parse(format!(
-            "merged settings.sandbox.filesystemMode: unsupported filesystem mode {other}"
-        ))),
-    }
-}
-
 fn parse_optional_oauth_config(
     root: &JsonValue,
     context: &str,
@@ -737,7 +688,6 @@ mod tests {
         CLAUDE_CODE_SETTINGS_SCHEMA_NAME,
     };
     use crate::json::JsonValue;
-    use crate::sandbox::FilesystemIsolationMode;
     use std::fs;
     use std::time::{SystemTime, UNIX_EPOCH};
 
@@ -842,44 +792,6 @@ mod tests {
         fs::remove_dir_all(root).expect("cleanup temp dir");
     }
 
-    #[test]
-    fn parses_sandbox_config() {
-        let root = temp_dir();
-        let cwd = root.join("project");
-        let home = root.join("home").join(".claude");
-        fs::create_dir_all(cwd.join(".claude")).expect("project config dir");
-        fs::create_dir_all(&home).expect("home config dir");
-
-        fs::write(
-            cwd.join(".claude").join("settings.local.json"),
-            r#"{
-              "sandbox": {
-                "enabled": true,
-                "namespaceRestrictions": false,
-                "networkIsolation": true,
-                "filesystemMode": "allow-list",
-                "allowedMounts": ["logs", "tmp/cache"]
-              }
-            }"#,
-        )
-        .expect("write local settings");
-
-        let loaded = ConfigLoader::new(&cwd, &home)
-            .load()
-            .expect("config should load");
-
-        assert_eq!(loaded.sandbox().enabled, Some(true));
-        assert_eq!(loaded.sandbox().namespace_restrictions, Some(false));
-        assert_eq!(loaded.sandbox().network_isolation, Some(true));
-        assert_eq!(
-            loaded.sandbox().filesystem_mode,
-            Some(FilesystemIsolationMode::AllowList)
-        );
-        assert_eq!(loaded.sandbox().allowed_mounts, vec!["logs", "tmp/cache"]);
-
-        fs::remove_dir_all(root).expect("cleanup temp dir");
-    }
-
     #[test]
     fn parses_typed_mcp_and_oauth_config() {
         let root = temp_dir();

rust/crates/runtime/src/lib.rs

@@ -12,7 +12,6 @@ mod oauth;
 mod permissions;
 mod prompt;
 mod remote;
-mod sandbox;
 mod session;
 mod usage;
 
@@ -74,12 +73,6 @@ pub use remote::{
     RemoteSessionContext, UpstreamProxyBootstrap, UpstreamProxyState, DEFAULT_REMOTE_BASE_URL,
     DEFAULT_SESSION_TOKEN_PATH, DEFAULT_SYSTEM_CA_BUNDLE, NO_PROXY_HOSTS, UPSTREAM_PROXY_ENV_KEYS,
 };
-pub use sandbox::{
-    build_linux_sandbox_command, detect_container_environment, detect_container_environment_from,
-    resolve_sandbox_status, resolve_sandbox_status_for_request, ContainerEnvironment,
-    FilesystemIsolationMode, LinuxSandboxCommand, SandboxConfig, SandboxDetectionInputs,
-    SandboxRequest, SandboxStatus,
-};
 pub use session::{ContentBlock, ConversationMessage, MessageRole, Session, SessionError};
 pub use usage::{
     format_usd, pricing_for_model, ModelPricing, TokenUsage, UsageCostEstimate, UsageTracker,

rust/crates/runtime/src/permissions.rs

@@ -5,8 +5,6 @@ pub enum PermissionMode {
     ReadOnly,
     WorkspaceWrite,
     DangerFullAccess,
-    Prompt,
-    Allow,
 }
 
 impl PermissionMode {
@@ -16,8 +14,6 @@ impl PermissionMode {
             Self::ReadOnly => "read-only",
             Self::WorkspaceWrite => "workspace-write",
             Self::DangerFullAccess => "danger-full-access",
-            Self::Prompt => "prompt",
-            Self::Allow => "allow",
         }
     }
 }
@@ -94,7 +90,7 @@ impl PermissionPolicy {
     ) -> PermissionOutcome {
         let current_mode = self.active_mode();
         let required_mode = self.required_mode_for(tool_name);
-        if current_mode == PermissionMode::Allow || current_mode >= required_mode {
+        if current_mode >= required_mode {
             return PermissionOutcome::Allow;
         }
 
@@ -105,9 +101,8 @@ impl PermissionPolicy {
             required_mode,
         };
 
-        if current_mode == PermissionMode::Prompt
+        if current_mode == PermissionMode::WorkspaceWrite
-            || (current_mode == PermissionMode::WorkspaceWrite
+            && required_mode == PermissionMode::DangerFullAccess
-                && required_mode == PermissionMode::DangerFullAccess)
         {
             return match prompter.as_mut() {
                 Some(prompter) => match prompter.decide(&request) {

rust/crates/runtime/src/sandbox.rs

@@ -1,364 +0,0 @@
-use std::env;
-use std::fs;
-use std::path::{Path, PathBuf};
-
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
-#[serde(rename_all = "kebab-case")]
-pub enum FilesystemIsolationMode {
-    Off,
-    #[default]
-    WorkspaceOnly,
-    AllowList,
-}
-
-impl FilesystemIsolationMode {
-    #[must_use]
-    pub fn as_str(self) -> &'static str {
-        match self {
-            Self::Off => "off",
-            Self::WorkspaceOnly => "workspace-only",
-            Self::AllowList => "allow-list",
-        }
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
-pub struct SandboxConfig {
-    pub enabled: Option<bool>,
-    pub namespace_restrictions: Option<bool>,
-    pub network_isolation: Option<bool>,
-    pub filesystem_mode: Option<FilesystemIsolationMode>,
-    pub allowed_mounts: Vec<String>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
-pub struct SandboxRequest {
-    pub enabled: bool,
-    pub namespace_restrictions: bool,
-    pub network_isolation: bool,
-    pub filesystem_mode: FilesystemIsolationMode,
-    pub allowed_mounts: Vec<String>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
-pub struct ContainerEnvironment {
-    pub in_container: bool,
-    pub markers: Vec<String>,
-}
-
-#[allow(clippy::struct_excessive_bools)]
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
-pub struct SandboxStatus {
-    pub enabled: bool,
-    pub requested: SandboxRequest,
-    pub supported: bool,
-    pub active: bool,
-    pub namespace_supported: bool,
-    pub namespace_active: bool,
-    pub network_supported: bool,
-    pub network_active: bool,
-    pub filesystem_mode: FilesystemIsolationMode,
-    pub filesystem_active: bool,
-    pub allowed_mounts: Vec<String>,
-    pub in_container: bool,
-    pub container_markers: Vec<String>,
-    pub fallback_reason: Option<String>,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct SandboxDetectionInputs<'a> {
-    pub env_pairs: Vec<(String, String)>,
-    pub dockerenv_exists: bool,
-    pub containerenv_exists: bool,
-    pub proc_1_cgroup: Option<&'a str>,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct LinuxSandboxCommand {
-    pub program: String,
-    pub args: Vec<String>,
-    pub env: Vec<(String, String)>,
-}
-
-impl SandboxConfig {
-    #[must_use]
-    pub fn resolve_request(
-        &self,
-        enabled_override: Option<bool>,
-        namespace_override: Option<bool>,
-        network_override: Option<bool>,
-        filesystem_mode_override: Option<FilesystemIsolationMode>,
-        allowed_mounts_override: Option<Vec<String>>,
-    ) -> SandboxRequest {
-        SandboxRequest {
-            enabled: enabled_override.unwrap_or(self.enabled.unwrap_or(true)),
-            namespace_restrictions: namespace_override
-                .unwrap_or(self.namespace_restrictions.unwrap_or(true)),
-            network_isolation: network_override.unwrap_or(self.network_isolation.unwrap_or(false)),
-            filesystem_mode: filesystem_mode_override
-                .or(self.filesystem_mode)
-                .unwrap_or_default(),
-            allowed_mounts: allowed_mounts_override.unwrap_or_else(|| self.allowed_mounts.clone()),
-        }
-    }
-}
-
-#[must_use]
-pub fn detect_container_environment() -> ContainerEnvironment {
-    let proc_1_cgroup = fs::read_to_string("/proc/1/cgroup").ok();
-    detect_container_environment_from(SandboxDetectionInputs {
-        env_pairs: env::vars().collect(),
-        dockerenv_exists: Path::new("/.dockerenv").exists(),
-        containerenv_exists: Path::new("/run/.containerenv").exists(),
-        proc_1_cgroup: proc_1_cgroup.as_deref(),
-    })
-}
-
-#[must_use]
-pub fn detect_container_environment_from(
-    inputs: SandboxDetectionInputs<'_>,
-) -> ContainerEnvironment {
-    let mut markers = Vec::new();
-    if inputs.dockerenv_exists {
-        markers.push("/.dockerenv".to_string());
-    }
-    if inputs.containerenv_exists {
-        markers.push("/run/.containerenv".to_string());
-    }
-    for (key, value) in inputs.env_pairs {
-        let normalized = key.to_ascii_lowercase();
-        if matches!(
-            normalized.as_str(),
-            "container" | "docker" | "podman" | "kubernetes_service_host"
-        ) && !value.is_empty()
-        {
-            markers.push(format!("env:{key}={value}"));
-        }
-    }
-    if let Some(cgroup) = inputs.proc_1_cgroup {
-        for needle in ["docker", "containerd", "kubepods", "podman", "libpod"] {
-            if cgroup.contains(needle) {
-                markers.push(format!("/proc/1/cgroup:{needle}"));
-            }
-        }
-    }
-    markers.sort();
-    markers.dedup();
-    ContainerEnvironment {
-        in_container: !markers.is_empty(),
-        markers,
-    }
-}
-
-#[must_use]
-pub fn resolve_sandbox_status(config: &SandboxConfig, cwd: &Path) -> SandboxStatus {
-    let request = config.resolve_request(None, None, None, None, None);
-    resolve_sandbox_status_for_request(&request, cwd)
-}
-
-#[must_use]
-pub fn resolve_sandbox_status_for_request(request: &SandboxRequest, cwd: &Path) -> SandboxStatus {
-    let container = detect_container_environment();
-    let namespace_supported = cfg!(target_os = "linux") && command_exists("unshare");
-    let network_supported = namespace_supported;
-    let filesystem_active =
-        request.enabled && request.filesystem_mode != FilesystemIsolationMode::Off;
-    let mut fallback_reasons = Vec::new();
-
-    if request.enabled && request.namespace_restrictions && !namespace_supported {
-        fallback_reasons
-            .push("namespace isolation unavailable (requires Linux with `unshare`)".to_string());
-    }
-    if request.enabled && request.network_isolation && !network_supported {
-        fallback_reasons
-            .push("network isolation unavailable (requires Linux with `unshare`)".to_string());
-    }
-    if request.enabled
-        && request.filesystem_mode == FilesystemIsolationMode::AllowList
-        && request.allowed_mounts.is_empty()
-    {
-        fallback_reasons
-            .push("filesystem allow-list requested without configured mounts".to_string());
-    }
-
-    let active = request.enabled
-        && (!request.namespace_restrictions || namespace_supported)
-        && (!request.network_isolation || network_supported);
-
-    let allowed_mounts = normalize_mounts(&request.allowed_mounts, cwd);
-
-    SandboxStatus {
-        enabled: request.enabled,
-        requested: request.clone(),
-        supported: namespace_supported,
-        active,
-        namespace_supported,
-        namespace_active: request.enabled && request.namespace_restrictions && namespace_supported,
-        network_supported,
-        network_active: request.enabled && request.network_isolation && network_supported,
-        filesystem_mode: request.filesystem_mode,
-        filesystem_active,
-        allowed_mounts,
-        in_container: container.in_container,
-        container_markers: container.markers,
-        fallback_reason: (!fallback_reasons.is_empty()).then(|| fallback_reasons.join("; ")),
-    }
-}
-
-#[must_use]
-pub fn build_linux_sandbox_command(
-    command: &str,
-    cwd: &Path,
-    status: &SandboxStatus,
-) -> Option<LinuxSandboxCommand> {
-    if !cfg!(target_os = "linux")
-        || !status.enabled
-        || (!status.namespace_active && !status.network_active)
-    {
-        return None;
-    }
-
-    let mut args = vec![
-        "--user".to_string(),
-        "--map-root-user".to_string(),
-        "--mount".to_string(),
-        "--ipc".to_string(),
-        "--pid".to_string(),
-        "--uts".to_string(),
-        "--fork".to_string(),
-    ];
-    if status.network_active {
-        args.push("--net".to_string());
-    }
-    args.push("sh".to_string());
-    args.push("-lc".to_string());
-    args.push(command.to_string());
-
-    let sandbox_home = cwd.join(".sandbox-home");
-    let sandbox_tmp = cwd.join(".sandbox-tmp");
-    let mut env = vec![
-        ("HOME".to_string(), sandbox_home.display().to_string()),
-        ("TMPDIR".to_string(), sandbox_tmp.display().to_string()),
-        (
-            "CLAWD_SANDBOX_FILESYSTEM_MODE".to_string(),
-            status.filesystem_mode.as_str().to_string(),
-        ),
-        (
-            "CLAWD_SANDBOX_ALLOWED_MOUNTS".to_string(),
-            status.allowed_mounts.join(":"),
-        ),
-    ];
-    if let Ok(path) = env::var("PATH") {
-        env.push(("PATH".to_string(), path));
-    }
-
-    Some(LinuxSandboxCommand {
-        program: "unshare".to_string(),
-        args,
-        env,
-    })
-}
-
-fn normalize_mounts(mounts: &[String], cwd: &Path) -> Vec<String> {
-    let cwd = cwd.to_path_buf();
-    mounts
-        .iter()
-        .map(|mount| {
-            let path = PathBuf::from(mount);
-            if path.is_absolute() {
-                path
-            } else {
-                cwd.join(path)
-            }
-        })
-        .map(|path| path.display().to_string())
-        .collect()
-}
-
-fn command_exists(command: &str) -> bool {
-    env::var_os("PATH")
-        .is_some_and(|paths| env::split_paths(&paths).any(|path| path.join(command).exists()))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{
-        build_linux_sandbox_command, detect_container_environment_from, FilesystemIsolationMode,
-        SandboxConfig, SandboxDetectionInputs,
-    };
-    use std::path::Path;
-
-    #[test]
-    fn detects_container_markers_from_multiple_sources() {
-        let detected = detect_container_environment_from(SandboxDetectionInputs {
-            env_pairs: vec![("container".to_string(), "docker".to_string())],
-            dockerenv_exists: true,
-            containerenv_exists: false,
-            proc_1_cgroup: Some("12:memory:/docker/abc"),
-        });
-
-        assert!(detected.in_container);
-        assert!(detected
-            .markers
-            .iter()
-            .any(|marker| marker == "/.dockerenv"));
-        assert!(detected
-            .markers
-            .iter()
-            .any(|marker| marker == "env:container=docker"));
-        assert!(detected
-            .markers
-            .iter()
-            .any(|marker| marker == "/proc/1/cgroup:docker"));
-    }
-
-    #[test]
-    fn resolves_request_with_overrides() {
-        let config = SandboxConfig {
-            enabled: Some(true),
-            namespace_restrictions: Some(true),
-            network_isolation: Some(false),
-            filesystem_mode: Some(FilesystemIsolationMode::WorkspaceOnly),
-            allowed_mounts: vec!["logs".to_string()],
-        };
-
-        let request = config.resolve_request(
-            Some(true),
-            Some(false),
-            Some(true),
-            Some(FilesystemIsolationMode::AllowList),
-            Some(vec!["tmp".to_string()]),
-        );
-
-        assert!(request.enabled);
-        assert!(!request.namespace_restrictions);
-        assert!(request.network_isolation);
-        assert_eq!(request.filesystem_mode, FilesystemIsolationMode::AllowList);
-        assert_eq!(request.allowed_mounts, vec!["tmp"]);
-    }
-
-    #[test]
-    fn builds_linux_launcher_with_network_flag_when_requested() {
-        let config = SandboxConfig::default();
-        let status = super::resolve_sandbox_status_for_request(
-            &config.resolve_request(
-                Some(true),
-                Some(true),
-                Some(true),
-                Some(FilesystemIsolationMode::WorkspaceOnly),
-                None,
-            ),
-            Path::new("/workspace"),
-        );
-
-        if let Some(launcher) =
-            build_linux_sandbox_command("printf hi", Path::new("/workspace"), &status)
-        {
-            assert_eq!(launcher.program, "unshare");
-            assert!(launcher.args.iter().any(|arg| arg == "--mount"));
-            assert!(launcher.args.iter().any(|arg| arg == "--net") == status.network_active);
-        }
-    }
-}

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

@@ -5,15 +5,16 @@ use std::collections::{BTreeMap, BTreeSet};
 use std::env;
 use std::fs;
 use std::io::{self, Read, Write};
-use std::net::TcpListener;
+use std::net::{TcpListener, TcpStream, ToSocketAddrs};
 use std::path::{Path, PathBuf};
 use std::process::Command;
-use std::time::{SystemTime, UNIX_EPOCH};
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
 use api::{
-    resolve_startup_auth_source, AnthropicClient, AuthSource, ContentBlockDelta, InputContentBlock,
+    oauth_token_is_expired, resolve_startup_auth_source, AnthropicClient, ApiError, AuthSource,
-    InputMessage, MessageRequest, MessageResponse, OutputContentBlock,
+    ContentBlockDelta, InputContentBlock, InputMessage, MessageRequest, MessageResponse,
-    StreamEvent as ApiStreamEvent, ToolChoice, ToolDefinition, ToolResultContentBlock,
+    OutputContentBlock, StreamEvent as ApiStreamEvent, ToolChoice, ToolDefinition,
+    ToolResultContentBlock,
 };
 
 use commands::{
@@ -22,10 +23,11 @@ use commands::{
 use compat_harness::{extract_manifest, UpstreamPaths};
 use render::{Spinner, TerminalRenderer};
 use runtime::{
-    clear_oauth_credentials, generate_pkce_pair, generate_state, load_system_prompt,
+    clear_oauth_credentials, generate_pkce_pair, generate_state, load_oauth_credentials,
-    parse_oauth_callback_request_target, resolve_sandbox_status, save_oauth_credentials, ApiClient,
+    load_system_prompt, parse_oauth_callback_request_target, save_oauth_credentials, ApiClient,
     ApiRequest, AssistantEvent, CompactionConfig, ConfigLoader, ConfigSource, ContentBlock,
-    ConversationMessage, ConversationRuntime, MessageRole, OAuthAuthorizationRequest,
+    ConversationMessage, ConversationRuntime, McpClientBootstrap, McpClientTransport,
+    McpServerConfig, McpStdioProcess, MessageRole, OAuthAuthorizationRequest,
     OAuthTokenExchangeRequest, PermissionMode, PermissionPolicy, ProjectContext, RuntimeError,
     Session, TokenUsage, ToolError, ToolExecutor, UsageTracker,
 };
@@ -74,6 +76,7 @@ fn run() -> Result<(), Box<dyn std::error::Error>> {
             .run_turn_with_output(&prompt, output_format)?,
         CliAction::Login => run_login()?,
         CliAction::Logout => run_logout()?,
+        CliAction::Doctor => run_doctor()?,
         CliAction::Repl {
             model,
             allowed_tools,
@@ -106,6 +109,7 @@ enum CliAction {
     },
     Login,
     Logout,
+    Doctor,
     Repl {
         model: String,
         allowed_tools: Option<AllowedToolSet>,
@@ -230,6 +234,7 @@ fn parse_args(args: &[String]) -> Result<CliAction, String> {
         "system-prompt" => parse_system_prompt_args(&rest[1..]),
         "login" => Ok(CliAction::Login),
         "logout" => Ok(CliAction::Logout),
+        "doctor" => Ok(CliAction::Doctor),
         "prompt" => {
             let prompt = rest[1..].join(" ");
             if prompt.trim().is_empty() {
@@ -520,6 +525,627 @@ fn wait_for_oauth_callback(
     Ok(callback)
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum DiagnosticLevel {
+    Ok,
+    Warn,
+    Fail,
+}
+
+impl DiagnosticLevel {
+    const fn label(self) -> &'static str {
+        match self {
+            Self::Ok => "OK",
+            Self::Warn => "WARN",
+            Self::Fail => "FAIL",
+        }
+    }
+
+    const fn is_failure(self) -> bool {
+        matches!(self, Self::Fail)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct DiagnosticCheck {
+    name: &'static str,
+    level: DiagnosticLevel,
+    summary: String,
+    details: Vec<String>,
+}
+
+impl DiagnosticCheck {
+    fn new(name: &'static str, level: DiagnosticLevel, summary: impl Into<String>) -> Self {
+        Self {
+            name,
+            level,
+            summary: summary.into(),
+            details: Vec::new(),
+        }
+    }
+
+    fn with_details(mut self, details: Vec<String>) -> Self {
+        self.details = details;
+        self
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+enum OAuthDiagnosticStatus {
+    Missing,
+    Valid,
+    ExpiredRefreshable,
+    ExpiredNoRefresh,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct ConfigFileCheck {
+    path: PathBuf,
+    exists: bool,
+    valid: bool,
+    note: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct DoctorReport {
+    checks: Vec<DiagnosticCheck>,
+}
+
+impl DoctorReport {
+    fn has_failures(&self) -> bool {
+        self.checks.iter().any(|check| check.level.is_failure())
+    }
+
+    fn render(&self) -> String {
+        let mut lines = vec!["Doctor diagnostics".to_string()];
+        let ok_count = self
+            .checks
+            .iter()
+            .filter(|check| check.level == DiagnosticLevel::Ok)
+            .count();
+        let warn_count = self
+            .checks
+            .iter()
+            .filter(|check| check.level == DiagnosticLevel::Warn)
+            .count();
+        let fail_count = self
+            .checks
+            .iter()
+            .filter(|check| check.level == DiagnosticLevel::Fail)
+            .count();
+        lines.push(format!(
+            "Summary\n  OK               {ok_count}\n  Warnings         {warn_count}\n  Failures         {fail_count}"
+        ));
+        lines.extend(self.checks.iter().map(render_diagnostic_check));
+        lines.join("\n\n")
+    }
+}
+
+fn render_diagnostic_check(check: &DiagnosticCheck) -> String {
+    let mut section = vec![format!(
+        "{}\n  Status           {}\n  Summary          {}",
+        check.name,
+        check.level.label(),
+        check.summary
+    )];
+    if !check.details.is_empty() {
+        section.push("  Details".to_string());
+        section.extend(check.details.iter().map(|detail| format!("    - {detail}")));
+    }
+    section.join("\n")
+}
+
+fn run_doctor() -> Result<(), Box<dyn std::error::Error>> {
+    let cwd = env::current_dir()?;
+    let config_loader = ConfigLoader::default_for(&cwd);
+    let config = config_loader.load();
+    let report = DoctorReport {
+        checks: vec![
+            check_api_key_validity(config.as_ref().ok()),
+            check_oauth_token_status(config.as_ref().ok()),
+            check_config_files(&config_loader, config.as_ref()),
+            check_git_availability(&cwd),
+            check_mcp_server_health(config.as_ref().ok()),
+            check_network_connectivity(),
+            check_system_info(&cwd, config.as_ref().ok()),
+        ],
+    };
+    println!("{}", report.render());
+    if report.has_failures() {
+        return Err("doctor found failing checks".into());
+    }
+    Ok(())
+}
+
+fn check_api_key_validity(config: Option<&runtime::RuntimeConfig>) -> DiagnosticCheck {
+    let api_key = match env::var("ANTHROPIC_API_KEY") {
+        Ok(value) if !value.trim().is_empty() => value,
+        Ok(_) | Err(env::VarError::NotPresent) => {
+            return DiagnosticCheck::new(
+                "API key validity",
+                DiagnosticLevel::Warn,
+                "ANTHROPIC_API_KEY is not set",
+            );
+        }
+        Err(error) => {
+            return DiagnosticCheck::new(
+                "API key validity",
+                DiagnosticLevel::Fail,
+                format!("failed to read ANTHROPIC_API_KEY: {error}"),
+            );
+        }
+    };
+
+    let request = MessageRequest {
+        model: config
+            .and_then(runtime::RuntimeConfig::model)
+            .unwrap_or(DEFAULT_MODEL)
+            .to_string(),
+        max_tokens: 1,
+        messages: vec![InputMessage {
+            role: "user".to_string(),
+            content: vec![InputContentBlock::Text {
+                text: "Reply with OK.".to_string(),
+            }],
+        }],
+        system: None,
+        tools: None,
+        tool_choice: None,
+        stream: false,
+    };
+    let runtime = match tokio::runtime::Runtime::new() {
+        Ok(runtime) => runtime,
+        Err(error) => {
+            return DiagnosticCheck::new(
+                "API key validity",
+                DiagnosticLevel::Fail,
+                format!("failed to create async runtime: {error}"),
+            );
+        }
+    };
+    match runtime
+        .block_on(AnthropicClient::from_auth(AuthSource::ApiKey(api_key)).send_message(&request))
+    {
+        Ok(response) => DiagnosticCheck::new(
+            "API key validity",
+            DiagnosticLevel::Ok,
+            "Anthropic API accepted the configured API key",
+        )
+        .with_details(vec![format!(
+            "request_id={} input_tokens={} output_tokens={}",
+            response.request_id.unwrap_or_else(|| "<none>".to_string()),
+            response.usage.input_tokens,
+            response.usage.output_tokens
+        )]),
+        Err(ApiError::Api { status, .. }) if status.as_u16() == 401 || status.as_u16() == 403 => {
+            DiagnosticCheck::new(
+                "API key validity",
+                DiagnosticLevel::Fail,
+                format!("Anthropic API rejected the API key with HTTP {status}"),
+            )
+        }
+        Err(error) => DiagnosticCheck::new(
+            "API key validity",
+            DiagnosticLevel::Warn,
+            format!("unable to conclusively validate the API key: {error}"),
+        ),
+    }
+}
+
+fn classify_oauth_status() -> Result<(OAuthDiagnosticStatus, Vec<String>), io::Error> {
+    let Some(token_set) = load_oauth_credentials()? else {
+        return Ok((OAuthDiagnosticStatus::Missing, vec![]));
+    };
+    let token = api::OAuthTokenSet {
+        access_token: token_set.access_token.clone(),
+        refresh_token: token_set.refresh_token.clone(),
+        expires_at: token_set.expires_at,
+        scopes: token_set.scopes.clone(),
+    };
+    let details = vec![format!(
+        "expires_at={} refresh_token={} scopes={}",
+        token
+            .expires_at
+            .map_or_else(|| "<none>".to_string(), |value| value.to_string()),
+        if token.refresh_token.is_some() {
+            "present"
+        } else {
+            "absent"
+        },
+        if token.scopes.is_empty() {
+            "<none>".to_string()
+        } else {
+            token.scopes.join(",")
+        }
+    )];
+    let status = if oauth_token_is_expired(&token) {
+        if token.refresh_token.is_some() {
+            OAuthDiagnosticStatus::ExpiredRefreshable
+        } else {
+            OAuthDiagnosticStatus::ExpiredNoRefresh
+        }
+    } else {
+        OAuthDiagnosticStatus::Valid
+    };
+    Ok((status, details))
+}
+
+fn check_oauth_token_status(config: Option<&runtime::RuntimeConfig>) -> DiagnosticCheck {
+    match classify_oauth_status() {
+        Ok((OAuthDiagnosticStatus::Missing, _)) => DiagnosticCheck::new(
+            "OAuth token status",
+            DiagnosticLevel::Warn,
+            "no saved OAuth credentials found",
+        ),
+        Ok((OAuthDiagnosticStatus::Valid, details)) => DiagnosticCheck::new(
+            "OAuth token status",
+            DiagnosticLevel::Ok,
+            "saved OAuth token is present and not expired",
+        )
+        .with_details(details),
+        Ok((OAuthDiagnosticStatus::ExpiredRefreshable, mut details)) => {
+            let refresh_ready = config.and_then(runtime::RuntimeConfig::oauth).is_some();
+            details.push(if refresh_ready {
+                "runtime OAuth config is present for refresh".to_string()
+            } else {
+                "runtime OAuth config is missing for refresh".to_string()
+            });
+            DiagnosticCheck::new(
+                "OAuth token status",
+                if refresh_ready {
+                    DiagnosticLevel::Warn
+                } else {
+                    DiagnosticLevel::Fail
+                },
+                "saved OAuth token is expired but includes a refresh token",
+            )
+            .with_details(details)
+        }
+        Ok((OAuthDiagnosticStatus::ExpiredNoRefresh, details)) => DiagnosticCheck::new(
+            "OAuth token status",
+            DiagnosticLevel::Fail,
+            "saved OAuth token is expired and cannot refresh",
+        )
+        .with_details(details),
+        Err(error) => DiagnosticCheck::new(
+            "OAuth token status",
+            DiagnosticLevel::Fail,
+            format!("failed to read saved OAuth credentials: {error}"),
+        ),
+    }
+}
+
+fn validate_config_file(path: &Path) -> ConfigFileCheck {
+    match fs::read_to_string(path) {
+        Ok(contents) => {
+            if contents.trim().is_empty() {
+                return ConfigFileCheck {
+                    path: path.to_path_buf(),
+                    exists: true,
+                    valid: true,
+                    note: "exists but is empty".to_string(),
+                };
+            }
+            match serde_json::from_str::<serde_json::Value>(&contents) {
+                Ok(serde_json::Value::Object(_)) => ConfigFileCheck {
+                    path: path.to_path_buf(),
+                    exists: true,
+                    valid: true,
+                    note: "valid JSON object".to_string(),
+                },
+                Ok(_) => ConfigFileCheck {
+                    path: path.to_path_buf(),
+                    exists: true,
+                    valid: false,
+                    note: "top-level JSON value is not an object".to_string(),
+                },
+                Err(error) => ConfigFileCheck {
+                    path: path.to_path_buf(),
+                    exists: true,
+                    valid: false,
+                    note: format!("invalid JSON: {error}"),
+                },
+            }
+        }
+        Err(error) if error.kind() == io::ErrorKind::NotFound => ConfigFileCheck {
+            path: path.to_path_buf(),
+            exists: false,
+            valid: true,
+            note: "not present".to_string(),
+        },
+        Err(error) => ConfigFileCheck {
+            path: path.to_path_buf(),
+            exists: true,
+            valid: false,
+            note: format!("unreadable: {error}"),
+        },
+    }
+}
+
+fn check_config_files(
+    config_loader: &ConfigLoader,
+    config: Result<&runtime::RuntimeConfig, &runtime::ConfigError>,
+) -> DiagnosticCheck {
+    let file_checks = config_loader
+        .discover()
+        .into_iter()
+        .map(|entry| validate_config_file(&entry.path))
+        .collect::<Vec<_>>();
+    let existing_count = file_checks.iter().filter(|check| check.exists).count();
+    let invalid_count = file_checks
+        .iter()
+        .filter(|check| check.exists && !check.valid)
+        .count();
+    let mut details = file_checks
+        .iter()
+        .map(|check| format!("{} => {}", check.path.display(), check.note))
+        .collect::<Vec<_>>();
+    match config {
+        Ok(runtime_config) => details.push(format!(
+            "merged load succeeded with {} loaded file(s)",
+            runtime_config.loaded_entries().len()
+        )),
+        Err(error) => details.push(format!("merged load failed: {error}")),
+    }
+    DiagnosticCheck::new(
+        "Config files",
+        if invalid_count > 0 || config.is_err() {
+            DiagnosticLevel::Fail
+        } else if existing_count == 0 {
+            DiagnosticLevel::Warn
+        } else {
+            DiagnosticLevel::Ok
+        },
+        format!(
+            "discovered {} candidate file(s), {} existing, {} invalid",
+            file_checks.len(),
+            existing_count,
+            invalid_count
+        ),
+    )
+    .with_details(details)
+}
+
+fn check_git_availability(cwd: &Path) -> DiagnosticCheck {
+    match Command::new("git").arg("--version").output() {
+        Ok(version_output) if version_output.status.success() => {
+            let version = String::from_utf8_lossy(&version_output.stdout)
+                .trim()
+                .to_string();
+            match Command::new("git")
+                .args(["rev-parse", "--show-toplevel"])
+                .current_dir(cwd)
+                .output()
+            {
+                Ok(root_output) if root_output.status.success() => DiagnosticCheck::new(
+                    "Git availability",
+                    DiagnosticLevel::Ok,
+                    "git is installed and the current directory is inside a repository",
+                )
+                .with_details(vec![
+                    version,
+                    format!(
+                        "repo_root={}",
+                        String::from_utf8_lossy(&root_output.stdout).trim()
+                    ),
+                ]),
+                Ok(_) => DiagnosticCheck::new(
+                    "Git availability",
+                    DiagnosticLevel::Warn,
+                    "git is installed but the current directory is not a repository",
+                )
+                .with_details(vec![version]),
+                Err(error) => DiagnosticCheck::new(
+                    "Git availability",
+                    DiagnosticLevel::Warn,
+                    format!("git is installed but repo detection failed: {error}"),
+                )
+                .with_details(vec![version]),
+            }
+        }
+        Ok(output) => DiagnosticCheck::new(
+            "Git availability",
+            DiagnosticLevel::Fail,
+            format!("git --version exited with status {}", output.status),
+        ),
+        Err(error) => DiagnosticCheck::new(
+            "Git availability",
+            DiagnosticLevel::Fail,
+            format!("failed to execute git: {error}"),
+        ),
+    }
+}
+
+fn check_one_mcp_server(
+    name: &str,
+    server: &runtime::ScopedMcpServerConfig,
+) -> (DiagnosticLevel, String) {
+    match &server.config {
+        McpServerConfig::Stdio(_) => {
+            let bootstrap = McpClientBootstrap::from_scoped_config(name, server);
+            let runtime = match tokio::runtime::Builder::new_current_thread()
+                .enable_all()
+                .build()
+            {
+                Ok(runtime) => runtime,
+                Err(error) => {
+                    return (
+                        DiagnosticLevel::Fail,
+                        format!("{name}: runtime error: {error}"),
+                    )
+                }
+            };
+            let detail = runtime.block_on(async {
+                match tokio::time::timeout(Duration::from_secs(3), async {
+                    let mut process = McpStdioProcess::spawn(match &bootstrap.transport {
+                        McpClientTransport::Stdio(transport) => transport,
+                        _ => unreachable!("stdio bootstrap expected"),
+                    })?;
+                    let result = process
+                        .initialize(
+                            runtime::JsonRpcId::Number(1),
+                            runtime::McpInitializeParams {
+                                protocol_version: "2025-03-26".to_string(),
+                                capabilities: serde_json::Value::Object(serde_json::Map::new()),
+                                client_info: runtime::McpInitializeClientInfo {
+                                    name: "doctor".to_string(),
+                                    version: VERSION.to_string(),
+                                },
+                            },
+                        )
+                        .await;
+                    let _ = process.terminate().await;
+                    result
+                })
+                .await
+                {
+                    Ok(Ok(response)) => {
+                        if let Some(error) = response.error {
+                            (
+                                DiagnosticLevel::Fail,
+                                format!(
+                                    "{name}: initialize JSON-RPC error {} ({})",
+                                    error.message, error.code
+                                ),
+                            )
+                        } else if let Some(result) = response.result {
+                            (
+                                DiagnosticLevel::Ok,
+                                format!(
+                                    "{name}: ok (server {} {})",
+                                    result.server_info.name, result.server_info.version
+                                ),
+                            )
+                        } else {
+                            (
+                                DiagnosticLevel::Fail,
+                                format!("{name}: initialize returned no result"),
+                            )
+                        }
+                    }
+                    Ok(Err(error)) => (
+                        DiagnosticLevel::Fail,
+                        format!("{name}: spawn/initialize failed: {error}"),
+                    ),
+                    Err(_) => (
+                        DiagnosticLevel::Fail,
+                        format!("{name}: timed out during initialize"),
+                    ),
+                }
+            });
+            detail
+        }
+        other => (
+            DiagnosticLevel::Warn,
+            format!(
+                "{name}: transport {:?} configured (active health probe not implemented)",
+                other.transport()
+            ),
+        ),
+    }
+}
+
+fn check_mcp_server_health(config: Option<&runtime::RuntimeConfig>) -> DiagnosticCheck {
+    let Some(config) = config else {
+        return DiagnosticCheck::new(
+            "MCP server health",
+            DiagnosticLevel::Warn,
+            "runtime config could not be loaded, so MCP servers were not inspected",
+        );
+    };
+    let servers = config.mcp().servers();
+    if servers.is_empty() {
+        return DiagnosticCheck::new(
+            "MCP server health",
+            DiagnosticLevel::Warn,
+            "no MCP servers are configured",
+        );
+    }
+    let results = servers
+        .iter()
+        .map(|(name, server)| check_one_mcp_server(name, server))
+        .collect::<Vec<_>>();
+    let level = if results
+        .iter()
+        .any(|(level, _)| *level == DiagnosticLevel::Fail)
+    {
+        DiagnosticLevel::Fail
+    } else if results
+        .iter()
+        .any(|(level, _)| *level == DiagnosticLevel::Warn)
+    {
+        DiagnosticLevel::Warn
+    } else {
+        DiagnosticLevel::Ok
+    };
+    DiagnosticCheck::new(
+        "MCP server health",
+        level,
+        format!("checked {} configured MCP server(s)", servers.len()),
+    )
+    .with_details(results.into_iter().map(|(_, detail)| detail).collect())
+}
+
+fn check_network_connectivity() -> DiagnosticCheck {
+    let address = match ("api.anthropic.com", 443).to_socket_addrs() {
+        Ok(mut addrs) => match addrs.next() {
+            Some(addr) => addr,
+            None => {
+                return DiagnosticCheck::new(
+                    "Network connectivity",
+                    DiagnosticLevel::Fail,
+                    "DNS resolution returned no addresses for api.anthropic.com",
+                );
+            }
+        },
+        Err(error) => {
+            return DiagnosticCheck::new(
+                "Network connectivity",
+                DiagnosticLevel::Fail,
+                format!("failed to resolve api.anthropic.com: {error}"),
+            );
+        }
+    };
+    match TcpStream::connect_timeout(&address, Duration::from_secs(5)) {
+        Ok(stream) => {
+            let _ = stream.shutdown(std::net::Shutdown::Both);
+            DiagnosticCheck::new(
+                "Network connectivity",
+                DiagnosticLevel::Ok,
+                format!("connected to {address}"),
+            )
+        }
+        Err(error) => DiagnosticCheck::new(
+            "Network connectivity",
+            DiagnosticLevel::Fail,
+            format!("failed to connect to {address}: {error}"),
+        ),
+    }
+}
+
+fn check_system_info(cwd: &Path, config: Option<&runtime::RuntimeConfig>) -> DiagnosticCheck {
+    let mut details = vec![
+        format!("os={} arch={}", env::consts::OS, env::consts::ARCH),
+        format!("cwd={}", cwd.display()),
+        format!("cli_version={VERSION}"),
+        format!("build_target={}", BUILD_TARGET.unwrap_or("<unknown>")),
+        format!("git_sha={}", GIT_SHA.unwrap_or("<unknown>")),
+    ];
+    if let Some(config) = config {
+        details.push(format!(
+            "resolved_model={} loaded_config_files={}",
+            config.model().unwrap_or(DEFAULT_MODEL),
+            config.loaded_entries().len()
+        ));
+    }
+    DiagnosticCheck::new(
+        "System info",
+        DiagnosticLevel::Ok,
+        "captured local runtime and build metadata",
+    )
+    .with_details(details)
+}
+
 fn print_system_prompt(cwd: PathBuf, date: String) {
     match load_system_prompt(cwd, date, env::consts::OS, "unknown") {
         Ok(sections) => println!("{}", sections.join("\n\n")),
@@ -591,7 +1217,6 @@ struct StatusContext {
     memory_file_count: usize,
     project_root: Option<PathBuf>,
     git_branch: Option<String>,
-    sandbox_status: runtime::SandboxStatus,
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -841,18 +1466,6 @@ fn run_resume_command(
                 )),
             })
         }
-        SlashCommand::Sandbox => {
-            let cwd = env::current_dir()?;
-            let loader = ConfigLoader::default_for(&cwd);
-            let runtime_config = loader.load()?;
-            Ok(ResumeCommandOutcome {
-                session: session.clone(),
-                message: Some(format_sandbox_report(&resolve_sandbox_status(
-                    runtime_config.sandbox(),
-                    &cwd,
-                ))),
-            })
-        }
         SlashCommand::Cost => {
             let usage = UsageTracker::from_session(session).cumulative_usage();
             Ok(ResumeCommandOutcome {
@@ -1104,10 +1717,6 @@ impl LiveCli {
                 self.print_status();
                 false
             }
-            SlashCommand::Sandbox => {
-                Self::print_sandbox_status();
-                false
-            }
             SlashCommand::Compact => {
                 self.compact()?;
                 false
@@ -1179,18 +1788,6 @@ impl LiveCli {
         );
     }
 
-    fn print_sandbox_status() {
-        let cwd = env::current_dir().expect("current dir");
-        let loader = ConfigLoader::default_for(&cwd);
-        let runtime_config = loader
-            .load()
-            .unwrap_or_else(|_| runtime::RuntimeConfig::empty());
-        println!(
-            "{}",
-            format_sandbox_report(&resolve_sandbox_status(runtime_config.sandbox(), &cwd))
-        );
-    }
-
     fn set_model(&mut self, model: Option<String>) -> Result<bool, Box<dyn std::error::Error>> {
         let Some(model) = model else {
             println!(
@@ -1566,7 +2163,6 @@ fn status_context(
     let project_context = ProjectContext::discover_with_git(&cwd, DEFAULT_DATE)?;
     let (project_root, git_branch) =
         parse_git_status_metadata(project_context.git_status.as_deref());
-    let sandbox_status = resolve_sandbox_status(runtime_config.sandbox(), &cwd);
     Ok(StatusContext {
         cwd,
         session_path: session_path.map(Path::to_path_buf),
@@ -1575,7 +2171,6 @@ fn status_context(
         memory_file_count: project_context.instruction_files.len(),
         project_root,
         git_branch,
-        sandbox_status,
     })
 }
 
@@ -1628,7 +2223,6 @@ fn format_status_report(
             context.discovered_config_files,
             context.memory_file_count,
         ),
-        format_sandbox_report(&context.sandbox_status),
     ]
     .join(
         "
@@ -1637,49 +2231,6 @@ fn format_status_report(
     )
 }
 
-fn format_sandbox_report(status: &runtime::SandboxStatus) -> String {
-    format!(
-        "Sandbox
-  Enabled           {}
-  Active            {}
-  Supported         {}
-  In container      {}
-  Requested ns      {}
-  Active ns         {}
-  Requested net     {}
-  Active net        {}
-  Filesystem mode   {}
-  Filesystem active {}
-  Allowed mounts    {}
-  Markers           {}
-  Fallback reason   {}",
-        status.enabled,
-        status.active,
-        status.supported,
-        status.in_container,
-        status.requested.namespace_restrictions,
-        status.namespace_active,
-        status.requested.network_isolation,
-        status.network_active,
-        status.filesystem_mode.as_str(),
-        status.filesystem_active,
-        if status.allowed_mounts.is_empty() {
-            "<none>".to_string()
-        } else {
-            status.allowed_mounts.join(", ")
-        },
-        if status.container_markers.is_empty() {
-            "<none>".to_string()
-        } else {
-            status.container_markers.join(", ")
-        },
-        status
-            .fallback_reason
-            .clone()
-            .unwrap_or_else(|| "<none>".to_string()),
-    )
-}
-
 fn render_config_report(section: Option<&str>) -> Result<String, Box<dyn std::error::Error>> {
     let cwd = env::current_dir()?;
     let loader = ConfigLoader::default_for(&cwd);
@@ -2433,6 +2984,7 @@ fn print_help() {
     println!("  rusty-claude-cli system-prompt [--cwd PATH] [--date YYYY-MM-DD]");
     println!("  rusty-claude-cli login");
     println!("  rusty-claude-cli logout");
+    println!("  rusty-claude-cli doctor");
     println!();
     println!("Flags:");
     println!("  --model MODEL              Override the active model");
@@ -2459,6 +3011,7 @@ fn print_help() {
     println!("  rusty-claude-cli --allowedTools read,glob \"summarize Cargo.toml\"");
     println!("  rusty-claude-cli --resume session.json /status /diff /export notes.txt");
     println!("  rusty-claude-cli login");
+    println!("  rusty-claude-cli doctor");
 }
 
 #[cfg(test)]
@@ -2600,7 +3153,7 @@ mod tests {
     }
 
     #[test]
-    fn parses_login_and_logout_subcommands() {
+    fn parses_login_logout_and_doctor_subcommands() {
         assert_eq!(
             parse_args(&["login".to_string()]).expect("login should parse"),
             CliAction::Login
@@ -2609,6 +3162,10 @@ mod tests {
             parse_args(&["logout".to_string()]).expect("logout should parse"),
             CliAction::Logout
         );
+        assert_eq!(
+            parse_args(&["doctor".to_string()]).expect("doctor should parse"),
+            CliAction::Doctor
+        );
     }
 
     #[test]
@@ -2676,7 +3233,6 @@ mod tests {
         assert!(help.contains("REPL"));
         assert!(help.contains("/help"));
         assert!(help.contains("/status"));
-        assert!(help.contains("/sandbox"));
         assert!(help.contains("/model [model]"));
         assert!(help.contains("/permissions [read-only|workspace-write|danger-full-access]"));
         assert!(help.contains("/clear [--confirm]"));
@@ -2701,8 +3257,8 @@ mod tests {
         assert_eq!(
             names,
             vec![
-                "help", "status", "sandbox", "compact", "clear", "cost", "config", "memory",
+                "help", "status", "compact", "clear", "cost", "config", "memory", "init", "diff",
-                "init", "diff", "version", "export",
+                "version", "export",
             ]
         );
     }
@@ -2820,7 +3376,6 @@ mod tests {
                 memory_file_count: 4,
                 project_root: Some(PathBuf::from("/tmp")),
                 git_branch: Some("main".to_string()),
-                sandbox_status: runtime::SandboxStatus::default(),
             },
         );
         assert!(status.contains("Status"));
@@ -2971,6 +3526,87 @@ mod tests {
         assert!(help.contains("Shift+Enter/Ctrl+J"));
     }
 
+    #[test]
+    fn oauth_status_classifies_missing_and_expired_tokens() {
+        let root = std::env::temp_dir().join(format!(
+            "doctor-oauth-status-{}",
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .expect("time")
+                .as_nanos()
+        ));
+        std::fs::create_dir_all(&root).expect("temp dir");
+        std::env::set_var("CLAUDE_CONFIG_HOME", &root);
+
+        assert_eq!(
+            super::classify_oauth_status()
+                .expect("missing should classify")
+                .0,
+            super::OAuthDiagnosticStatus::Missing
+        );
+
+        runtime::save_oauth_credentials(&runtime::OAuthTokenSet {
+            access_token: "token".to_string(),
+            refresh_token: Some("refresh".to_string()),
+            expires_at: Some(1),
+            scopes: vec!["scope:a".to_string()],
+        })
+        .expect("save oauth");
+        assert_eq!(
+            super::classify_oauth_status()
+                .expect("expired should classify")
+                .0,
+            super::OAuthDiagnosticStatus::ExpiredRefreshable
+        );
+
+        runtime::clear_oauth_credentials().expect("clear oauth");
+        std::fs::remove_dir_all(&root).expect("cleanup");
+        std::env::remove_var("CLAUDE_CONFIG_HOME");
+    }
+
+    #[test]
+    fn config_validation_flags_invalid_json() {
+        let root = std::env::temp_dir().join(format!(
+            "doctor-config-{}",
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .expect("time")
+                .as_nanos()
+        ));
+        std::fs::create_dir_all(&root).expect("temp dir");
+        let path = root.join("settings.json");
+        std::fs::write(&path, "[]").expect("write invalid top-level");
+        let check = super::validate_config_file(&path);
+        assert!(check.exists);
+        assert!(!check.valid);
+        assert!(check.note.contains("not an object"));
+        std::fs::remove_dir_all(&root).expect("cleanup");
+    }
+
+    #[test]
+    fn doctor_report_renders_requested_sections() {
+        let report = super::DoctorReport {
+            checks: vec![
+                super::DiagnosticCheck::new(
+                    "API key validity",
+                    super::DiagnosticLevel::Ok,
+                    "accepted",
+                ),
+                super::DiagnosticCheck::new(
+                    "System info",
+                    super::DiagnosticLevel::Warn,
+                    "captured",
+                )
+                .with_details(vec!["os=linux".to_string()]),
+            ],
+        };
+        let rendered = report.render();
+        assert!(rendered.contains("Doctor diagnostics"));
+        assert!(rendered.contains("API key validity"));
+        assert!(rendered.contains("System info"));
+        assert!(rendered.contains("Warnings         1"));
+    }
+
     #[test]
     fn tool_rendering_helpers_compact_output() {
         let start = format_tool_call_start("read_file", r#"{"path":"src/main.rs"}"#);
@@ -2982,17 +3618,3 @@ mod tests {
         assert!(done.contains("contents"));
     }
 }
-
-#[cfg(test)]
-mod sandbox_report_tests {
-    use super::format_sandbox_report;
-
-    #[test]
-    fn sandbox_report_renders_expected_fields() {
-        let report = format_sandbox_report(&runtime::SandboxStatus::default());
-        assert!(report.contains("Sandbox"));
-        assert!(report.contains("Enabled"));
-        assert!(report.contains("Filesystem mode"));
-        assert!(report.contains("Fallback reason"));
-    }
-}

rust/crates/tools/src/lib.rs

@@ -62,11 +62,7 @@ pub fn mvp_tool_specs() -> Vec<ToolSpec> {
                     "timeout": { "type": "integer", "minimum": 1 },
                     "description": { "type": "string" },
                     "run_in_background": { "type": "boolean" },
-                    "dangerouslyDisableSandbox": { "type": "boolean" },
+                    "dangerouslyDisableSandbox": { "type": "boolean" }
-                    "namespaceRestrictions": { "type": "boolean" },
-                    "isolateNetwork": { "type": "boolean" },
-                    "filesystemMode": { "type": "string", "enum": ["off", "workspace-only", "allow-list"] },
-                    "allowedMounts": { "type": "array", "items": { "type": "string" } }
                 },
                 "required": ["command"],
                 "additionalProperties": false
@@ -2218,7 +2214,6 @@ fn execute_shell_command(
             structured_content: None,
             persisted_output_path: None,
             persisted_output_size: None,
-            sandbox_status: None,
         });
     }
 
@@ -2256,7 +2251,6 @@ fn execute_shell_command(
                     structured_content: None,
                     persisted_output_path: None,
                     persisted_output_size: None,
-                    sandbox_status: None,
                 });
             }
             if started.elapsed() >= Duration::from_millis(timeout_ms) {
@@ -2287,7 +2281,6 @@ Command exceeded timeout of {timeout_ms} ms",
                     structured_content: None,
                     persisted_output_path: None,
                     persisted_output_size: None,
-                    sandbox_status: None,
                 });
             }
             std::thread::sleep(Duration::from_millis(10));
@@ -2314,7 +2307,6 @@ Command exceeded timeout of {timeout_ms} ms",
         structured_content: None,
         persisted_output_path: None,
         persisted_output_size: None,
-        sandbox_status: None,
     })
 }