An agent-managed museum exhibit, built in Rust with Gajae-Code / LazyCodex — developed and maintained with no human intervention.
Rust
Keep doctor and local help paths shell-native
Yeachan-Heo30883bddbd12
diff --git a/rust/crates/rusty-claude-cli/src/main.rs b/rust/crates/rusty-claude-cli/src/main.rsindex 81700722..dbf9311e 100644--- a/rust/crates/rusty-claude-cli/src/main.rs+++ b/rust/crates/rusty-claude-cli/src/main.rs@@ -24,9 +24,10 @@ use std::thread::{self, JoinHandle};use std::time::{Duration, Instant, UNIX_EPOCH};use api::{- resolve_startup_auth_source, AnthropicClient, AuthSource, ContentBlockDelta, InputContentBlock,- InputMessage, MessageRequest, MessageResponse, OutputContentBlock, PromptCache,- StreamEvent as ApiStreamEvent, ToolChoice, ToolDefinition, ToolResultContentBlock,+ oauth_token_is_expired, resolve_startup_auth_source, AnthropicClient, AuthSource,+ ContentBlockDelta, InputContentBlock, InputMessage, MessageRequest, MessageResponse,+ OutputContentBlock, PromptCache, StreamEvent as ApiStreamEvent, ToolChoice, ToolDefinition,+ ToolResultContentBlock,};use commands::{@@ -39,14 +40,14 @@ use init::initialize_repo;use plugins::{PluginHooks, PluginManager, PluginManagerConfig, PluginRegistry};use render::{MarkdownStreamState, Spinner, TerminalRenderer};use runtime::{- clear_oauth_credentials, format_usd, generate_pkce_pair, generate_state, load_system_prompt,- parse_oauth_callback_request_target, pricing_for_model, resolve_sandbox_status,- save_oauth_credentials, ApiClient, ApiRequest, AssistantEvent, CompactionConfig, ConfigLoader,- ConfigSource, ContentBlock, ConversationMessage, ConversationRuntime, McpServerManager,- McpTool, MessageRole, ModelPricing, OAuthAuthorizationRequest, OAuthConfig,- OAuthTokenExchangeRequest, PermissionMode, PermissionPolicy, ProjectContext, PromptCacheEvent,- ResolvedPermissionMode, RuntimeError, Session, TokenUsage, ToolError, ToolExecutor,- UsageTracker,+ clear_oauth_credentials, format_usd, generate_pkce_pair, generate_state,+ load_oauth_credentials, load_system_prompt, parse_oauth_callback_request_target,+ pricing_for_model, resolve_sandbox_status, save_oauth_credentials, ApiClient, ApiRequest,+ AssistantEvent, CompactionConfig, ConfigLoader, ConfigSource, ContentBlock,+ ConversationMessage, ConversationRuntime, McpServerManager, McpTool, MessageRole, ModelPricing,+ OAuthAuthorizationRequest, OAuthConfig, OAuthTokenExchangeRequest, PermissionMode,+ PermissionPolicy, ProjectContext, PromptCacheEvent, ResolvedPermissionMode, RuntimeError,+ Session, TokenUsage, ToolError, ToolExecutor, UsageTracker,};use serde::Deserialize;use serde_json::json;@@ -133,12 +134,14 @@ 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::Init => run_init()?,CliAction::Repl {model,allowed_tools,permission_mode,} => run_repl(model, allowed_tools, permission_mode)?,+ CliAction::HelpTopic(topic) => print_help_topic(topic),CliAction::Help => print_help(),}Ok(())@@ -180,16 +183,25 @@ enum CliAction {},Login,Logout,+ Doctor,Init,Repl {model: String,allowed_tools: Option<AllowedToolSet>,permission_mode: PermissionMode,},+ HelpTopic(LocalHelpTopic),// prompt-mode formatting is only supported for non-interactive runsHelp,}+#[derive(Debug, Clone, Copy, PartialEq, Eq)]+enum LocalHelpTopic {+ Status,+ Sandbox,+ Doctor,+}+#[derive(Debug, Clone, Copy, PartialEq, Eq)]enum CliOutputFormat {Text,@@ -341,8 +353,10 @@ fn parse_args(args: &[String]) -> Result<CliAction, String> {if rest.first().map(String::as_str) == Some("--resume") {return parse_resume_args(&rest[1..]);}- if let Some(action) = parse_single_word_command_alias(&rest, &model, permission_mode_override)- {+ if let Some(action) = parse_local_help_action(&rest) {+ return action;+ }+ if let Some(action) = parse_single_word_command_alias(&rest, &model, permission_mode_override) {return action;}@@ -388,6 +402,24 @@ fn parse_args(args: &[String]) -> Result<CliAction, String> {}}+fn parse_local_help_action(rest: &[String]) -> Option<Result<CliAction, String>> {+ if rest.len() != 2 || !is_help_flag(&rest[1]) {+ return None;+ }++ let topic = match rest[0].as_str() {+ "status" => LocalHelpTopic::Status,+ "sandbox" => LocalHelpTopic::Sandbox,+ "doctor" => LocalHelpTopic::Doctor,+ _ => return None,+ };+ Some(Ok(CliAction::HelpTopic(topic)))+}++fn is_help_flag(value: &str) -> bool {+ matches!(value, "--help" | "-h")+}+fn parse_single_word_command_alias(rest: &[String],model: &str,@@ -405,6 +437,7 @@ fn parse_single_word_command_alias(permission_mode: permission_mode_override.unwrap_or_else(default_permission_mode),})),"sandbox" => Some(Ok(CliAction::Sandbox)),+ "doctor" => Some(Ok(CliAction::Doctor)),other => bare_slash_command_guidance(other).map(Err),}}@@ -741,6 +774,396 @@ fn parse_resume_args(args: &[String]) -> Result<CliAction, String> {})}+#[derive(Debug, Clone, Copy, PartialEq, Eq)]+enum DiagnosticLevel {+ Ok,+ Warn,+ Fail,+}++impl DiagnosticLevel {+ fn label(self) -> &'static str {+ match self {+ Self::Ok => "ok",+ Self::Warn => "warn",+ Self::Fail => "fail",+ }+ }++ 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)]+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 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();+ let mut lines = vec![+ "Doctor".to_string(),+ 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 lines = vec![format!(+ "{}\n Status {}\n Summary {}",+ check.name,+ check.level.label(),+ check.summary+ )];+ if !check.details.is_empty() {+ lines.push(" Details".to_string());+ lines.extend(check.details.iter().map(|detail| format!(" - {detail}")));+ }+ lines.join("\n")+}++fn render_doctor_report() -> Result<DoctorReport, Box<dyn std::error::Error>> {+ let cwd = env::current_dir()?;+ let config_loader = ConfigLoader::default_for(&cwd);+ let config = config_loader.load();+ let discovered_config = config_loader.discover();+ 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 git_summary = parse_git_workspace_summary(project_context.git_status.as_deref());+ let empty_config = runtime::RuntimeConfig::empty();+ let sandbox_config = config.as_ref().ok().unwrap_or(&empty_config);+ let context = StatusContext {+ cwd: cwd.clone(),+ session_path: None,+ loaded_config_files: config+ .as_ref()+ .ok()+ .map_or(0, |runtime_config| runtime_config.loaded_entries().len()),+ discovered_config_files: discovered_config.len(),+ memory_file_count: project_context.instruction_files.len(),+ project_root,+ git_branch,+ git_summary,+ sandbox_status: resolve_sandbox_status(sandbox_config.sandbox(), &cwd),+ };+ Ok(DoctorReport {+ checks: vec![+ check_auth_health(),+ check_config_health(&config_loader, config.as_ref()),+ check_workspace_health(&context),+ check_sandbox_health(&context.sandbox_status),+ check_system_health(&cwd, config.as_ref().ok()),+ ],+ })+}++fn run_doctor() -> Result<(), Box<dyn std::error::Error>> {+ let report = render_doctor_report()?;+ println!("{}", report.render());+ if report.has_failures() {+ return Err("doctor found failing checks".into());+ }+ Ok(())+}++fn check_auth_health() -> DiagnosticCheck {+ let api_key_present = env::var("ANTHROPIC_API_KEY")+ .ok()+ .is_some_and(|value| !value.trim().is_empty());+ let auth_token_present = env::var("ANTHROPIC_AUTH_TOKEN")+ .ok()+ .is_some_and(|value| !value.trim().is_empty());++ match load_oauth_credentials() {+ Ok(Some(token_set)) => {+ let expired = oauth_token_is_expired(&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 mut details = vec![+ format!(+ "Environment api_key={} auth_token={}",+ if api_key_present { "present" } else { "absent" },+ if auth_token_present {+ "present"+ } else {+ "absent"+ }+ ),+ format!(+ "Saved OAuth expires_at={} refresh_token={} scopes={}",+ token_set+ .expires_at+ .map_or_else(|| "<none>".to_string(), |value| value.to_string()),+ if token_set.refresh_token.is_some() {+ "present"+ } else {+ "absent"+ },+ if token_set.scopes.is_empty() {+ "<none>".to_string()+ } else {+ token_set.scopes.join(",")+ }+ ),+ ];+ if expired {+ details.push(+ "Suggested action claw login to refresh local OAuth credentials".to_string(),+ );+ }+ DiagnosticCheck::new(+ "Auth",+ if expired {+ DiagnosticLevel::Warn+ } else {+ DiagnosticLevel::Ok+ },+ if expired {+ "saved OAuth credentials are present but expired"+ } else if api_key_present || auth_token_present {+ "environment and saved credentials are available"+ } else {+ "saved OAuth credentials are available"+ },+ )+ .with_details(details)+ }+ Ok(None) => DiagnosticCheck::new(+ "Auth",+ if api_key_present || auth_token_present {+ DiagnosticLevel::Ok+ } else {+ DiagnosticLevel::Warn+ },+ if api_key_present || auth_token_present {+ "environment credentials are configured"+ } else {+ "no API key or saved OAuth credentials were found"+ },+ )+ .with_details(vec![format!(+ "Environment api_key={} auth_token={}",+ if api_key_present { "present" } else { "absent" },+ if auth_token_present {+ "present"+ } else {+ "absent"+ }+ )]),+ Err(error) => DiagnosticCheck::new(+ "Auth",+ DiagnosticLevel::Fail,+ format!("failed to inspect saved credentials: {error}"),+ ),+ }+}++fn check_config_health(+ config_loader: &ConfigLoader,+ config: Result<&runtime::RuntimeConfig, &runtime::ConfigError>,+) -> DiagnosticCheck {+ let discovered = config_loader.discover();+ let discovered_count = discovered.len();+ let discovered_paths = discovered+ .iter()+ .map(|entry| entry.path.display().to_string())+ .collect::<Vec<_>>();+ match config {+ Ok(runtime_config) => {+ let loaded_entries = runtime_config.loaded_entries();+ let mut details = vec![format!(+ "Config files loaded {}/{}",+ loaded_entries.len(),+ discovered_count+ )];+ if let Some(model) = runtime_config.model() {+ details.push(format!("Resolved model {model}"));+ }+ details.push(format!(+ "MCP servers {}",+ runtime_config.mcp().servers().len()+ ));+ if discovered_paths.is_empty() {+ details.push("Discovered files <none>".to_string());+ } else {+ details.extend(+ discovered_paths+ .into_iter()+ .map(|path| format!("Discovered file {path}")),+ );+ }+ DiagnosticCheck::new(+ "Config",+ if discovered_count == 0 {+ DiagnosticLevel::Warn+ } else {+ DiagnosticLevel::Ok+ },+ if discovered_count == 0 {+ "no config files were found; defaults are active"+ } else {+ "runtime config loaded successfully"+ },+ )+ .with_details(details)+ }+ Err(error) => DiagnosticCheck::new(+ "Config",+ DiagnosticLevel::Fail,+ format!("runtime config failed to load: {error}"),+ )+ .with_details(if discovered_paths.is_empty() {+ vec!["Discovered files <none>".to_string()]+ } else {+ discovered_paths+ .into_iter()+ .map(|path| format!("Discovered file {path}"))+ .collect()+ }),+ }+}++fn check_workspace_health(context: &StatusContext) -> DiagnosticCheck {+ let in_repo = context.project_root.is_some();+ DiagnosticCheck::new(+ "Workspace",+ if in_repo {+ DiagnosticLevel::Ok+ } else {+ DiagnosticLevel::Warn+ },+ if in_repo {+ format!(+ "project root detected on branch {}",+ context.git_branch.as_deref().unwrap_or("unknown")+ )+ } else {+ "current directory is not inside a git project".to_string()+ },+ )+ .with_details(vec![+ format!("Cwd {}", context.cwd.display()),+ format!(+ "Project root {}",+ context+ .project_root+ .as_ref()+ .map_or_else(|| "<none>".to_string(), |path| path.display().to_string())+ ),+ format!(+ "Git branch {}",+ context.git_branch.as_deref().unwrap_or("unknown")+ ),+ format!("Git state {}", context.git_summary.headline()),+ format!("Changed files {}", context.git_summary.changed_files),+ format!(+ "Memory files {} · config files loaded {}/{}",+ context.memory_file_count, context.loaded_config_files, context.discovered_config_files+ ),+ ])+}++fn check_sandbox_health(status: &runtime::SandboxStatus) -> DiagnosticCheck {+ let degraded = status.enabled && !status.active;+ let mut details = vec![+ format!("Enabled {}", status.enabled),+ format!("Active {}", status.active),+ format!("Supported {}", status.supported),+ format!("Filesystem mode {}", status.filesystem_mode.as_str()),+ format!("Filesystem live {}", status.filesystem_active),+ ];+ if let Some(reason) = &status.fallback_reason {+ details.push(format!("Fallback reason {reason}"));+ }+ DiagnosticCheck::new(+ "Sandbox",+ if degraded {+ DiagnosticLevel::Warn+ } else {+ DiagnosticLevel::Ok+ },+ if degraded {+ "sandbox was requested but is not currently active"+ } else if status.active {+ "sandbox protections are active"+ } else {+ "sandbox is not active for this session"+ },+ )+ .with_details(details)+}++fn check_system_health(cwd: &Path, config: Option<&runtime::RuntimeConfig>) -> DiagnosticCheck {+ let mut details = vec![+ format!("OS {} {}", env::consts::OS, env::consts::ARCH),+ format!("Working dir {}", cwd.display()),+ format!("Version {}", VERSION),+ format!("Build target {}", BUILD_TARGET.unwrap_or("<unknown>")),+ format!("Git SHA {}", GIT_SHA.unwrap_or("<unknown>")),+ ];+ if let Some(model) = config.and_then(runtime::RuntimeConfig::model) {+ details.push(format!("Default model {model}"));+ }+ DiagnosticCheck::new(+ "System",+ DiagnosticLevel::Ok,+ "captured local runtime metadata",+ )+ .with_details(details)+}+fn resume_command_can_absorb_token(current_command: &str, token: &str) -> bool {matches!(SlashCommand::parse(current_command),@@ -1468,6 +1891,10 @@ fn run_resume_command(message: Some(handle_skills_slash_command(args.as_deref(), &cwd)?),})}+ SlashCommand::Doctor => Ok(ResumeCommandOutcome {+ session: session.clone(),+ message: Some(render_doctor_report()?.render()),+ }),SlashCommand::Unknown(name) => Err(format_unknown_slash_command(name).into()),SlashCommand::Bughunter { .. }| SlashCommand::Commit { .. }@@ -1481,7 +1908,6 @@ fn run_resume_command(| SlashCommand::Permissions { .. }| SlashCommand::Session { .. }| SlashCommand::Plugins { .. }- | SlashCommand::Doctor| SlashCommand::Login| SlashCommand::Logout| SlashCommand::Vim@@ -1751,37 +2177,38 @@ impl RuntimeMcpState {.into_iter().filter(|server_name| !failed_server_names.contains(server_name)).collect::<Vec<_>>();- let failed_servers = discovery- .failed_servers- .iter()- .map(|failure| runtime::McpFailedServer {- server_name: failure.server_name.clone(),- phase: runtime::McpLifecyclePhase::ToolDiscovery,- error: runtime::McpErrorSurface::new(- runtime::McpLifecyclePhase::ToolDiscovery,- Some(failure.server_name.clone()),- failure.error.clone(),- std::collections::BTreeMap::new(),- true,- ),- })- .chain(discovery.unsupported_servers.iter().map(|server| {- runtime::McpFailedServer {- server_name: server.server_name.clone(),- phase: runtime::McpLifecyclePhase::ServerRegistration,+ let failed_servers =+ discovery+ .failed_servers+ .iter()+ .map(|failure| runtime::McpFailedServer {+ server_name: failure.server_name.clone(),+ phase: runtime::McpLifecyclePhase::ToolDiscovery,error: runtime::McpErrorSurface::new(- runtime::McpLifecyclePhase::ServerRegistration,- Some(server.server_name.clone()),- server.reason.clone(),- std::collections::BTreeMap::from([(- "transport".to_string(),- format!("{:?}", server.transport).to_ascii_lowercase(),- )]),- false,+ runtime::McpLifecyclePhase::ToolDiscovery,+ Some(failure.server_name.clone()),+ failure.error.clone(),+ std::collections::BTreeMap::new(),+ true,),- }- }))- .collect::<Vec<_>>();+ })+ .chain(discovery.unsupported_servers.iter().map(|server| {+ runtime::McpFailedServer {+ server_name: server.server_name.clone(),+ phase: runtime::McpLifecyclePhase::ServerRegistration,+ error: runtime::McpErrorSurface::new(+ runtime::McpLifecyclePhase::ServerRegistration,+ Some(server.server_name.clone()),+ server.reason.clone(),+ std::collections::BTreeMap::from([(+ "transport".to_string(),+ format!("{:?}", server.transport).to_ascii_lowercase(),+ )]),+ false,+ ),+ }+ }))+ .collect::<Vec<_>>();let degraded_report = (!failed_servers.is_empty()).then(|| {runtime::McpDegradedReport::new(working_servers,@@ -2387,8 +2814,11 @@ impl LiveCli {Self::print_skills(args.as_deref())?;false}- SlashCommand::Doctor- | SlashCommand::Login+ SlashCommand::Doctor => {+ println!("{}", render_doctor_report()?.render());+ false+ }+ SlashCommand::Login| SlashCommand::Logout| SlashCommand::Vim| SlashCommand::Upgrade@@ -3371,6 +3801,33 @@ fn print_sandbox_status_snapshot() -> Result<(), Box<dyn std::error::Error>> {Ok(())}+fn render_help_topic(topic: LocalHelpTopic) -> String {+ match topic {+ LocalHelpTopic::Status => "Status+ Usage claw status+ Purpose show the local workspace snapshot without entering the REPL+ Output model, permissions, git state, config files, and sandbox status+ Related /status · claw --resume latest /status"+ .to_string(),+ LocalHelpTopic::Sandbox => "Sandbox+ Usage claw sandbox+ Purpose inspect the resolved sandbox and isolation state for the current directory+ Output namespace, network, filesystem, and fallback details+ Related /sandbox · claw status"+ .to_string(),+ LocalHelpTopic::Doctor => "Doctor+ Usage claw doctor+ Purpose diagnose local auth, config, workspace, sandbox, and build metadata+ Output local-only health report; no provider request or session resume required+ Related /doctor · claw --resume latest /doctor"+ .to_string(),+ }+}++fn print_help_topic(topic: LocalHelpTopic) {+ println!("{}", render_help_topic(topic));+}+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);@@ -5549,6 +6006,11 @@ fn print_help_to(out: &mut impl Write) -> io::Result<()> {)?;writeln!(out, " claw sandbox")?;writeln!(out, " Show the current sandbox isolation snapshot")?;+ writeln!(out, " claw doctor")?;+ writeln!(+ out,+ " Diagnose local auth, config, workspace, and sandbox health"+ )?;writeln!(out, " claw dump-manifests")?;writeln!(out, " claw bootstrap-plan")?;writeln!(out, " claw agents")?;@@ -5626,6 +6088,7 @@ fn print_help_to(out: &mut impl Write) -> io::Result<()> {writeln!(out, " claw agents")?;writeln!(out, " claw mcp show my-server")?;writeln!(out, " claw /skills")?;+ writeln!(out, " claw doctor")?;writeln!(out, " claw login")?;writeln!(out, " claw init")?;Ok(())@@ -5654,8 +6117,8 @@ mod tests {resume_supported_slash_commands, run_resume_command,slash_command_completion_candidates_with_sessions, status_context, validate_no_args,write_mcp_server_fixture, CliAction, CliOutputFormat, CliToolExecutor, GitWorkspaceSummary,- InternalPromptProgressEvent, InternalPromptProgressState, LiveCli, SlashCommand,- StatusUsage, DEFAULT_MODEL,+ InternalPromptProgressEvent, InternalPromptProgressState, LiveCli, LocalHelpTopic,+ SlashCommand, StatusUsage, DEFAULT_MODEL,};use api::{MessageResponse, OutputContentBlock, Usage};use plugins::{@@ -6021,6 +6484,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+ );assert_eq!(parse_args(&["init".to_string()]).expect("init should parse"),CliAction::Init@@ -6046,6 +6513,25 @@ mod tests {);}+ #[test]+ fn local_command_help_flags_stay_on_the_local_parser_path() {+ assert_eq!(+ parse_args(&["status".to_string(), "--help".to_string()])+ .expect("status help should parse"),+ CliAction::HelpTopic(LocalHelpTopic::Status)+ );+ assert_eq!(+ parse_args(&["sandbox".to_string(), "-h".to_string()])+ .expect("sandbox help should parse"),+ CliAction::HelpTopic(LocalHelpTopic::Sandbox)+ );+ assert_eq!(+ parse_args(&["doctor".to_string(), "--help".to_string()])+ .expect("doctor help should parse"),+ CliAction::HelpTopic(LocalHelpTopic::Doctor)+ );+ }+#[test]fn parses_single_word_command_aliases_without_falling_back_to_prompt_mode() {let _guard = env_lock();@@ -7509,8 +7995,12 @@ UU conflicted.rs",let runtime_config = loader.load().expect("runtime config should load");let state = build_runtime_plugin_state_with_loader(&workspace, &loader, &runtime_config).expect("runtime plugin state should load");- let mut executor =- CliToolExecutor::new(None, false, state.tool_registry.clone(), state.mcp_state.clone());+ let mut executor = CliToolExecutor::new(+ None,+ false,+ state.tool_registry.clone(),+ state.mcp_state.clone(),+ );let search_output = executor.execute("ToolSearch", r#"{"query":"remote","max_results":5}"#)diff --git a/rust/crates/rusty-claude-cli/tests/cli_flags_and_config_defaults.rs b/rust/crates/rusty-claude-cli/tests/cli_flags_and_config_defaults.rsindex 9d574c4a..6402f89a 100644--- a/rust/crates/rusty-claude-cli/tests/cli_flags_and_config_defaults.rs+++ b/rust/crates/rusty-claude-cli/tests/cli_flags_and_config_defaults.rs@@ -160,6 +160,82 @@ fn config_command_loads_defaults_from_standard_config_locations() {fs::remove_dir_all(temp_dir).expect("cleanup temp dir");}+#[test]+fn doctor_command_runs_as_a_local_shell_entrypoint() {+ // given+ let temp_dir = unique_temp_dir("doctor-entrypoint");+ let config_home = temp_dir.join("home").join(".claw");+ fs::create_dir_all(&config_home).expect("config home should exist");++ // when+ let output = command_in(&temp_dir)+ .env("CLAW_CONFIG_HOME", &config_home)+ .env_remove("ANTHROPIC_API_KEY")+ .env_remove("ANTHROPIC_AUTH_TOKEN")+ .env("ANTHROPIC_BASE_URL", "http://127.0.0.1:9")+ .arg("doctor")+ .output()+ .expect("claw doctor should launch");++ // then+ assert_success(&output);+ let stdout = String::from_utf8(output.stdout).expect("stdout should be utf8");+ assert!(stdout.contains("Doctor"));+ assert!(stdout.contains("Auth"));+ assert!(stdout.contains("Config"));+ assert!(stdout.contains("Workspace"));+ assert!(stdout.contains("Sandbox"));+ assert!(!stdout.contains("Thinking"));++ fs::remove_dir_all(temp_dir).expect("cleanup temp dir");+}++#[test]+fn local_subcommand_help_does_not_fall_through_to_runtime_or_provider_calls() {+ // given+ let temp_dir = unique_temp_dir("subcommand-help");+ let config_home = temp_dir.join("home").join(".claw");+ fs::create_dir_all(&config_home).expect("config home should exist");++ // when+ let doctor_help = command_in(&temp_dir)+ .env("CLAW_CONFIG_HOME", &config_home)+ .env_remove("ANTHROPIC_API_KEY")+ .env_remove("ANTHROPIC_AUTH_TOKEN")+ .env("ANTHROPIC_BASE_URL", "http://127.0.0.1:9")+ .args(["doctor", "--help"])+ .output()+ .expect("doctor help should launch");+ let status_help = command_in(&temp_dir)+ .env("CLAW_CONFIG_HOME", &config_home)+ .env_remove("ANTHROPIC_API_KEY")+ .env_remove("ANTHROPIC_AUTH_TOKEN")+ .env("ANTHROPIC_BASE_URL", "http://127.0.0.1:9")+ .args(["status", "--help"])+ .output()+ .expect("status help should launch");++ // then+ assert_success(&doctor_help);+ let doctor_stdout = String::from_utf8(doctor_help.stdout).expect("stdout should be utf8");+ assert!(doctor_stdout.contains("Usage claw doctor"));+ assert!(doctor_stdout.contains("local-only health report"));+ assert!(!doctor_stdout.contains("Thinking"));++ assert_success(&status_help);+ let status_stdout = String::from_utf8(status_help.stdout).expect("stdout should be utf8");+ assert!(status_stdout.contains("Usage claw status"));+ assert!(status_stdout.contains("local workspace snapshot"));+ assert!(!status_stdout.contains("Thinking"));++ let doctor_stderr = String::from_utf8(doctor_help.stderr).expect("stderr should be utf8");+ let status_stderr = String::from_utf8(status_help.stderr).expect("stderr should be utf8");+ assert!(!doctor_stderr.contains("auth_unavailable"));+ assert!(!status_stderr.contains("auth_unavailable"));++ fs::remove_dir_all(temp_dir).expect("cleanup temp dir");+}+fn command_in(cwd: &Path) -> Command {let mut command = Command::new(env!("CARGO_BIN_EXE_claw"));command.current_dir(cwd);