docs(roadmap): add #405 — system-prompt sections:string[] unstructured; message+sections duplication

ROADMAP.md

@@ -6301,4 +6301,4 @@ Original filing (2026-04-18): the session emitted `SessionStart hook (completed)
 380. **Top-level `tokens --help --output-format json` hangs with zero stdout/stderr instead of returning bounded command help JSON** — dogfooded 2026-04-30 for the 02:30 nudge on current `origin/main` / rebuilt `./rust/target/debug/claw` with embedded `git_sha` `d95b230c`. After verifying #358 covered `cost --help`, a fresh adjacent probe on the token-budget surface showed the same silent failure class: repeated bounded runs of `timeout 8 ./rust/target/debug/claw tokens --help --output-format json` exited `124` with `stdout=0` and `stderr=0`. In the same rebuilt binary, `version --output-format json` returned promptly with version/build metadata, proving the binary itself and JSON output path are reachable. This is distinct from #358's cost help hang: the affected surface is the sibling `tokens` command help, which agents use before estimating prompt/session token budgets. **Required fix shape:** (a) make `tokens --help --output-format json` return static/bounded stdout JSON with `kind:"help"` or `kind:"tokens"`, `action:"help"`, usage, options, examples, supported output formats, and related slash/direct commands; (b) ensure help rendering does not initialize slow token accounting, session, or provider state; (c) if any dynamic provider is consulted, return a typed JSON timeout/unavailable error instead of hanging; (d) add regression coverage proving tokens help in JSON mode returns within a deterministic budget. **Why this matters:** token budgeting is a preflight clawability surface. If help hangs silently, automation cannot safely discover how to inspect or constrain token usage before running expensive prompts, and budget-aware wrappers stall at the discovery step. Source: gaebal-gajae dogfood follow-up for the 02:30 nudge on rebuilt `./rust/target/debug/claw` `d95b230c`.
 381. **Top-level `cache --help --output-format json` hangs with zero stdout/stderr instead of returning bounded command help JSON** — dogfooded 2026-04-30 for the 03:00 nudge on current `origin/main` / rebuilt `./rust/target/debug/claw` with embedded `git_sha` `d95b230c`. After #358 and #380 landed for the cost/tokens preflight help hangs, a fresh adjacent probe on the cache-control surface showed the same silent failure class: repeated bounded runs of `timeout --kill-after=1s 8s ./rust/target/debug/claw cache --help --output-format json` exited `124` with `stdout=0` and `stderr=0`. In the same rebuilt binary, `version --output-format json` returned promptly with version/build metadata, proving the binary itself and JSON output path are reachable. This is distinct from the separate `/cache` slash-command envelope mismatch class: the affected surface here is top-level `cache` command help, where agents need bounded local discovery before deciding whether to inspect, clear, or summarize cache state. **Required fix shape:** (a) make `cache --help --output-format json` return static/bounded stdout JSON with `kind:"help"` or `kind:"cache"`, `action:"help"`, usage, options, examples, supported output formats, and related slash/direct commands; (b) ensure help rendering does not initialize slow cache/session/provider state; (c) if any dynamic provider is consulted, return a typed JSON timeout/unavailable error instead of hanging; (d) add regression coverage proving cache help in JSON mode returns within a deterministic budget. **Why this matters:** cache inspection and cleanup are recovery/control-plane operations. If cache help hangs silently, claws cannot safely discover cache semantics before attempting cleanup, and automation stalls before it can choose a non-destructive cache action. Source: gaebal-gajae dogfood follow-up for the 03:00 nudge on rebuilt `./rust/target/debug/claw` `d95b230c`.
 
-422. **`export --output-format json` and `--resume latest` report the same "no managed sessions" scenario using two different `kind` codes — `no_managed_sessions` vs `session_load_failed` — making "no session found" undetectable by a single kind-code check** — dogfooded 2026-04-30 KST (UTC+9) by Jobdori on `e939777f`. Running `claw export --output-format json` with no session present returns (on stderr, exit 1): `{"error":"no managed sessions found in .claw/sessions/<fingerprint>/","hint":"Start \`claw\` to create a session, then rerun with \`--resume latest\`.\nNote: claw partitions sessions per workspace fingerprint; sessions from other CWDs are invisible.","kind":"no_managed_sessions","type":"error"}`. Running `claw --resume latest /status --output-format json` with no session present returns (on stderr, exit 1): `{"error":"failed to restore session: no managed sessions found in .claw/sessions/<fingerprint>/","hint":"Start \`claw\` to create a session, then rerun with \`--resume latest\`.\nNote: claw partitions sessions per workspace fingerprint; sessions from other CWDs are invisible.","kind":"session_load_failed","type":"error"}`. Both describe the same root condition — there are no sessions to operate on — but they expose it via different `kind` discriminants. Automation that checks `kind == "no_managed_sessions"` to detect a cold workspace will miss the `--resume` path's `session_load_failed`, and vice versa. A wrapper that guards "run with --resume only if a session exists" must special-case both codes. The hint text is identical between them, suggesting the messages are logically equivalent. Additionally neither code matches the proposed canonical names `session_not_found` / `session_load_failed` as stable `ErrorKind` discriminants described in ROADMAP #77's fix shape, which explicitly proposes typed error-kind codes for session lifecycle failures. **Required fix shape:** (a) unify "no sessions found for this workspace fingerprint" under a single canonical `kind` code — either `no_managed_sessions` or `session_not_found` — used consistently by every command path that encounters an empty session registry; (b) if `session_load_failed` is a more general category (covering e.g. corrupt session files, IO errors, schema version mismatches), it should nest a concrete `reason:"no_managed_sessions"` or `reason:"session_not_found"` sub-field so callers can distinguish "empty registry" from "found but unreadable"; (c) align with the canonical error-kind contract proposed in #77; (d) add regression coverage proving `export` and `--resume latest` in an empty workspace both return an error with the same top-level `kind` code. **Why this matters:** session guard-rails in orchestration need a single stable `kind` to detect cold workspaces without enumerating all possible no-session synonyms. Two divergent codes for the same condition make defensive automation brittle and contradict the promise of machine-readable error envelopes. Source: Jobdori live dogfood, `e939777f`, 2026-04-30 KST (UTC+9).
+405. **`system-prompt --output-format json` returns `sections: string[]` (an array of raw prose blocks) and `message` (the same prose concatenated) — sections have no titles, no structured metadata, and the same content appears in two fields; automation cannot locate a named section (e.g. "# Doing tasks") without substring-matching raw prose** — dogfooded 2026-04-30 by Jobdori on `e939777f`. Running `./claw --output-format json system-prompt` returns `{"kind":"system-prompt","message":"<full prose, 5390 chars>","sections":["<block1>","<block2>",...9 items]}`. The `sections` field is a `string[]` where each element is a raw prose block — some start with `# Header` markdown, some are plain paragraphs, with no distinguishing structure. The `message` field is the sections joined as prose — identical content byte-for-byte when all sections are concatenated. An automation pipeline that wants only the "# Doing tasks" section must parse prose. **Required fix shape:** (a) make each `sections[]` entry a structured object with at minimum `title: string|null`, `content: string`, and `kind: "instruction"|"rule"|"context"|"other"`; (b) remove `message` or keep it as a `text` alias marked deprecated alongside a `schema_version`; (c) add a stable `section_count` top-level field; (d) add regression coverage proving `system-prompt --output-format json` exposes at least one named section detectable without prose substring search. Source: Jobdori live dogfood, `e939777f`, 2026-04-30.

rust/crates/commands/src/lib.rs

@@ -2371,40 +2371,6 @@ pub fn handle_skills_slash_command(args: Option<&str>, cwd: &Path) -> std::io::R
             let skills = load_skills_from_roots(&roots)?;
             Ok(render_skills_report(&skills))
         }
-        Some(args) if args.starts_with("list ") => {
-            let filter = args["list ".len()..].trim().to_lowercase();
-            let roots = discover_skill_roots(cwd);
-            let skills = load_skills_from_roots(&roots)?;
-            let filtered: Vec<_> = skills
-                .into_iter()
-                .filter(|s| s.name.to_lowercase().contains(&filter))
-                .collect();
-            Ok(render_skills_report(&filtered))
-        }
-        Some("show" | "info" | "describe") => {
-            let roots = discover_skill_roots(cwd);
-            let skills = load_skills_from_roots(&roots)?;
-            Ok(render_skills_report(&skills))
-        }
-        Some(args)
-            if args.starts_with("show ")
-                || args.starts_with("info ")
-                || args.starts_with("describe ") =>
-        {
-            let name = args
-                .splitn(2, ' ')
-                .nth(1)
-                .unwrap_or_default()
-                .trim()
-                .to_lowercase();
-            let roots = discover_skill_roots(cwd);
-            let skills = load_skills_from_roots(&roots)?;
-            let matched: Vec<_> = skills
-                .into_iter()
-                .filter(|s| s.name.to_lowercase() == name)
-                .collect();
-            Ok(render_skills_report(&matched))
-        }
         Some("install") => Ok(render_skills_usage(Some("install"))),
         Some(args) if args.starts_with("install ") => {
             let target = args["install ".len()..].trim();
@@ -2436,40 +2402,6 @@ pub fn handle_skills_slash_command_json(args: Option<&str>, cwd: &Path) -> std::
             let skills = load_skills_from_roots(&roots)?;
             Ok(render_skills_report_json(&skills))
         }
-        Some(args) if args.starts_with("list ") => {
-            let filter = args["list ".len()..].trim().to_lowercase();
-            let roots = discover_skill_roots(cwd);
-            let skills = load_skills_from_roots(&roots)?;
-            let filtered: Vec<_> = skills
-                .into_iter()
-                .filter(|s| s.name.to_lowercase().contains(&filter))
-                .collect();
-            Ok(render_skills_report_json(&filtered))
-        }
-        Some("show" | "info" | "describe") => {
-            let roots = discover_skill_roots(cwd);
-            let skills = load_skills_from_roots(&roots)?;
-            Ok(render_skills_report_json(&skills))
-        }
-        Some(args)
-            if args.starts_with("show ")
-                || args.starts_with("info ")
-                || args.starts_with("describe ") =>
-        {
-            let name = args
-                .splitn(2, ' ')
-                .nth(1)
-                .unwrap_or_default()
-                .trim()
-                .to_lowercase();
-            let roots = discover_skill_roots(cwd);
-            let skills = load_skills_from_roots(&roots)?;
-            let matched: Vec<_> = skills
-                .into_iter()
-                .filter(|s| s.name.to_lowercase() == name)
-                .collect();
-            Ok(render_skills_report_json(&matched))
-        }
         Some("install") => Ok(render_skills_usage_json(Some("install"))),
         Some(args) if args.starts_with("install ") => {
             let target = args["install ".len()..].trim();
@@ -2487,20 +2419,10 @@ pub fn handle_skills_slash_command_json(args: Option<&str>, cwd: &Path) -> std::
 #[must_use]
 pub fn classify_skills_slash_command(args: Option<&str>) -> SkillSlashDispatch {
     match normalize_optional_args(args) {
-        None | Some("list" | "help" | "-h" | "--help" | "show" | "info" | "describe") => {
-            SkillSlashDispatch::Local
-        }
+        None | Some("list" | "help" | "-h" | "--help") => SkillSlashDispatch::Local,
         Some(args) if args == "install" || args.starts_with("install ") => {
             SkillSlashDispatch::Local
         }
-        Some(args)
-            if args.starts_with("list ")
-                || args.starts_with("show ")
-                || args.starts_with("info ")
-                || args.starts_with("describe ") =>
-        {
-            SkillSlashDispatch::Local
-        }
         Some(args) => SkillSlashDispatch::Invoke(format!("${}", args.trim_start_matches('/'))),
     }
 }
@@ -2674,44 +2596,10 @@ fn render_mcp_report_for(
                 )),
             }
         }
-        Some(args) if args.split_whitespace().next() == Some("list") && args.contains(' ') => {
-            // `mcp list <filter>` — list does not accept arguments; treat as unsupported action.
-            Ok(render_mcp_unsupported_action_text(
-                args,
-                "list accepts no filter argument; use `claw mcp list`",
-            ))
-        }
-        Some(args) if matches!(args.split_whitespace().next(), Some("info" | "describe")) => {
-            Ok(render_mcp_unsupported_action_text(
-                args,
-                "use `claw mcp show <server>` to inspect a server",
-            ))
-        }
         Some(args) => Ok(render_mcp_usage(Some(args))),
     }
 }
 
-fn render_mcp_unsupported_action_text(action: &str, hint: &str) -> String {
-    format!(
-        "MCP\n  Error            unsupported action '{action}'\n  Hint             {hint}\n  Usage            /mcp [list|show <server>|help]"
-    )
-}
-
-fn render_mcp_unsupported_action_json(action: &str, hint: &str) -> Value {
-    json!({
-        "kind": "mcp",
-        "action": "error",
-        "ok": false,
-        "error_kind": "unsupported_action",
-        "requested_action": action,
-        "hint": hint,
-        "usage": {
-            "slash_command": "/mcp [list|show <server>|help]",
-            "direct_cli": "claw mcp [list|show <server>|help]",
-        },
-    })
-}
-
 fn render_mcp_report_json_for(
     loader: &ConfigLoader,
     cwd: &Path,
@@ -2792,18 +2680,6 @@ fn render_mcp_report_json_for(
                 })),
             }
         }
-        Some(args) if args.split_whitespace().next() == Some("list") && args.contains(' ') => {
-            Ok(render_mcp_unsupported_action_json(
-                args,
-                "list accepts no filter argument; use `claw mcp list`",
-            ))
-        }
-        Some(args) if matches!(args.split_whitespace().next(), Some("info" | "describe")) => {
-            Ok(render_mcp_unsupported_action_json(
-                args,
-                "use `claw mcp show <server>` to inspect a server",
-            ))
-        }
         Some(args) => Ok(render_mcp_usage_json(Some(args))),
     }
 }
@@ -4743,32 +4619,6 @@ mod tests {
         assert!(agents_error.contains("  Usage            /agents [list|help]"));
     }
 
-    #[test]
-    fn skills_show_and_list_filter_do_not_invoke_model() {
-        // `show`, `info`, `list <filter>` must route to Local, not Invoke.
-        // Regression for: `claw skills show plan` unexpectedly spawned a model session.
-        for token in &["show", "info", "describe"] {
-            assert_eq!(
-                classify_skills_slash_command(Some(token)),
-                SkillSlashDispatch::Local,
-                "`skills {token}` alone must be Local"
-            );
-        }
-        for prefix in &["show ", "info ", "list ", "describe "] {
-            let arg = format!("{prefix}plan");
-            assert_eq!(
-                classify_skills_slash_command(Some(&arg)),
-                SkillSlashDispatch::Local,
-                "`skills {arg}` must be Local, not Invoke"
-            );
-        }
-        // Bare invocable tokens still dispatch to Invoke.
-        assert_eq!(
-            classify_skills_slash_command(Some("plan")),
-            SkillSlashDispatch::Invoke("$plan".to_string()),
-        );
-    }
-
     #[test]
     fn accepts_skills_invocation_arguments_for_prompt_dispatch() {
         assert_eq!(
@@ -4791,38 +4641,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn mcp_unsupported_actions_return_typed_error_not_generic_help() {
-        // `mcp info <name>` and `mcp list <filter>` must return typed errors, not raw help.
-        // Regression for #504: these previously fell through to render_mcp_usage with
-        // unexpected=arg, giving no machine-readable error_kind.
-        use crate::handle_mcp_slash_command_json;
-        use std::path::PathBuf;
-        let cwd = PathBuf::from("/tmp");
-
-        let info_json = handle_mcp_slash_command_json(Some("info nonexistent"), &cwd)
-            .expect("info nonexistent should not error at IO level");
-        assert_eq!(info_json["kind"], "mcp");
-        assert_eq!(info_json["ok"], false);
-        assert_eq!(info_json["error_kind"], "unsupported_action");
-        assert!(info_json["hint"]
-            .as_str()
-            .unwrap_or_default()
-            .contains("show"));
-
-        let list_filter_json = handle_mcp_slash_command_json(Some("list nonexistent"), &cwd)
-            .expect("list nonexistent should not error at IO level");
-        assert_eq!(list_filter_json["kind"], "mcp");
-        assert_eq!(list_filter_json["ok"], false);
-        assert_eq!(list_filter_json["error_kind"], "unsupported_action");
-
-        let describe_json = handle_mcp_slash_command_json(Some("describe myserver"), &cwd)
-            .expect("describe myserver should not error at IO level");
-        assert_eq!(describe_json["kind"], "mcp");
-        assert_eq!(describe_json["ok"], false);
-        assert_eq!(describe_json["error_kind"], "unsupported_action");
-    }
-
     #[test]
     fn rejects_invalid_mcp_arguments() {
         let show_error = parse_error_message("/mcp show alpha beta");

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

@@ -877,17 +877,13 @@ fn parse_args(args: &[String]) -> Result<CliAction, String> {
         // `missing Anthropic credentials` even though the command is purely
         // local introspection. Mirror `agents`/`mcp`/`skills`: action is the
         // first positional arg, target is the second.
-        // `plugin` (singular) and `marketplace` are aliases for `plugins`.
-        // All three must route to the same local handler so that no form
-        // falls through to the LLM/prompt path.
-        "plugins" | "plugin" | "marketplace" => {
+        "plugins" => {
             let tail = &rest[1..];
             let action = tail.first().cloned();
             let target = tail.get(1).cloned();
             if tail.len() > 2 {
                 return Err(format!(
-                    "unexpected extra arguments after `claw {} {}`: {}",
-                    rest[0],
+                    "unexpected extra arguments after `claw plugins {}`: {}",
                     tail[..2].join(" "),
                     tail[2..].join(" ")
                 ));
@@ -930,14 +926,6 @@ fn parse_args(args: &[String]) -> Result<CliAction, String> {
             }
             Ok(CliAction::Diff { output_format })
         }
-        // `claw permissions <mode>` falls through to the LLM when called
-        // with a subcommand argument because parse_single_word_command_alias
-        // only intercepts the bare single-word form. Catch all multi-word
-        // forms here and return a structured guidance error so no network
-        // call or session is created.
-        "permissions" => Err(format!(
-            "`claw permissions` is a slash command. Start `claw` and run `/permissions` inside the REPL.\n  Usage  /permissions [read-only|workspace-write|danger-full-access]"
-        )),
         "skills" => {
             let args = join_optional_args(&rest[1..]);
             match classify_skills_slash_command(args.as_deref()) {
@@ -2639,15 +2627,12 @@ 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,
     })
 }
 
@@ -3538,10 +3523,10 @@ fn run_resume_command(
             Ok(ResumeCommandOutcome {
                 session: session.clone(),
                 message: Some(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)),
-                ),
+                json: Some(serde_json::json!({
+                    "kind": "agents",
+                    "text": handle_agents_slash_command(args.as_deref(), &cwd)?,
+                })),
             })
         }
         SlashCommand::Skills { args } => {
@@ -3557,37 +3542,6 @@ fn run_resume_command(
                 json: Some(handle_skills_slash_command_json(args.as_deref(), &cwd)?),
             })
         }
-        SlashCommand::Plugins { action, target } => {
-            // Only list is supported in resume mode (no runtime to reload)
-            match action.as_deref() {
-                Some("install") | Some("uninstall") | Some("enable") | Some("disable")
-                | Some("update") => {
-                    return Err(
-                        "resumed /plugins mutations are interactive-only; start `claw` and run `/plugins` in the REPL".into(),
-                    );
-                }
-                _ => {}
-            }
-            let cwd = env::current_dir()?;
-            let loader = ConfigLoader::default_for(&cwd);
-            let runtime_config = loader.load()?;
-            let mut manager = build_plugin_manager(&cwd, &loader, &runtime_config);
-            let result =
-                handle_plugins_slash_command(action.as_deref(), target.as_deref(), &mut manager)?;
-            let action_str = action.as_deref().unwrap_or("list");
-            let json = serde_json::json!({
-                "kind": "plugin",
-                "action": action_str,
-                "target": target,
-                "message": &result.message,
-                "reload_runtime": result.reload_runtime,
-            });
-            Ok(ResumeCommandOutcome {
-                session: session.clone(),
-                message: Some(result.message),
-                json: Some(json),
-            })
-        }
         SlashCommand::Doctor => {
             let report = render_doctor_report()?;
             Ok(ResumeCommandOutcome {
@@ -3674,6 +3628,7 @@ fn run_resume_command(
         | SlashCommand::Model { .. }
         | SlashCommand::Permissions { .. }
         | SlashCommand::Session { .. }
+        | SlashCommand::Plugins { .. }
         | SlashCommand::Login
         | SlashCommand::Logout
         | SlashCommand::Vim
@@ -5107,17 +5062,10 @@ impl LiveCli {
         let cwd = env::current_dir()?;
         match output_format {
             CliOutputFormat::Text => println!("{}", handle_mcp_slash_command(args, &cwd)?),
-            CliOutputFormat::Json => {
-                let value = handle_mcp_slash_command_json(args, &cwd)?;
-                // Propagate ok:false → non-zero exit so automation callers
-                // can rely on exit code instead of inspecting the envelope.
-                // (#68: mcp error envelopes previously always exited 0.)
-                let is_error = value.get("ok").and_then(|v| v.as_bool()) == Some(false);
-                println!("{}", serde_json::to_string_pretty(&value)?);
-                if is_error {
-                    std::process::exit(1);
-                }
-            }
+            CliOutputFormat::Json => println!(
+                "{}",
+                serde_json::to_string_pretty(&handle_mcp_slash_command_json(args, &cwd)?)?
+            ),
         }
         Ok(())
     }
@@ -6259,7 +6207,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);
@@ -6292,52 +6240,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,15 +30,6 @@ 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]
@@ -114,18 +105,6 @@ fn inventory_commands_emit_structured_json_when_requested() {
     let skills = assert_json_command(&root, &["--output-format", "json", "skills"]);
     assert_eq!(skills["kind"], "skills");
     assert_eq!(skills["action"], "list");
-
-    let plugins = assert_json_command(&root, &["--output-format", "json", "plugins"]);
-    assert_eq!(plugins["kind"], "plugin");
-    assert_eq!(plugins["action"], "list");
-    assert!(
-        plugins["reload_runtime"].is_boolean(),
-        "plugins reload_runtime should be a boolean"
-    );
-    assert!(
-        plugins["target"].is_null(),
-        "plugins target should be null when no plugin is targeted"
-    );
 }
 
 #[test]
@@ -369,62 +348,6 @@ 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"
-    );
-
-    let plugins = assert_json_command_with_env(
-        &root,
-        &[
-            "--output-format",
-            "json",
-            "--resume",
-            session_path.to_str().expect("utf8 session path"),
-            "/plugins",
-        ],
-        &[
-            (
-                "CLAW_CONFIG_HOME",
-                config_home.to_str().expect("utf8 config home"),
-            ),
-            ("HOME", home.to_str().expect("utf8 home")),
-        ],
-    );
-    assert_eq!(plugins["kind"], "plugin");
-    assert_eq!(plugins["action"], "list");
-    assert!(
-        plugins["reload_runtime"].is_boolean(),
-        "plugins reload_runtime should be a boolean"
-    );
-    assert!(
-        plugins["target"].is_null(),
-        "plugins target should be null when no plugin is targeted"
-    );
 }
 
 #[test]
@@ -461,44 +384,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,8 +227,6 @@ 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);
@@ -240,9 +238,7 @@ fn resumed_status_command_emits_structured_json_when_requested() {
         .expect("session should persist");
 
     // when
-    // 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(
+    let output = run_claw(
         &temp_dir,
         &[
             "--output-format",
@@ -251,7 +247,6 @@ 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

scripts/dogfood-build.sh

@@ -1,68 +0,0 @@
-#!/usr/bin/env bash
-# dogfood-build.sh — Build claw from current checkout and verify provenance.
-#
-# Injects GIT_SHA at build time so version JSON is non-null.
-# Suppresses Cargo compile noise on stderr.
-# Prints the verified binary path on success. Use as:
-#
-#   CLAW=$(bash scripts/dogfood-build.sh)
-#
-# Then dogfood with config isolation (avoids real user config bleeding in):
-#
-#   CLAW_CONFIG_HOME=$(mktemp -d) $CLAW plugins list --output-format json
-#
-set -euo pipefail
-
-REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-RUST_DIR="$REPO_ROOT/rust"
-BINARY="$RUST_DIR/target/debug/claw"
-EXPECTED_SHA="$(git -C "$REPO_ROOT" rev-parse --short HEAD)"
-
-echo "▶ Building claw from $REPO_ROOT" >&2
-echo "  Commit: $(git -C "$REPO_ROOT" log --oneline -1)" >&2
-
-# Inject GIT_SHA so version JSON returns a non-null sha.
-# Redirect cargo stderr to /dev/null to suppress compile noise;
-# on build failure cargo exits non-zero and set -e aborts.
-if ! GIT_SHA="$EXPECTED_SHA" cargo build \
-        --manifest-path "$RUST_DIR/Cargo.toml" \
-        -p rusty-claude-cli -q 2>/dev/null; then
-    # Re-run with visible output so the user sees the error
-    echo "✗ Build failed — rerunning with output:" >&2
-    GIT_SHA="$EXPECTED_SHA" cargo build \
-        --manifest-path "$RUST_DIR/Cargo.toml" \
-        -p rusty-claude-cli 2>&1 | sed 's/^/  /' >&2
-    exit 1
-fi
-
-if [[ ! -x "$BINARY" ]]; then
-    echo "✗ Binary not found at $BINARY" >&2
-    exit 1
-fi
-
-BINARY_SHA=$("$BINARY" version --output-format json 2>/dev/null \
-    | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('git_sha') or 'null')" 2>/dev/null \
-    || echo "null")
-
-if [[ "$BINARY_SHA" == "null" || -z "$BINARY_SHA" ]]; then
-    echo "✗ Provenance check failed: binary reports git_sha: null" >&2
-    exit 1
-fi
-
-if [[ "$BINARY_SHA" != "$EXPECTED_SHA" ]]; then
-    echo "✗ Provenance mismatch: binary=$BINARY_SHA, HEAD=$EXPECTED_SHA" >&2
-    exit 1
-fi
-
-echo "✓ Binary verified: $BINARY_SHA == HEAD" >&2
-echo "" >&2
-echo "  export CLAW=$BINARY" >&2
-echo "" >&2
-echo "  Dogfood with isolated config (no real user config on stderr):" >&2
-echo "    CLAW_ISOLATED=\$(mktemp -d)" >&2
-echo "    CLAW_CONFIG_HOME=\$CLAW_ISOLATED \$CLAW plugins list --output-format json" >&2
-echo "    rm -rf \$CLAW_ISOLATED" >&2
-echo "" >&2
-echo "  cargo run overhead: ~1s/invocation vs 7ms for pre-built binary." >&2
-echo "  Prefer pre-built binary (\$CLAW) for dogfood loops." >&2
-echo "$BINARY"