feat(config): mid-session edit tool, advisor, and auto preference

crates/rho/src/app/automation.rs

@@ -504,7 +504,7 @@ async fn run_session_with_output(
                 workspace,
                 workspace_policy: AppPolicy::for_mode(startup.config.permission_mode),
                 approval_session: startup.approval_session.clone(),
-                system_prompt: system_prompt.for_advisor_mode(tool_set.advisor_registered()),
+                system_prompt: system_prompt.get(),
                 reasoning: sdk_options.runtime.reasoning,
                 service_tier: sdk_options.runtime.service_tier,
                 compaction,

crates/rho/src/app/interactive_runtime.rs

@@ -722,6 +722,61 @@ impl InteractiveRuntime {
         Ok(())
     }
 
+    /// Swaps the advertised file edit tool for the next turn.
+    ///
+    /// Keeps the system prompt fixed for prompt-cache stability. Callers should
+    /// append [`Self::notify_edit_tool_switch`] after a successful save so the
+    /// model sees the new surface even when older prompt text mentions the
+    /// previous tool. Returns the previous format when the tool list changed.
+    pub(crate) async fn set_edit_tool(
+        &mut self,
+        edit_tool: crate::config::EditTool,
+        max_output_bytes: usize,
+    ) -> anyhow::Result<Option<crate::config::EditTool>> {
+        if self.runs.is_active() {
+            anyhow::bail!("edit tool cannot change while a run is active");
+        }
+        let Some(previous) = self.tools.set_edit_tool(edit_tool, max_output_bytes) else {
+            return Ok(None);
+        };
+        match self.rebind_current_session().await {
+            Ok(()) => Ok(Some(previous)),
+            Err(error) => {
+                let _ = self.tools.set_edit_tool(previous, max_output_bytes);
+                Err(error)
+            }
+        }
+    }
+
+    /// Appends a model-facing notice that the edit tool changed mid-session.
+    ///
+    /// Includes the live tool description and input schema so the model can use
+    /// the new surface without a system-prompt rewrite.
+    pub(crate) fn notify_edit_tool_switch(
+        &mut self,
+        previous: crate::config::EditTool,
+        current: crate::config::EditTool,
+    ) -> anyhow::Result<String> {
+        let spec = self
+            .tools
+            .specs()
+            .into_iter()
+            .find(|spec| spec.name == current.tool_name())
+            .ok_or_else(|| {
+                anyhow::anyhow!(
+                    "edit tool `{}` is missing after the mid-session switch",
+                    current.tool_name()
+                )
+            })?;
+        let (model, display) = edit_tool_switch_prompts(previous, current, &spec);
+        self.append_user_context_with_display(model, display.clone())?;
+        Ok(display)
+    }
+
+    pub(crate) fn tool_specs(&self) -> Vec<rho_sdk::model::ToolSpec> {
+        self.tools.specs()
+    }
+
     pub(crate) async fn shutdown(&mut self) {
         if self.runs.is_active() {
             debug_assert_eq!(
@@ -886,6 +941,40 @@ impl InteractiveRuntime {
     }
 }
 
+/// Model and display text for a mid-session edit-tool switch.
+///
+/// The system prompt stays fixed for prompt caching. This notice carries the
+/// new tool contract so the model stops using the previous surface.
+fn edit_tool_switch_prompts(
+    previous: crate::config::EditTool,
+    current: crate::config::EditTool,
+    spec: &rho_sdk::model::ToolSpec,
+) -> (String, String) {
+    let schema = serde_json::to_string_pretty(&spec.input_schema).unwrap_or_else(|_| "{}".into());
+    let model = format!(
+        "[edit tool switched]\n\n\
+The file edit tool changed mid-session. Do not call `{previous_name}` anymore.\n\
+Use `{current_name}` for edits to existing UTF-8 files from now on.\n\
+Prefer `write` only to create or fully rewrite a file.\n\
+Any earlier system-prompt guidance about `{previous_name}` is superseded by this notice and the live tool list.\n\n\
+Previous tool: `{previous_name}` ({previous_label})\n\
+Current tool: `{current_name}` ({current_label})\n\n\
+Tool schema for `{current_name}`:\n\
+description:\n\
+{description}\n\n\
+input_schema:\n\
+{schema}\n",
+        previous_name = previous.tool_name(),
+        current_name = current.tool_name(),
+        previous_label = previous.as_str(),
+        current_label = current.as_str(),
+        description = spec.description,
+        schema = schema,
+    );
+    let display = format!("edit tool switched to {}", current.as_str());
+    (model, display)
+}
+
 #[cfg(test)]
 #[path = "interactive_runtime_tests.rs"]
 mod tests;

crates/rho/src/app/interactive_runtime_advisor.rs

@@ -1,10 +1,13 @@
 //! Advisor mode as a runtime state transition.
 //!
-//! Advisor mode changes the tool list and the system prompt, neither of which
-//! the SDK can swap on a live runtime. Turning it on or off therefore rebuilds
-//! the runtime and rebinds the session, the same move a permission-mode change
-//! makes, so the change lands on the next turn and the session ID and history
-//! survive it.
+//! Advisor mode changes the advertised tool list, which the SDK cannot swap on
+//! a live runtime. Turning it on or off therefore rebuilds the runtime and
+//! rebinds the session so the change lands on the next turn. The session ID and
+//! history survive it.
+//!
+//! The system prompt stays fixed for prompt-cache stability. The model learns
+//! about the tool list change from an appended context notice (with the tool
+//! schema when enabling) rather than a rewritten system prompt.
 
 use std::sync::Arc;
 
@@ -20,31 +23,33 @@ use super::super::{
 use super::InteractiveRuntime;
 
 impl InteractiveRuntime {
-    /// The system prompt for the tools this run currently offers.
+    /// Fixed system prompt for this session.
+    ///
+    /// Mid-session tool list changes keep this value stable and tell the model
+    /// through appended context instead.
     pub(super) fn active_system_prompt(&self) -> SystemPrompt {
-        self.system_prompt
-            .for_advisor_mode(self.tools.advisor_registered())
+        self.system_prompt.get()
     }
 
     /// Applies an advisor mode or advisor model change to the next turn.
     ///
     /// `model` is the advisor model to use, or `None` when advisor mode is off
     /// or has no model yet; those are the same thing to the executor. The live
     /// tool reads the new model at once. Registering or removing the `advisor`
-    /// tool also changes the tool list and the system prompt, so it needs the
-    /// same runtime rebuild as a permission-mode change; the session ID and
-    /// history survive it.
+    /// tool rebuilds the runtime without rewriting the system prompt, then
+    /// appends a context notice. Returns display text for a transcript notice
+    /// when the tool list changed.
     pub(crate) async fn set_advisor(
         &mut self,
         model: Option<InternalAgentModelConfig>,
-    ) -> anyhow::Result<()> {
+    ) -> anyhow::Result<Option<String>> {
         let Some(store) = self.tools.advisor().cloned() else {
-            return Ok(());
+            return Ok(None);
         };
         let registered = model.is_some();
         if registered == self.tools.advisor_registered() {
             store.set_model(model);
-            return Ok(());
+            return Ok(None);
         }
         if self.runs.is_active() {
             anyhow::bail!("advisor mode cannot change while a run is active");
@@ -56,7 +61,8 @@ impl InteractiveRuntime {
         match self.rebind_current_session().await {
             Ok(()) => {
                 store.set_model(model);
-                Ok(())
+                let display = self.append_advisor_switch_notice(registered)?;
+                Ok(Some(display))
             }
             Err(error) => {
                 self.tools.set_advisor_registered(!registered);
@@ -65,10 +71,32 @@ impl InteractiveRuntime {
         }
     }
 
+    fn append_advisor_switch_notice(&mut self, enabled: bool) -> anyhow::Result<String> {
+        let (model, display) = if enabled {
+            let spec = self
+                .tools
+                .specs()
+                .into_iter()
+                .find(|spec| spec.name == crate::tools::advisor::TOOL_NAME)
+                .ok_or_else(|| {
+                    anyhow::anyhow!("advisor tool is missing after it was registered")
+                })?;
+            crate::prompt::advisor_enabled_context(&spec)
+        } else {
+            crate::prompt::advisor_disabled_context()
+        };
+        self.append_user_context_with_display(model, display.clone())?;
+        Ok(display)
+    }
+
     /// Rebuilds the SDK runtime around the current tools and prompt, then
     /// rebinds the live session onto it. The live runtime is replaced only
     /// after the replacement is ready, so a failure leaves the session intact.
-    async fn rebind_current_session(&mut self) -> anyhow::Result<()> {
+    ///
+    /// Callers that change the advertised tool list should keep the system
+    /// prompt fixed for prompt-cache stability and tell the model about the
+    /// change with an appended context message instead.
+    pub(super) async fn rebind_current_session(&mut self) -> anyhow::Result<()> {
         let snapshot = self.sessions.session().snapshot();
         let replacement_runtime = build_runtime(RuntimeBuildOptions {
             provider: Arc::clone(self.provider.provider()),

crates/rho/src/app/interactive_runtime_startup.rs

@@ -101,7 +101,7 @@ pub(super) async fn initialize(
             approval_session: approval_handler
                 .clone()
                 .map(rho_sdk::ApprovalSession::from_shared),
-            system_prompt: system_prompt.for_advisor_mode(tools.advisor_registered()),
+            system_prompt: system_prompt.get(),
             reasoning: sdk_options.runtime.reasoning,
             service_tier: sdk_options.runtime.service_tier,
             compaction: compaction.clone(),

crates/rho/src/app/interactive_runtime_tests.rs

@@ -638,12 +638,15 @@ fn advisor_model() -> crate::config::InternalAgentModelConfig {
 }
 
 // Covers: toggling advisor mode mid-session must add and remove the advisor tool
-// for the next turn while the session ID and history survive the rebuild.
+// for the next turn without rewriting the system prompt, while the session ID
+// survives and a model-facing schema notice is appended.
 // Owner: interactive runtime advisor state transition.
 #[tokio::test]
 async fn advisor_mode_changes_the_tool_list_without_replacing_the_session() {
     let mut interactive = advisor_test_runtime().await;
     let session_id = interactive.sessions.session().id().clone();
+    let history_before = interactive.history().len();
+    let system_before = interactive.system_prompt.clone();
     let advertised = |interactive: &InteractiveRuntime| {
         interactive
             .runtime
@@ -655,18 +658,133 @@ async fn advisor_mode_changes_the_tool_list_without_replacing_the_session() {
 
     assert!(!interactive.tools.advisor_registered());
 
-    interactive
+    let enabled = interactive
         .set_advisor(Some(advisor_model()))
         .await
         .unwrap();
-
+    assert_eq!(enabled.as_deref(), Some("advisor mode on"));
     assert!(interactive.tools.advisor_registered());
     assert!(advertised(&interactive));
     assert_eq!(interactive.sessions.session().id(), &session_id);
-
-    interactive.set_advisor(None).await.unwrap();
-
+    assert_eq!(interactive.system_prompt, system_before);
+    assert_eq!(interactive.history().len(), history_before + 1);
+    let enabled_notice = interactive.history().last().expect("enable notice").clone();
+    let Message::User(blocks) = &enabled_notice else {
+        panic!("expected user notice, got {enabled_notice:?}");
+    };
+    let enabled_text = blocks
+        .iter()
+        .filter_map(|block| match block {
+            ContentBlock::Text(text) => Some(text.as_str()),
+            _ => None,
+        })
+        .collect::<String>();
+    assert!(enabled_text.contains("[advisor mode on]"));
+    assert!(enabled_text.contains("input_schema:"));
+    assert!(enabled_text.contains("`advisor`"));
+
+    let disabled = interactive.set_advisor(None).await.unwrap();
+    assert_eq!(disabled.as_deref(), Some("advisor mode off"));
     assert!(!interactive.tools.advisor_registered());
     assert!(!advertised(&interactive));
     assert_eq!(interactive.sessions.session().id(), &session_id);
+    assert_eq!(interactive.system_prompt, system_before);
+    assert_eq!(interactive.history().len(), history_before + 2);
+    let disabled_notice = interactive
+        .history()
+        .last()
+        .expect("disable notice")
+        .clone();
+    let Message::User(blocks) = &disabled_notice else {
+        panic!("expected user notice, got {disabled_notice:?}");
+    };
+    let disabled_text = blocks
+        .iter()
+        .filter_map(|block| match block {
+            ContentBlock::Text(text) => Some(text.as_str()),
+            _ => None,
+        })
+        .collect::<String>();
+    assert!(disabled_text.contains("[advisor mode off]"));
+    assert!(disabled_text.contains("no longer available"));
+}
+
+async fn edit_tool_test_runtime() -> InteractiveRuntime {
+    let mut interactive = pending_compaction_runtime("done").await;
+    let config = Config {
+        edit_tool: crate::config::EditTool::Hashline,
+        ..Config::default()
+    };
+    interactive.tools = AppToolSet::new(
+        &config,
+        RuntimeDiagnostics::new(&config),
+        ToolSetOptions::new(AgentCapabilities::new(
+            [ToolCapability::Edit, ToolCapability::ReadFile]
+                .into_iter()
+                .collect(),
+        )),
+    );
+    interactive
+}
+
+// Covers: /config edit-tool selection must swap the advertised edit surface for
+// the next turn without rewriting the system prompt, while the session ID
+// survives and a model-facing schema notice is appended.
+// Owner: interactive runtime edit-tool state transition.
+#[tokio::test]
+async fn edit_tool_switch_rebuilds_tools_and_appends_schema_notice() {
+    let mut interactive = edit_tool_test_runtime().await;
+    let session_id = interactive.sessions.session().id().clone();
+    let history_before = interactive.history().len();
+    let system_before = interactive.system_prompt.clone();
+    let advertised = |interactive: &InteractiveRuntime, name: &str| {
+        interactive
+            .runtime
+            .diagnostics()
+            .tools()
+            .iter()
+            .any(|tool| tool.name() == name)
+    };
+
+    assert!(interactive.tools.contains("edit"));
+    assert!(!interactive.tools.contains("str_replace"));
+
+    let previous = interactive
+        .set_edit_tool(
+            crate::config::EditTool::StrReplace,
+            Config::default().max_output_bytes,
+        )
+        .await
+        .unwrap();
+    assert_eq!(previous, Some(crate::config::EditTool::Hashline));
+    assert_eq!(interactive.system_prompt, system_before);
+    assert!(interactive.tools.contains("str_replace"));
+    assert!(!interactive.tools.contains("edit"));
+    assert!(advertised(&interactive, "str_replace"));
+    assert!(!advertised(&interactive, "edit"));
+    assert_eq!(interactive.sessions.session().id(), &session_id);
+
+    let display = interactive
+        .notify_edit_tool_switch(
+            crate::config::EditTool::Hashline,
+            crate::config::EditTool::StrReplace,
+        )
+        .unwrap();
+    assert_eq!(display, "edit tool switched to str_replace");
+    assert_eq!(interactive.history().len(), history_before + 1);
+    let notice = interactive.history().last().expect("switch notice").clone();
+    let Message::User(blocks) = &notice else {
+        panic!("expected user notice, got {notice:?}");
+    };
+    let text = blocks
+        .iter()
+        .filter_map(|block| match block {
+            ContentBlock::Text(text) => Some(text.as_str()),
+            _ => None,
+        })
+        .collect::<String>();
+    assert!(text.contains("[edit tool switched]"));
+    assert!(text.contains("`str_replace`"));
+    assert!(text.contains("input_schema:"));
+    assert!(!text.contains("restart"));
 }