feat(tui): toggle ACP recording from agent picker

Author: CSRessel

nori-rs/acp/docs.md

@@ -142,6 +142,8 @@ When enabled, the resolved `AcpProxyConfig` stores logs under `$NORI_HOME/acp-wi
 
 The connection layer uses `sacp::Lines` to observe raw newline-delimited JSON-RPC messages at the transport boundary before or after SACP parsing. Each child process gets a distinct JSONL file named from the launch timestamp, child PID, and sanitized agent slug. Records include the timestamp, direction (`client_to_agent` or `agent_to_client`), agent slug, child PID, and the parsed JSON message. If a line cannot be parsed as JSON, the logger preserves the raw line and parse error instead of disrupting the live session.
 
+The TUI's `/agent` picker can persistently toggle this setting with `Shift-Tab`. Because the proxy wraps subprocess transports at spawn time, the toggle is intentionally a future-process setting: newly spawned ACP child subprocesses observe the updated config, while already-running subprocesses continue with the proxy state they started with.
+
 **Agent Config Field Resolution:**
 
 | Field | Purpose | Persistence |

nori-rs/tui/docs.md

@@ -31,7 +31,7 @@ Key dependencies: `ratatui` for rendering, `crossterm` for terminal events, `pul
 
 Entry point is `main.rs` which delegates to `run_app()` in `lib.rs`. The `run_main()` function loads `NoriConfig` once early and reuses it for both the auto-worktree setup and the `vertical_footer` setting (passed as a parameter to `run_ratatui_app()`). After loading config, `run_main()` initializes the agent registry via `nori_acp::initialize_registry()` with any custom `[[agents]]` defined in `config.toml` (see `@/nori-rs/acp/docs.md` for registry details). Initialization failure is non-fatal (logged as a warning).
 
-`NoriConfig` is also the source of truth for ACP backend diagnostics that do not have direct TUI controls yet. The chat widget passes the resolved ACP proxy configuration into `AcpBackendConfig` when spawning or resuming sessions, so enabling `[acp_proxy]` in config wraps every backend ACP subprocess in the wire logger without needing UI state in the TUI layer.
+`NoriConfig` is also the source of truth for ACP backend diagnostics. The chat widget passes the resolved ACP proxy configuration into `AcpBackendConfig` when spawning or resuming sessions, so enabling `[acp_proxy]` in config wraps every backend ACP subprocess in the wire logger without requiring the live backend to be reconfigured in place.
 
 The auto-worktree startup flow branches on the `AutoWorktree` enum (see `@/nori-rs/acp/docs.md`):
 
@@ -195,7 +195,7 @@ The drawer is inserted into the `FlexRenderable` layout in `ChatWidget::as_rende
 
 The config persists a boolean `pinned_plan_drawer` in `[tui]` of `config.toml`. At startup, `true` maps to `Expanded` and `false` maps to `Off`. Runtime toggling via Ctrl+O does not persist -- only the `/config` toggle persists.
 
-The Nori-specific agent picker UI lives in `nori/agent_picker.rs`, allowing users to select between available ACP agents.
+The Nori-specific agent picker UI lives in `nori/agent_picker.rs`, allowing users to select between available ACP agents. It also exposes the ACP wire JSONL recorder as a same-line footer hint: `Shift-Tab` toggles `[acp_proxy].enabled` through the app config persistence path, updates the open picker and slash-command status text, and applies to future ACP child subprocesses. Existing running ACP subprocesses keep the proxy setting they were spawned with.
 
 **System Info Collection** (`system_info.rs`):
 

nori-rs/tui/src/app/config_persistence.rs

@@ -1,4 +1,12 @@
 use super::*;
+use std::path::Path;
+
+async fn persist_acp_wire_recording_config(codex_home: &Path, enabled: bool) -> anyhow::Result<()> {
+    ConfigEditsBuilder::new(codex_home)
+        .set_path(&["acp_proxy", "enabled"], toml_value(enabled))
+        .apply()
+        .await
+}
 
 impl App {
     /// Persist a TUI config setting to config.toml and apply it immediately.
@@ -191,6 +199,23 @@ impl App {
             .add_info_message(format!("Pinned plan drawer {status}."), None);
     }
 
+    #[cfg(feature = "nori-config")]
+    pub(super) async fn persist_acp_wire_recording_setting(&mut self, enabled: bool) {
+        if let Err(err) = persist_acp_wire_recording_config(&self.config.codex_home, enabled).await
+        {
+            tracing::error!(error = %err, "failed to persist acp wire recording setting");
+            self.chat_widget
+                .add_error_message(format!("Failed to save ACP wire recording setting: {err}"));
+            return;
+        }
+
+        self.chat_widget.set_acp_wire_recording_enabled(enabled);
+        self.chat_widget.replace_agent_popup(enabled);
+        let status = if enabled { "enabled" } else { "disabled" };
+        self.chat_widget
+            .add_info_message(format!("ACP wire recording {status}."), None);
+    }
+
     #[cfg(feature = "nori-config")]
     pub(super) async fn persist_skillset_per_session_setting(&mut self, enabled: bool) {
         let builder = ConfigEditsBuilder::new(&self.config.codex_home)
@@ -435,3 +460,29 @@ impl App {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::TempDir;
+
+    #[tokio::test]
+    async fn persists_acp_wire_recording_to_top_level_acp_proxy_section() {
+        let temp = TempDir::new().expect("temp home");
+
+        persist_acp_wire_recording_config(temp.path(), true)
+            .await
+            .expect("persist recording enabled");
+
+        let content = std::fs::read_to_string(temp.path().join("config.toml"))
+            .expect("read persisted config");
+        let parsed: toml::Value = toml::from_str(&content).expect("config toml");
+        assert_eq!(
+            parsed
+                .get("acp_proxy")
+                .and_then(|section| section.get("enabled"))
+                .and_then(toml::Value::as_bool),
+            Some(true)
+        );
+    }
+}

nori-rs/tui/src/app/event_handling.rs

@@ -797,6 +797,10 @@ impl App {
                 self.persist_pinned_plan_drawer_setting(enabled).await;
             }
             #[cfg(feature = "nori-config")]
+            AppEvent::SetConfigAcpWireRecording(enabled) => {
+                self.persist_acp_wire_recording_setting(enabled).await;
+            }
+            #[cfg(feature = "nori-config")]
             AppEvent::OpenSkillsetPerSessionWorktreeChoice => {
                 self.chat_widget.open_skillset_worktree_choice_picker();
             }

nori-rs/tui/src/app_event.rs

@@ -320,6 +320,10 @@ pub(crate) enum AppEvent {
     #[cfg(feature = "nori-config")]
     SetConfigPinnedPlanDrawer(bool),
 
+    /// Set ACP wire JSONL recording for future ACP child subprocesses.
+    #[cfg(feature = "nori-config")]
+    SetConfigAcpWireRecording(bool),
+
     /// Open the worktree choice modal when enabling per-session skillsets.
     #[cfg(feature = "nori-config")]
     OpenSkillsetPerSessionWorktreeChoice,

nori-rs/tui/src/bottom_pane/chat_composer/mod.rs

@@ -116,7 +116,7 @@ pub(crate) struct ChatComposer {
     custom_prompts: Vec<CustomPrompt>,
     agent_commands: Vec<nori_protocol::AgentCommandInfo>,
     agent_command_prefix: String,
-    command_description_overrides: HashMap<SlashCommand, String>,
+    command_description_overrides: HashMap<SlashCommand, Line<'static>>,
     footer_mode: FooterMode,
     footer_hint_override: Option<Vec<(String, String)>>,
     context_window_percent: Option<i64>,
@@ -391,6 +391,15 @@ impl ChatComposer {
     }
 
     pub(crate) fn set_command_description_override(&mut self, cmd: SlashCommand, desc: String) {
+        self.command_description_overrides
+            .insert(cmd, Line::from(desc));
+    }
+
+    pub(crate) fn set_command_description_override_line(
+        &mut self,
+        cmd: SlashCommand,
+        desc: Line<'static>,
+    ) {
         self.command_description_overrides.insert(cmd, desc);
     }
 

nori-rs/tui/src/bottom_pane/command_popup.rs

@@ -1,5 +1,6 @@
 use ratatui::buffer::Buffer;
 use ratatui::layout::Rect;
+use ratatui::text::Line;
 use ratatui::widgets::WidgetRef;
 
 use super::popup_consts::MAX_POPUP_ROWS;
@@ -35,7 +36,7 @@ pub(crate) struct CommandPopup {
     agent_commands: Vec<AgentCommandInfo>,
     agent_command_prefix: String,
     state: ScrollState,
-    description_overrides: HashMap<SlashCommand, String>,
+    description_overrides: HashMap<SlashCommand, Line<'static>>,
 }
 
 impl CommandPopup {
@@ -47,7 +48,7 @@ impl CommandPopup {
     #[cfg(test)]
     pub(crate) fn new_with_overrides(
         prompts: Vec<CustomPrompt>,
-        description_overrides: HashMap<SlashCommand, String>,
+        description_overrides: HashMap<SlashCommand, Line<'static>>,
     ) -> Self {
         Self::new_full(prompts, Vec::new(), String::new(), description_overrides)
     }
@@ -56,7 +57,7 @@ impl CommandPopup {
         mut prompts: Vec<CustomPrompt>,
         agent_commands: Vec<AgentCommandInfo>,
         agent_command_prefix: String,
-        description_overrides: HashMap<SlashCommand, String>,
+        description_overrides: HashMap<SlashCommand, Line<'static>>,
     ) -> Self {
         let builtins = built_in_slash_commands();
         // Exclude prompts that collide with builtin command names and sort by name.
@@ -229,14 +230,20 @@ impl CommandPopup {
         matches
             .into_iter()
             .map(|(item, indices, _)| {
-                let (name, description) = match item {
+                let (name, description, styled_description) = match item {
                     CommandItem::Builtin(cmd) => {
-                        let desc = self
-                            .description_overrides
-                            .get(&cmd)
-                            .cloned()
-                            .unwrap_or_else(|| cmd.description().to_string());
-                        (format!("/{}", cmd.command()), desc)
+                        let (description, styled_description) = if let Some(desc_line) =
+                            self.description_overrides.get(&cmd).cloned()
+                        {
+                            (desc_line.to_string(), Some(desc_line))
+                        } else {
+                            (cmd.description().to_string(), None)
+                        };
+                        (
+                            format!("/{}", cmd.command()),
+                            description,
+                            styled_description,
+                        )
                     }
                     CommandItem::UserPrompt(i) => {
                         let prompt = &self.prompts[i];
@@ -247,19 +254,21 @@ impl CommandPopup {
                         (
                             format!("/{PROMPTS_CMD_PREFIX}:{}", prompt.name),
                             description,
+                            None,
                         )
                     }
                     CommandItem::AgentCommand(i) => {
                         let display_key = self.agent_command_display_key(i);
                         let cmd = &self.agent_commands[i];
-                        (format!("/{display_key}"), cmd.description.clone())
+                        (format!("/{display_key}"), cmd.description.clone(), None)
                     }
                 };
                 GenericDisplayRow {
                     name,
                     match_indices: indices.map(|v| v.into_iter().map(|i| i + 1).collect()),
                     display_shortcut: None,
                     description: Some(description),
+                    styled_description,
                 }
             })
             .collect()
@@ -452,7 +461,7 @@ mod tests {
         let mut overrides = HashMap::new();
         overrides.insert(
             SlashCommand::Agent,
-            "switch between available ACP agents (current: Claude Code)".to_string(),
+            Line::from("switch between available ACP agents (current: Claude Code)"),
         );
         let popup = CommandPopup::new_with_overrides(Vec::new(), overrides);
         let rows =
@@ -469,7 +478,7 @@ mod tests {
         let mut overrides = HashMap::new();
         overrides.insert(
             SlashCommand::Agent,
-            "switch between available ACP agents (current: Claude Code)".to_string(),
+            Line::from("switch between available ACP agents (current: Claude Code)"),
         );
         let popup = CommandPopup::new_with_overrides(Vec::new(), overrides);
         let rows =

nori-rs/tui/src/bottom_pane/file_search_popup.rs

@@ -131,6 +131,7 @@ impl WidgetRef for &FileSearchPopup {
                         .map(|v| v.iter().map(|&i| i as usize).collect()),
                     display_shortcut: None,
                     description: None,
+                    styled_description: None,
                 })
                 .collect()
         };