Keep doctor and local help paths shell-native

Promote doctor into a real top-level CLI action, reuse the same local report for resumed and REPL doctor invocations, and intercept doctor/status/sandbox help flags before prompt-mode dispatch. The parser change also closes the help fallthrough that previously wandered into runtime startup for local-info commands.

Constraint: Preserve prompt shorthand for normal multi-word text input while fixing exact local subcommand help paths
Rejected: Route \7⠋ 🦀 Thinking...8✘ ❌ Request failed
 through prompt/slash guidance | still shells out through the wrong surface and keeps health checks hidden
Rejected: Reuse the status report as doctor output | status does not explain auth/config health or expose a dedicated diagnostic summary
Confidence: high
Scope-risk: narrow
Directive: Keep doctor local-only unless an explicit network probe is intentionally added and separately tested
Tested: cargo build -p rusty-claude-cli; cargo test -p rusty-claude-cli; cargo run -p rusty-claude-cli -- doctor --help; CLAW_CONFIG_HOME=/tmp/tmp.7pm9SVzOPN ANTHROPIC_API_KEY= ANTHROPIC_AUTH_TOKEN= cargo run -p rusty-claude-cli -- doctor
Not-tested: direct /doctor outside the REPL remains interactive-only

rust/crates/rusty-claude-cli/tests/cli_flags_and_config_defaults.rs

@@ -5,7 +5,6 @@ use std::sync::atomic::{AtomicU64, Ordering};
 use std::time::{SystemTime, UNIX_EPOCH};
 
 use runtime::Session;
-use serde_json::Value;
 
 static TEMP_COUNTER: AtomicU64 = AtomicU64::new(0);
 
@@ -38,64 +37,6 @@ fn status_command_applies_model_and_permission_mode_flags() {
     fs::remove_dir_all(temp_dir).expect("cleanup temp dir");
 }
 
-#[test]
-fn status_command_emits_structured_json_when_requested() {
-    // given
-    let temp_dir = unique_temp_dir("status-json");
-    fs::create_dir_all(&temp_dir).expect("temp dir should exist");
-
-    // when
-    let output = Command::new(env!("CARGO_BIN_EXE_claw"))
-        .current_dir(&temp_dir)
-        .args([
-            "--model",
-            "sonnet",
-            "--permission-mode",
-            "read-only",
-            "--output-format",
-            "json",
-            "status",
-        ])
-        .output()
-        .expect("claw should launch");
-
-    // then
-    assert_success(&output);
-    let stdout = String::from_utf8(output.stdout).expect("stdout should be utf8");
-    let parsed: Value = serde_json::from_str(stdout.trim()).expect("status output should be json");
-    assert_eq!(parsed["kind"], "status");
-    assert_eq!(parsed["model"], "claude-sonnet-4-6");
-    assert_eq!(parsed["permission_mode"], "read-only");
-    assert_eq!(parsed["workspace"]["session"], "live-repl");
-    assert!(parsed["sandbox"].is_object());
-
-    fs::remove_dir_all(temp_dir).expect("cleanup temp dir");
-}
-
-#[test]
-fn sandbox_command_emits_structured_json_when_requested() {
-    // given
-    let temp_dir = unique_temp_dir("sandbox-json");
-    fs::create_dir_all(&temp_dir).expect("temp dir should exist");
-
-    // when
-    let output = Command::new(env!("CARGO_BIN_EXE_claw"))
-        .current_dir(&temp_dir)
-        .args(["--output-format", "json", "sandbox"])
-        .output()
-        .expect("claw should launch");
-
-    // then
-    assert_success(&output);
-    let stdout = String::from_utf8(output.stdout).expect("stdout should be utf8");
-    let parsed: Value = serde_json::from_str(stdout.trim()).expect("sandbox output should be json");
-    assert_eq!(parsed["kind"], "sandbox");
-    assert!(parsed["sandbox"].is_object());
-    assert!(parsed["sandbox"]["requested"].is_object());
-
-    fs::remove_dir_all(temp_dir).expect("cleanup temp dir");
-}
-
 #[test]
 fn resume_flag_loads_a_saved_session_and_dispatches_status() {
     // given
@@ -219,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);

rust/crates/rusty-claude-cli/tests/resume_slash_commands.rs

@@ -7,7 +7,6 @@ use std::time::{SystemTime, UNIX_EPOCH};
 
 use runtime::ContentBlock;
 use runtime::Session;
-use serde_json::Value;
 
 static TEMP_COUNTER: AtomicU64 = AtomicU64::new(0);
 
@@ -222,52 +221,6 @@ fn resume_latest_restores_the_most_recent_managed_session() {
     assert!(stdout.contains(newer_path.to_str().expect("utf8 path")));
 }
 
-#[test]
-fn resumed_status_command_emits_structured_json_when_requested() {
-    // given
-    let temp_dir = unique_temp_dir("resume-status-json");
-    fs::create_dir_all(&temp_dir).expect("temp dir should exist");
-    let session_path = temp_dir.join("session.jsonl");
-
-    let mut session = Session::new();
-    session
-        .push_user_text("resume status json fixture")
-        .expect("session write should succeed");
-    session
-        .save_to_path(&session_path)
-        .expect("session should persist");
-
-    // when
-    let output = run_claw(
-        &temp_dir,
-        &[
-            "--output-format",
-            "json",
-            "--resume",
-            session_path.to_str().expect("utf8 path"),
-            "/status",
-        ],
-    );
-
-    // then
-    assert!(
-        output.status.success(),
-        "stdout:\n{}\n\nstderr:\n{}",
-        String::from_utf8_lossy(&output.stdout),
-        String::from_utf8_lossy(&output.stderr)
-    );
-
-    let stdout = String::from_utf8(output.stdout).expect("stdout should be utf8");
-    let parsed: Value =
-        serde_json::from_str(stdout.trim()).expect("resume status output should be json");
-    assert_eq!(parsed["kind"], "status");
-    assert_eq!(parsed["messages"], 1);
-    assert_eq!(
-        parsed["workspace"]["session"],
-        session_path.to_str().expect("utf8 path")
-    );
-}
-
 fn run_claw(current_dir: &Path, args: &[&str]) -> Output {
     run_claw_with_env(current_dir, args, &[])
 }