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-Heof0d82a7cc018
diff --git a/rust/crates/rusty-claude-cli/src/main.rs b/rust/crates/rusty-claude-cli/src/main.rsindex 3d199762..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,17 +40,17 @@ 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, Value};+use serde_json::json;use tools::{GlobalToolRegistry, RuntimeToolDefinition, ToolSearchOutput};const DEFAULT_MODEL: &str = "claude-opus-4-6";@@ -117,14 +118,12 @@ fn run() -> Result<(), Box<dyn std::error::Error>> {CliAction::ResumeSession {session_path,commands,- output_format,- } => resume_session(&session_path, &commands, output_format),+ } => resume_session(&session_path, &commands),CliAction::Status {model,permission_mode,- output_format,- } => print_status_snapshot(&model, permission_mode, output_format)?,- CliAction::Sandbox { output_format } => print_sandbox_status_snapshot(output_format)?,+ } => print_status_snapshot(&model, permission_mode)?,+ CliAction::Sandbox => print_sandbox_status_snapshot()?,CliAction::Prompt {prompt,model,@@ -135,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(())@@ -167,16 +168,12 @@ enum CliAction {ResumeSession {session_path: PathBuf,commands: Vec<String>,- output_format: CliOutputFormat,},Status {model: String,permission_mode: PermissionMode,- output_format: CliOutputFormat,- },- Sandbox {- output_format: CliOutputFormat,},+ Sandbox,Prompt {prompt: String,model: String,@@ -186,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,@@ -345,11 +351,12 @@ fn parse_args(args: &[String]) -> Result<CliAction, String> {});}if rest.first().map(String::as_str) == Some("--resume") {- return parse_resume_args(&rest[1..], output_format);+ return parse_resume_args(&rest[1..]);}- if let Some(action) =- parse_single_word_command_alias(&rest, &model, permission_mode_override, output_format)- {+ 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;}@@ -395,11 +402,28 @@ 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,permission_mode_override: Option<PermissionMode>,- output_format: CliOutputFormat,) -> Option<Result<CliAction, String>> {if rest.len() != 1 {return None;@@ -411,9 +435,9 @@ fn parse_single_word_command_alias("status" => Some(Ok(CliAction::Status {model: model.to_string(),permission_mode: permission_mode_override.unwrap_or_else(default_permission_mode),- output_format,})),- "sandbox" => Some(Ok(CliAction::Sandbox { output_format })),+ "sandbox" => Some(Ok(CliAction::Sandbox)),+ "doctor" => Some(Ok(CliAction::Doctor)),other => bare_slash_command_guidance(other).map(Err),}}@@ -707,7 +731,7 @@ fn parse_system_prompt_args(args: &[String]) -> Result<CliAction, String> {Ok(CliAction::PrintSystemPrompt { cwd, date })}-fn parse_resume_args(args: &[String], output_format: CliOutputFormat) -> Result<CliAction, String> {+fn parse_resume_args(args: &[String]) -> Result<CliAction, String> {let (session_path, command_tokens): (PathBuf, &[String]) = match args.first() {None => (PathBuf::from(LATEST_SESSION_REFERENCE), &[]),Some(first) if looks_like_slash_command_token(first) => {@@ -747,10 +771,399 @@ fn parse_resume_args(args: &[String], output_format: CliOutputFormat) -> Result<Ok(CliAction::ResumeSession {session_path,commands,- output_format,})}+#[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),@@ -938,7 +1351,7 @@ fn print_version() {println!("{}", render_version_report());}-fn resume_session(session_path: &Path, commands: &[String], output_format: CliOutputFormat) {+fn resume_session(session_path: &Path, commands: &[String]) {let resolved_path = if session_path.exists() {session_path.to_path_buf()} else {@@ -960,31 +1373,15 @@ fn resume_session(session_path: &Path, commands: &[String], output_format: CliOu};if commands.is_empty() {- match output_format {- CliOutputFormat::Text => {- println!(- "Restored session from {} ({} messages).",- resolved_path.display(),- session.messages.len()- );- }- CliOutputFormat::Json => {- println!(- "{}",- serialize_json_output(&json!({- "kind": "resume",- "session_file": resolved_path.display().to_string(),- "messages": session.messages.len(),- }))- .unwrap_or_else(|error| format!(r#"{{"kind":"error","message":"{error}"}}"#))- );- }- }+ println!(+ "Restored session from {} ({} messages).",+ resolved_path.display(),+ session.messages.len()+ );return;}let mut session = session;- let mut json_outputs = Vec::new();for raw_command in commands {let command = match SlashCommand::parse(raw_command) {Ok(Some(command)) => command,@@ -997,19 +1394,14 @@ fn resume_session(session_path: &Path, commands: &[String], output_format: CliOustd::process::exit(2);}};- match run_resume_command(&resolved_path, &session, &command, output_format) {+ match run_resume_command(&resolved_path, &session, &command) {Ok(ResumeCommandOutcome {session: next_session,message,}) => {session = next_session;if let Some(message) = message {- match output_format {- CliOutputFormat::Text => {- println!("{}", render_resume_text_output(&message))- }- CliOutputFormat::Json => json_outputs.push(message),- }+ println!("{message}");}}Err(error) => {@@ -1018,27 +1410,12 @@ fn resume_session(session_path: &Path, commands: &[String], output_format: CliOu}}}-- if matches!(output_format, CliOutputFormat::Json) {- let payload = if json_outputs.len() == 1 {- json_outputs.pop().expect("single json output")- } else {- Value::Array(json_outputs)- };- match serialize_json_output(&payload) {- Ok(rendered) => println!("{rendered}"),- Err(error) => {- eprintln!("failed to render json output: {error}");- std::process::exit(2);- }- }- }}#[derive(Debug, Clone)]struct ResumeCommandOutcome {session: Session,- message: Option<Value>,+ message: Option<String>,}#[derive(Debug, Clone)]@@ -1363,28 +1740,16 @@ fn parse_git_status_metadata_for((project_root, branch)}-fn serialize_json_output(value: &Value) -> Result<String, serde_json::Error> {- serde_json::to_string_pretty(value)-}--fn render_resume_text_output(value: &Value) -> String {- value.get("message").and_then(Value::as_str).map_or_else(- || serialize_json_output(value).unwrap_or_else(|_| value.to_string()),- ToString::to_string,- )-}-#[allow(clippy::too_many_lines)]fn run_resume_command(session_path: &Path,session: &Session,command: &SlashCommand,- output_format: CliOutputFormat,) -> Result<ResumeCommandOutcome, Box<dyn std::error::Error>> {match command {SlashCommand::Help => Ok(ResumeCommandOutcome {session: session.clone(),- message: Some(json!({ "kind": "help", "message": render_repl_help() })),+ message: Some(render_repl_help()),}),SlashCommand::Compact => {let result = runtime::compact_session(@@ -1400,20 +1765,16 @@ fn run_resume_command(result.compacted_session.save_to_path(session_path)?;Ok(ResumeCommandOutcome {session: result.compacted_session,- message: Some(json!({- "kind": "compact",- "message": format_compact_report(removed, kept, skipped),- })),+ message: Some(format_compact_report(removed, kept, skipped)),})}SlashCommand::Clear { confirm } => {if !confirm {return Ok(ResumeCommandOutcome {session: session.clone(),- message: Some(json!({- "kind": "clear",- "message": "clear: confirmation required; rerun with /clear --confirm",- })),+ message: Some(+ "clear: confirmation required; rerun with /clear --confirm".to_string(),+ ),});}let backup_path = write_session_clear_backup(session, session_path)?;@@ -1423,85 +1784,55 @@ fn run_resume_command(cleared.save_to_path(session_path)?;Ok(ResumeCommandOutcome {session: cleared,- message: Some(json!({- "kind": "clear",- "message": format!(- "Session cleared\n Mode resumed session reset\n Previous session {previous_session_id}\n Backup {}\n Resume previous claw --resume {}\n New session {new_session_id}\n Session file {}",- backup_path.display(),- backup_path.display(),- session_path.display()- ),- })),+ message: Some(format!(+ "Session cleared\n Mode resumed session reset\n Previous session {previous_session_id}\n Backup {}\n Resume previous claw --resume {}\n New session {new_session_id}\n Session file {}",+ backup_path.display(),+ backup_path.display(),+ session_path.display()+ )),})}SlashCommand::Status => {let tracker = UsageTracker::from_session(session);let usage = tracker.cumulative_usage();- let status_usage = StatusUsage {- message_count: session.messages.len(),- turns: tracker.turns(),- latest: tracker.current_turn_usage(),- cumulative: usage,- estimated_tokens: 0,- };- let context = status_context(Some(session_path))?;- let status_json = status_report_json(- "restored-session",- status_usage,- default_permission_mode().as_str(),- &context,- );Ok(ResumeCommandOutcome {session: session.clone(),- message: Some(match output_format {- CliOutputFormat::Text => json!({- "kind": "status-text",- "message": format_status_report(- "restored-session",- status_usage,- default_permission_mode().as_str(),- &context,- ),- }),- CliOutputFormat::Json => status_json,- }),+ message: Some(format_status_report(+ "restored-session",+ StatusUsage {+ message_count: session.messages.len(),+ turns: tracker.turns(),+ latest: tracker.current_turn_usage(),+ cumulative: usage,+ estimated_tokens: 0,+ },+ default_permission_mode().as_str(),+ &status_context(Some(session_path))?,+ )),})}SlashCommand::Sandbox => {let cwd = env::current_dir()?;let loader = ConfigLoader::default_for(&cwd);let runtime_config = loader.load()?;- let sandbox_status = resolve_sandbox_status(runtime_config.sandbox(), &cwd);Ok(ResumeCommandOutcome {session: session.clone(),- message: Some(match output_format {- CliOutputFormat::Text => json!({- "kind": "sandbox-text",- "message": format_sandbox_report(&sandbox_status),- }),- CliOutputFormat::Json => json!({- "kind": "sandbox",- "sandbox": sandbox_status_json(&sandbox_status),- }),- }),+ message: Some(format_sandbox_report(&resolve_sandbox_status(+ runtime_config.sandbox(),+ &cwd,+ ))),})}SlashCommand::Cost => {let usage = UsageTracker::from_session(session).cumulative_usage();Ok(ResumeCommandOutcome {session: session.clone(),- message: Some(json!({- "kind": "cost",- "message": format_cost_report(usage),- })),+ message: Some(format_cost_report(usage)),})}SlashCommand::Config { section } => Ok(ResumeCommandOutcome {session: session.clone(),- message: Some(json!({- "kind": "config",- "message": render_config_report(section.as_deref())?,- })),+ message: Some(render_config_report(section.as_deref())?),}),SlashCommand::Mcp { action, target } => {let cwd = env::current_dir()?;@@ -1513,77 +1844,57 @@ fn run_resume_command(};Ok(ResumeCommandOutcome {session: session.clone(),- message: Some(json!({- "kind": "mcp",- "message": handle_mcp_slash_command(args.as_deref(), &cwd)?,- })),+ message: Some(handle_mcp_slash_command(args.as_deref(), &cwd)?),})}SlashCommand::Memory => Ok(ResumeCommandOutcome {session: session.clone(),- message: Some(json!({- "kind": "memory",- "message": render_memory_report()?,- })),+ message: Some(render_memory_report()?),}),SlashCommand::Init => Ok(ResumeCommandOutcome {session: session.clone(),- message: Some(json!({- "kind": "init",- "message": init_claude_md()?,- })),+ message: Some(init_claude_md()?),}),SlashCommand::Diff => Ok(ResumeCommandOutcome {session: session.clone(),- message: Some(json!({- "kind": "diff",- "message": render_diff_report_for(- session_path.parent().unwrap_or_else(|| Path::new(".")),- )?,- })),+ message: Some(render_diff_report_for(+ session_path.parent().unwrap_or_else(|| Path::new(".")),+ )?),}),SlashCommand::Version => Ok(ResumeCommandOutcome {session: session.clone(),- message: Some(json!({- "kind": "version",- "message": render_version_report(),- })),+ message: Some(render_version_report()),}),SlashCommand::Export { path } => {let export_path = resolve_export_path(path.as_deref(), session)?;fs::write(&export_path, render_export_text(session))?;Ok(ResumeCommandOutcome {session: session.clone(),- message: Some(json!({- "kind": "export",- "message": format!(- "Export\n Result wrote transcript\n File {}\n Messages {}",- export_path.display(),- session.messages.len(),- ),- })),+ message: Some(format!(+ "Export\n Result wrote transcript\n File {}\n Messages {}",+ export_path.display(),+ session.messages.len(),+ )),})}SlashCommand::Agents { args } => {let cwd = env::current_dir()?;Ok(ResumeCommandOutcome {session: session.clone(),- message: Some(json!({- "kind": "agents",- "message": handle_agents_slash_command(args.as_deref(), &cwd)?,- })),+ message: Some(handle_agents_slash_command(args.as_deref(), &cwd)?),})}SlashCommand::Skills { args } => {let cwd = env::current_dir()?;Ok(ResumeCommandOutcome {session: session.clone(),- message: Some(json!({- "kind": "skills",- "message": handle_skills_slash_command(args.as_deref(), &cwd)?,- })),+ 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 { .. }@@ -1597,7 +1908,6 @@ fn run_resume_command(| SlashCommand::Permissions { .. }| SlashCommand::Session { .. }| SlashCommand::Plugins { .. }- | SlashCommand::Doctor| SlashCommand::Login| SlashCommand::Logout| SlashCommand::Vim@@ -2504,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@@ -3296,31 +3609,22 @@ fn render_repl_help() -> String {fn print_status_snapshot(model: &str,permission_mode: PermissionMode,- output_format: CliOutputFormat,) -> Result<(), Box<dyn std::error::Error>> {- let usage = StatusUsage {- message_count: 0,- turns: 0,- latest: TokenUsage::default(),- cumulative: TokenUsage::default(),- estimated_tokens: 0,- };- let context = status_context(None)?;- match output_format {- CliOutputFormat::Text => println!(- "{}",- format_status_report(model, usage, permission_mode.as_str(), &context)- ),- CliOutputFormat::Json => println!(- "{}",- serialize_json_output(&status_report_json(- model,- usage,- permission_mode.as_str(),- &context,- ))?- ),- }+ println!(+ "{}",+ format_status_report(+ model,+ StatusUsage {+ message_count: 0,+ turns: 0,+ latest: TokenUsage::default(),+ cumulative: TokenUsage::default(),+ estimated_tokens: 0,+ },+ permission_mode.as_str(),+ &status_context(None)?,+ )+ );Ok(())}@@ -3418,61 +3722,6 @@ fn format_status_report()}-fn status_report_json(- model: &str,- usage: StatusUsage,- permission_mode: &str,- context: &StatusContext,-) -> Value {- json!({- "kind": "status",- "model": model,- "permission_mode": permission_mode,- "messages": usage.message_count,- "turns": usage.turns,- "estimated_tokens": usage.estimated_tokens,- "usage": {- "latest": token_usage_json(usage.latest),- "cumulative": token_usage_json(usage.cumulative),- },- "workspace": {- "cwd": context.cwd.display().to_string(),- "project_root": context.project_root.as_ref().map(|path| path.display().to_string()),- "git_branch": context.git_branch.clone(),- "git_state": context.git_summary.headline(),- "changed_files": context.git_summary.changed_files,- "staged_files": context.git_summary.staged_files,- "unstaged_files": context.git_summary.unstaged_files,- "untracked_files": context.git_summary.untracked_files,- "session": status_session_label(context.session_path.as_deref()),- "config_files": {- "loaded": context.loaded_config_files,- "discovered": context.discovered_config_files,- },- "memory_files": context.memory_file_count,- "suggested_flow": ["/status", "/diff", "/commit"],- },- "sandbox": sandbox_status_json(&context.sandbox_status),- })-}--fn token_usage_json(usage: TokenUsage) -> Value {- json!({- "input_tokens": usage.input_tokens,- "output_tokens": usage.output_tokens,- "cache_creation_input_tokens": usage.cache_creation_input_tokens,- "cache_read_input_tokens": usage.cache_read_input_tokens,- "total_tokens": usage.total_tokens(),- })-}--fn status_session_label(session_path: Option<&Path>) -> String {- session_path.map_or_else(- || "live-repl".to_string(),- |path| path.display().to_string(),- )-}-fn format_sandbox_report(status: &runtime::SandboxStatus) -> String {format!("Sandbox@@ -3516,31 +3765,6 @@ fn format_sandbox_report(status: &runtime::SandboxStatus) -> String {)}-fn sandbox_status_json(status: &runtime::SandboxStatus) -> Value {- json!({- "enabled": status.enabled,- "active": status.active,- "supported": status.supported,- "namespace_supported": status.namespace_supported,- "namespace_active": status.namespace_active,- "network_supported": status.network_supported,- "network_active": status.network_active,- "filesystem_mode": status.filesystem_mode.as_str(),- "filesystem_active": status.filesystem_active,- "allowed_mounts": status.allowed_mounts.clone(),- "in_container": status.in_container,- "container_markers": status.container_markers.clone(),- "fallback_reason": status.fallback_reason.clone(),- "requested": {- "enabled": status.requested.enabled,- "namespace_restrictions": status.requested.namespace_restrictions,- "network_isolation": status.requested.network_isolation,- "filesystem_mode": status.requested.filesystem_mode.as_str(),- "allowed_mounts": status.requested.allowed_mounts.clone(),- }- })-}-fn format_commit_preflight_report(branch: Option<&str>, summary: GitWorkspaceSummary) -> String {format!("Commit@@ -3564,28 +3788,46 @@ fn format_commit_skipped_report() -> String {.to_string()}-fn print_sandbox_status_snapshot(- output_format: CliOutputFormat,-) -> Result<(), Box<dyn std::error::Error>> {+fn print_sandbox_status_snapshot() -> Result<(), Box<dyn std::error::Error>> {let cwd = env::current_dir()?;let loader = ConfigLoader::default_for(&cwd);let runtime_config = loader.load().unwrap_or_else(|_| runtime::RuntimeConfig::empty());- let sandbox_status = resolve_sandbox_status(runtime_config.sandbox(), &cwd);- match output_format {- CliOutputFormat::Text => println!("{}", format_sandbox_report(&sandbox_status)),- CliOutputFormat::Json => println!(- "{}",- serialize_json_output(&json!({- "kind": "sandbox",- "sandbox": sandbox_status_json(&sandbox_status),- }))?- ),- }+ println!(+ "{}",+ format_sandbox_report(&resolve_sandbox_status(runtime_config.sandbox(), &cwd))+ );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);@@ -5764,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")?;@@ -5841,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(())@@ -5865,11 +6113,11 @@ mod tests {parse_git_status_branch, parse_git_status_metadata_for, parse_git_workspace_summary,permission_policy, print_help_to, push_output_block, render_config_report,render_diff_report, render_diff_report_for, render_memory_report, render_repl_help,- render_resume_text_output, render_resume_usage, resolve_model_alias,- resolve_session_reference, response_to_events, 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,+ render_resume_usage, resolve_model_alias, resolve_session_reference, response_to_events,+ 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, LocalHelpTopic,SlashCommand, StatusUsage, DEFAULT_MODEL,};use api::{MessageResponse, OutputContentBlock, Usage};@@ -6236,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@@ -6261,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();@@ -6278,36 +6549,11 @@ mod tests {CliAction::Status {model: DEFAULT_MODEL.to_string(),permission_mode: PermissionMode::DangerFullAccess,- output_format: CliOutputFormat::Text,});assert_eq!(parse_args(&["sandbox".to_string()]).expect("sandbox should parse"),- CliAction::Sandbox {- output_format: CliOutputFormat::Text,- }- );- }-- #[test]- fn parses_json_output_for_status_and_sandbox_aliases() {- let _guard = env_lock();- std::env::remove_var("RUSTY_CLAUDE_PERMISSION_MODE");- assert_eq!(- parse_args(&["--output-format=json".to_string(), "status".to_string()])- .expect("json status should parse"),- CliAction::Status {- model: DEFAULT_MODEL.to_string(),- permission_mode: PermissionMode::DangerFullAccess,- output_format: CliOutputFormat::Json,- }- );- assert_eq!(- parse_args(&["--output-format=json".to_string(), "sandbox".to_string()])- .expect("json sandbox should parse"),- CliAction::Sandbox {- output_format: CliOutputFormat::Json,- }+ CliAction::Sandbox);}@@ -6413,7 +6659,6 @@ mod tests {CliAction::ResumeSession {session_path: PathBuf::from("session.jsonl"),commands: vec!["/compact".to_string()],- output_format: CliOutputFormat::Text,});}@@ -6425,7 +6670,6 @@ mod tests {CliAction::ResumeSession {session_path: PathBuf::from("latest"),commands: vec![],- output_format: CliOutputFormat::Text,});assert_eq!(@@ -6434,7 +6678,6 @@ mod tests {CliAction::ResumeSession {session_path: PathBuf::from("latest"),commands: vec!["/status".to_string()],- output_format: CliOutputFormat::Text,});}@@ -6457,7 +6700,6 @@ mod tests {"/compact".to_string(),"/cost".to_string(),],- output_format: CliOutputFormat::Text,});}@@ -6488,7 +6730,6 @@ mod tests {"/export notes.txt".to_string(),"/clear --confirm".to_string(),],- output_format: CliOutputFormat::Text,});}@@ -6507,25 +6748,6 @@ mod tests {CliAction::ResumeSession {session_path: PathBuf::from("session.jsonl"),commands: vec!["/export /tmp/notes.txt".to_string(), "/status".to_string()],- output_format: CliOutputFormat::Text,- }- );- }-- #[test]- fn parses_json_output_for_resumed_status_queries() {- let args = vec![- "--output-format=json".to_string(),- "--resume".to_string(),- "session.jsonl".to_string(),- "/status".to_string(),- ];- assert_eq!(- parse_args(&args).expect("json resume status should parse"),- CliAction::ResumeSession {- session_path: PathBuf::from("session.jsonl"),- commands: vec!["/status".to_string()],- output_format: CliOutputFormat::Json,});}@@ -7046,16 +7268,10 @@ UU conflicted.rs",let session = Session::load_from_path(&session_path).expect("session should load");let outcome = with_current_dir(&root, || {- run_resume_command(- &session_path,- &session,- &SlashCommand::Diff,- CliOutputFormat::Text,- )- .expect("resume diff should work")+ run_resume_command(&session_path, &session, &SlashCommand::Diff)+ .expect("resume diff should work")});- let message =- render_resume_text_output(&outcome.message.expect("diff message should exist"));+ let message = outcome.message.expect("diff message should exist");assert!(message.contains("Unstaged changes:"));assert!(message.contains("tracked.txt"));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 cd06e0b1..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@@ -161,37 +161,77 @@ fn config_command_loads_defaults_from_standard_config_locations() {}#[test]-fn nested_help_flags_render_usage_instead_of_falling_through() {- let temp_dir = unique_temp_dir("nested-help");- fs::create_dir_all(&temp_dir).expect("temp dir should exist");+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");- let mcp_output = command_in(&temp_dir)- .args(["mcp", "show", "--help"])- .output()- .expect("claw should launch");- assert_success(&mcp_output);- let mcp_stdout = String::from_utf8(mcp_output.stdout).expect("stdout should be utf8");- assert!(mcp_stdout.contains("Usage /mcp [list|show <server>|help]"));- assert!(mcp_stdout.contains("Unexpected show"));- assert!(!mcp_stdout.contains("server `--help` is not configured"));-- let skills_output = command_in(&temp_dir)- .args(["skills", "install", "--help"])+ // 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 should launch");- assert_success(&skills_output);- let skills_stdout = String::from_utf8(skills_output.stdout).expect("stdout should be utf8");- assert!(skills_stdout.contains("Usage /skills [list|install <path>|help]"));- assert!(skills_stdout.contains("Unexpected install"));+ .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");- let unknown_output = command_in(&temp_dir)- .args(["mcp", "inspect", "--help"])+ // 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("claw should launch");- assert_success(&unknown_output);- let unknown_stdout = String::from_utf8(unknown_output.stdout).expect("stdout should be utf8");- assert!(unknown_stdout.contains("Usage /mcp [list|show <server>|help]"));- assert!(unknown_stdout.contains("Unexpected inspect"));+ .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");}