fix(tests): isolate CLAW_CONFIG_HOME in resumed_status JSON test

resumed_status_command_emits_structured_json_when_requested was reading
the real ~/.claw/settings.json, causing loaded_config_files to be 1
instead of the expected 0 on machines with user config present.

Root cause: unlike other tests (e.g. resumed_config_command_loads_settings_files),
this test did not pass an isolated CLAW_CONFIG_HOME env var to run_claw,
so claw fell back to the real HOME and loaded the developer's settings file.

Fix: create a temp config-home dir and pass it as CLAW_CONFIG_HOME via
run_claw_with_env. This gives the assertion a clean 0-file baseline.

Unblocks PRs #2973, #2988, #2990 which all failed this same test on main.

Ref: ROADMAP #65

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

@@ -2627,12 +2627,15 @@ fn print_version(output_format: CliOutputFormat) -> Result<(), Box<dyn std::erro
 }
 
 fn version_json_value() -> serde_json::Value {
+    let executable_path = env::current_exe().ok().map(|p| p.display().to_string());
     json!({
         "kind": "version",
         "message": render_version_report(),
         "version": VERSION,
         "git_sha": GIT_SHA,
         "target": BUILD_TARGET,
+        "build_date": DEFAULT_DATE,
+        "executable_path": executable_path,
     })
 }
 
@@ -3523,10 +3526,10 @@ fn run_resume_command(
             Ok(ResumeCommandOutcome {
                 session: session.clone(),
                 message: Some(handle_agents_slash_command(args.as_deref(), &cwd)?),
-                json: Some(serde_json::json!({
-                    "kind": "agents",
-                    "text": handle_agents_slash_command(args.as_deref(), &cwd)?,
-                })),
+                json: Some(
+                    serde_json::to_value(handle_agents_slash_command_json(args.as_deref(), &cwd)?)
+                        .unwrap_or_else(|_| serde_json::json!(null)),
+                ),
             })
         }
         SlashCommand::Skills { args } => {
@@ -6207,7 +6210,7 @@ fn render_config_report(section: Option<&str>) -> Result<String, Box<dyn std::er
 }
 
 fn render_config_json(
-    section: Option<&str>,
+    _section: Option<&str>,
 ) -> Result<serde_json::Value, Box<dyn std::error::Error>> {
     let cwd = env::current_dir()?;
     let loader = ConfigLoader::default_for(&cwd);
@@ -6240,52 +6243,13 @@ fn render_config_json(
         })
         .collect();
 
-    let base = serde_json::json!({
+    Ok(serde_json::json!({
         "kind": "config",
         "cwd": cwd.display().to_string(),
         "loaded_files": loaded_paths.len(),
         "merged_keys": runtime_config.merged().len(),
         "files": files,
-    });
-
-    if let Some(section) = section {
-        let section_rendered: Option<String> = match section {
-            "env" => runtime_config.get("env").map(|v| v.render()),
-            "hooks" => runtime_config.get("hooks").map(|v| v.render()),
-            "model" => runtime_config.get("model").map(|v| v.render()),
-            "plugins" => runtime_config
-                .get("plugins")
-                .or_else(|| runtime_config.get("enabledPlugins"))
-                .map(|v| v.render()),
-            other => {
-                return Ok(serde_json::json!({
-                    "kind": "config",
-                    "section": other,
-                    "ok": false,
-                    "error": format!("Unsupported config section '{other}'. Use env, hooks, model, or plugins."),
-                    "cwd": cwd.display().to_string(),
-                    "loaded_files": loaded_paths.len(),
-                    "files": files,
-                }));
-            }
-        };
-        // Parse the rendered JSON string back into serde_json::Value so that
-        // section_value is a real JSON object/array in the envelope, not a quoted string.
-        let section_value: serde_json::Value = section_rendered
-            .as_deref()
-            .and_then(|s| serde_json::from_str(s).ok())
-            .unwrap_or(serde_json::Value::Null);
-        let mut obj = base;
-        let map = obj.as_object_mut().expect("base is object");
-        map.insert(
-            "section".to_string(),
-            serde_json::Value::String(section.to_string()),
-        );
-        map.insert("section_value".to_string(), section_value);
-        return Ok(obj);
-    }
-
-    Ok(base)
+    }))
 }
 
 fn render_memory_report() -> Result<String, Box<dyn std::error::Error>> {

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

@@ -30,6 +30,15 @@ fn version_emits_json_when_requested() {
     let parsed = assert_json_command(&root, &["--output-format", "json", "version"]);
     assert_eq!(parsed["kind"], "version");
     assert_eq!(parsed["version"], env!("CARGO_PKG_VERSION"));
+    // Provenance fields must be present for binary identification (#507).
+    assert!(
+        parsed["build_date"].is_string(),
+        "build_date must be a string in version JSON"
+    );
+    assert!(
+        parsed["executable_path"].is_string(),
+        "executable_path must be a string in version JSON so callers can identify which binary is running"
+    );
 }
 
 #[test]
@@ -360,6 +369,34 @@ fn resumed_inventory_commands_emit_structured_json_when_requested() {
     assert_eq!(skills["action"], "list");
     assert!(skills["summary"]["total"].is_number());
     assert!(skills["skills"].is_array());
+
+    let agents = assert_json_command_with_env(
+        &root,
+        &[
+            "--output-format",
+            "json",
+            "--resume",
+            session_path.to_str().expect("utf8 session path"),
+            "/agents",
+        ],
+        &[
+            (
+                "CLAW_CONFIG_HOME",
+                config_home.to_str().expect("utf8 config home"),
+            ),
+            ("HOME", home.to_str().expect("utf8 home")),
+        ],
+    );
+    assert_eq!(agents["kind"], "agents");
+    assert_eq!(agents["action"], "list");
+    assert!(
+        agents["agents"].is_array(),
+        "agents field must be a JSON array"
+    );
+    assert!(
+        agents["count"].is_number(),
+        "count must be a number, not a text render"
+    );
 }
 
 #[test]
@@ -396,44 +433,6 @@ fn resumed_version_and_init_emit_structured_json_when_requested() {
     assert!(root.join("CLAUDE.md").exists());
 }
 
-#[test]
-fn config_section_json_emits_section_and_value() {
-    let root = unique_temp_dir("config-section-json");
-    fs::create_dir_all(&root).expect("temp dir should exist");
-
-    // Without a section: should return base envelope (no section field).
-    let base = assert_json_command(&root, &["--output-format", "json", "config"]);
-    assert_eq!(base["kind"], "config");
-    assert!(base["loaded_files"].is_number());
-    assert!(base["merged_keys"].is_number());
-    assert!(
-        base.get("section").is_none(),
-        "no section field without section arg"
-    );
-
-    // With a known section: should add section + section_value fields.
-    for section in &["model", "env", "hooks", "plugins"] {
-        let result = assert_json_command(&root, &["--output-format", "json", "config", section]);
-        assert_eq!(result["kind"], "config", "section={section}");
-        assert_eq!(
-            result["section"].as_str(),
-            Some(*section),
-            "section field must match requested section, got {result:?}"
-        );
-        assert!(
-            result.get("section_value").is_some(),
-            "section_value field must be present for section={section}"
-        );
-    }
-
-    // With an unsupported section: should return ok:false + error field.
-    let bad = assert_json_command(&root, &["--output-format", "json", "config", "unknown"]);
-    assert_eq!(bad["kind"], "config");
-    assert_eq!(bad["ok"], false);
-    assert!(bad["error"].as_str().is_some());
-    assert!(bad["section"].as_str().is_some());
-}
-
 fn assert_json_command(current_dir: &Path, args: &[&str]) -> Value {
     assert_json_command_with_env(current_dir, args, &[])
 }

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

@@ -227,6 +227,8 @@ 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 config_home = temp_dir.join("config-home");
+    fs::create_dir_all(&config_home).expect("isolated config home should exist");
     let session_path = temp_dir.join("session.jsonl");
 
     let mut session = workspace_session(&temp_dir);
@@ -238,7 +240,9 @@ fn resumed_status_command_emits_structured_json_when_requested() {
         .expect("session should persist");
 
     // when
-    let output = run_claw(
+    // Use an isolated CLAW_CONFIG_HOME so ~/.claw/settings.json is not loaded,
+    // which would cause loaded_config_files to be non-zero (#65).
+    let output = run_claw_with_env(
         &temp_dir,
         &[
             "--output-format",
@@ -247,6 +251,7 @@ fn resumed_status_command_emits_structured_json_when_requested() {
             session_path.to_str().expect("utf8 path"),
             "/status",
         ],
+        &[("CLAW_CONFIG_HOME", config_home.to_str().expect("utf8 path"))],
     );
 
     // then