Group MCP servers under one banner header, route them above the TUI viewport, and quieten their stderr relay

Author: alexylon

CHANGELOG.md

@@ -19,6 +19,8 @@ All notable changes to Sofos are documented in this file.
 - **A pathologically large token count from the Anthropic API now saturates at the 32-bit ceiling instead of wrapping to a small number.** The 32-bit ceiling sits well above any realistic single-turn count, so this only matters as a defence against a misreported wire value, but if such a value ever arrives the reported count stays believable.
 - **The `anthropic-beta` header now agrees with the request body about which models support server-side compaction.** Earlier, the header check used its own model-prefix list while the body's `context_management` field used the per-model `ModelInfo` flag. A model that one source listed and the other did not (for example `claude-opus-4-5`) used to ship the compaction beta token while the body never carried the matching field, which can 400 on stricter validation. Both sources now read from the same `ModelInfo::supports_server_compaction` flag.
 - **Ctrl+Enter now inserts a newline in the TUI input box, matching Shift+Enter and Alt+Enter.** Earlier the keystroke was silently swallowed by the textarea router, even though the placeholder text and the dispatch comments already documented it as a fallback newline binding for terminals that do not deliver Shift+Enter distinctly.
+- **MCP server "initialized" lines no longer get scrolled off-screen by the TUI viewport at startup.** They used to print straight to stdout while sofos was still connecting servers, before the inline viewport anchored — on tight windows the viewport then scrolled the lines out of view as it made room for itself. The lines now ride the same deferred-banner replay path as the workspace/model header, so they always land above the viewport.
+- **MCP server stderr no longer floods the default log with WARN-level chatter, and the lines read as plain text instead of escaped ANSI.** Many MCP servers reserve stdout for JSON-RPC and emit their own INFO/DEBUG lines (often pre-coloured) to stderr; sofos used to relay every line through `tracing::warn!`, so a clean startup printed a wall of WARN messages with `\x1b[…]` escape sequences baked in. The relay now uses `tracing::debug!` and strips CSI runs first — real connect or list-tools failures still surface as WARN from `manager.rs`, and the raw lines are still available via `RUST_LOG=debug`.
 - **Setting `compaction_preserve_recent` to `0` no longer crashes the next compaction.** The split-point lookup used to index one past the end of the message list and panic. It now clamps to the last valid index, so a zero-preserve configuration just compacts everything older than the very last message.
 - **The summary call's token usage is now counted toward the session total.** When auto-compaction got a usable response from the model but the summary was too short to apply (fell back to plain trimming), sofos used to discard the response without billing it; the spend now lands on the session counters in every Ok path.
 - **The auto-compaction summary call no longer fights the prompt cache.** The one-shot summary used to share the OpenAI prompt-cache shard with the regular session, so the two distinct prefixes evicted each other on every compaction. The summary call now uses a `"<session>-summary"` shard of its own.

Cargo.lock

@@ -29,7 +29,7 @@ pulldown-cmark = "0.13"
 similar = "3"
 crossterm = "0.29"
 ratatui = { version = "0.30", features = ["unstable-rendered-line-info", "scrolling-regions"] }
-tui-textarea = { package = "tui-textarea-2", version = "0.10" }
+tui-textarea = { package = "tui-textarea-2", version = "0.11" }
 ansi-to-tui = "8"
 os_pipe = "1"
 libc = "0.2"

Cargo.toml

@@ -126,8 +126,6 @@ fn main() -> Result<()> {
         }
     });
 
-    startup_banner.push('\n');
-
     if !interactive_mode {
         print!("{}", startup_banner);
     }
@@ -140,8 +138,17 @@ fn main() -> Result<()> {
     );
 
     let mut repl = Repl::new(client, config, workspace.clone(), morph_client)?;
+    // MCP block sits flush below the workspace/model labels (no blank
+    // line in between), then a single trailing newline separates the
+    // banner from the welcome (interactive) or the next CLI output
+    // (one-shot). When there are no servers the trailing `\n` alone
+    // gives the same blank-line separator the old banner had.
+    let mcp_section = format!("{}\n", repl.take_mcp_init_lines());
     if interactive_mode {
+        startup_banner.push_str(&mcp_section);
         repl.set_startup_banner(startup_banner);
+    } else {
+        print!("{}", mcp_section);
     }
 
     if cli.resume {

src/main.rs

@@ -44,12 +44,21 @@ pub struct McpManager {
 }
 
 impl McpManager {
-    pub async fn new(workspace: PathBuf) -> Result<Self> {
+    /// Returns the manager and a pre-formatted startup block for the
+    /// caller to fold into the TUI banner. The block is empty when no
+    /// servers connected; otherwise it carries an `MCP servers:` header
+    /// followed by one indented `✓ name (N tools)` bullet per server,
+    /// matching the workspace/model section above it. Printing this
+    /// block here would land on the raw terminal before `OutputCapture`
+    /// is installed, and the inline viewport scrolls it off-screen when
+    /// it anchors.
+    pub async fn new(workspace: PathBuf) -> Result<(Self, String)> {
         let server_configs = load_mcp_config(&workspace);
 
         let mut clients: HashMap<String, Arc<McpClient>> = HashMap::new();
         let mut tools_by_server: HashMap<String, Vec<McpTool>> = HashMap::new();
         let mut tool_to_server: HashMap<String, String> = HashMap::new();
+        let mut bullets = String::new();
 
         for (server_name, config) in server_configs {
             match McpClient::connect(server_name.clone(), config).await {
@@ -65,12 +74,12 @@ impl McpManager {
                             }
                             tools_by_server.insert(server_name.clone(), tools);
                             clients.insert(server_name.clone(), Arc::new(client));
-                            println!(
-                                "{} MCP server '{}' initialized ({} tools)",
+                            bullets.push_str(&format!(
+                                "  {} {} ({} tools)\n",
                                 "✓".bright_green(),
                                 server_name.bright_cyan(),
                                 tool_count
-                            );
+                            ));
                         }
                         Err(e) => {
                             tracing::warn!(
@@ -91,11 +100,17 @@ impl McpManager {
             }
         }
 
-        Ok(Self {
+        let manager = Self {
             clients: Arc::new(Mutex::new(clients)),
             tools_by_server: Arc::new(tools_by_server),
             tool_to_server: Arc::new(tool_to_server),
-        })
+        };
+        let init_block = if bullets.is_empty() {
+            String::new()
+        } else {
+            format!("{}\n{}", "MCP servers:".bright_green(), bullets)
+        };
+        Ok((manager, init_block))
     }
 
     /// Get all available MCP tools from all connected servers.

src/mcp/manager.rs

@@ -38,20 +38,24 @@ fn take_child_pipes(
 }
 
 /// Drain the child's stderr line-by-line on a blocking worker and route
-/// each line through `tracing::warn!` tagged with the server name. The
-/// previous transport used `Stdio::null()` for stderr, so a misconfigured
-/// or crashing MCP server gave the user no clue what was wrong — the
-/// only signal was an opaque "failed to parse" or "connection closed"
-/// downstream. Capturing through `tracing` keeps the noise out of the
-/// foreground TUI but makes the diagnostics discoverable via
-/// `SOFOS_LOG=warn` or wherever the user has tracing pointed.
+/// each line through `tracing::debug!` tagged with the server name.
+/// Servers reserve stdout for JSON-RPC and emit their own INFO/DEBUG
+/// logs to stderr, so treating every line as a warning floods the
+/// default-level (WARN) log with normal startup chatter. Real failures
+/// still surface as WARN from the connect / list-tools paths in
+/// `manager.rs`; raw stderr is opt-in via `RUST_LOG=debug`.
+///
+/// ANSI escapes are stripped before logging because tracing's default
+/// formatter renders control bytes as `\x1b[…]` literals, which is what
+/// the user actually sees on the terminal otherwise.
 fn spawn_stderr_reader(server_name: String, stderr: ChildStderr) {
     tokio::task::spawn_blocking(move || {
         let reader = BufReader::new(stderr);
         for line in reader.lines() {
             match line {
                 Ok(text) => {
-                    tracing::warn!(server = %server_name, "mcp stderr: {}", text);
+                    let clean = strip_ansi_escapes(&text);
+                    tracing::debug!(server = %server_name, "mcp stderr: {}", clean);
                 }
                 Err(e) => {
                     tracing::warn!(
@@ -66,6 +70,29 @@ fn spawn_stderr_reader(server_name: String, stderr: ChildStderr) {
     });
 }
 
+/// Remove CSI sequences (`ESC [ … final-byte`) and the bare `ESC` so log
+/// lines stay readable when the child wraps its output in ANSI styling.
+/// Final bytes of a CSI run sit in `0x40..=0x7e`; we also tolerate a
+/// stray `ESC` with no following bracket by skipping the next char.
+fn strip_ansi_escapes(s: &str) -> String {
+    let mut out = String::with_capacity(s.len());
+    let mut chars = s.chars();
+    while let Some(c) = chars.next() {
+        if c != '\x1b' {
+            out.push(c);
+            continue;
+        }
+        if let Some('[') = chars.next() {
+            for cc in chars.by_ref() {
+                if matches!(cc, '\x40'..='\x7e') {
+                    break;
+                }
+            }
+        }
+    }
+    out
+}
+
 /// Write a single stdio message to the server (JSON-RPC request *or*
 /// notification). Shared by `send_request` and `send_notification` so
 /// the lock/write/flush sequence lives in one place.
@@ -353,3 +380,27 @@ impl StdioClient {
         parse_call_tool_response(result)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::strip_ansi_escapes;
+
+    #[test]
+    fn strips_csi_color_run() {
+        let input = "\x1b[2m2026-05-15T22:34:54.965614Z\x1b[0m \x1b[32m INFO\x1b[0m start";
+        assert_eq!(
+            strip_ansi_escapes(input),
+            "2026-05-15T22:34:54.965614Z  INFO start"
+        );
+    }
+
+    #[test]
+    fn passes_plain_text_through() {
+        assert_eq!(strip_ansi_escapes("no escapes here"), "no escapes here");
+    }
+
+    #[test]
+    fn drops_bare_escape() {
+        assert_eq!(strip_ansi_escapes("a\x1bXb"), "ab");
+    }
+}

src/mcp/transport/stdio.rs

@@ -80,6 +80,12 @@ pub struct Repl {
     /// (e.g. Ghostty), where the fallback origin would let the viewport
     /// overwrite the lines.
     pub(super) startup_banner: String,
+    /// Per-server "✓ MCP server 'X' initialized (N tools)" lines built
+    /// during [`Self::new`]. Held separately from `startup_banner` so
+    /// `main.rs` can splice them in after its own workspace/model
+    /// header before handing the combined banner back for the TUI to
+    /// replay through its capture pipe.
+    pub(super) mcp_init_lines: String,
     /// Shared tokio runtime driving every `block_on` in the REPL
     /// (initial request, compaction summary, tool-list refresh). Built
     /// once in [`Self::new`] and reused for the lifetime of the `Repl`.
@@ -105,12 +111,12 @@ impl Repl {
         let runtime = tokio::runtime::Runtime::new()
             .map_err(|e| SofosError::Config(format!("Failed to create async runtime: {}", e)))?;
 
-        let mcp_manager = runtime.block_on(async {
+        let (mcp_manager, mcp_init_lines) = runtime.block_on(async {
             match McpManager::new(workspace.clone()).await {
-                Ok(manager) => Some(manager),
+                Ok((manager, block)) => (Some(manager), block),
                 Err(e) => {
                     tracing::warn!(error = %e, "failed to initialize MCP manager");
-                    None
+                    (None, String::new())
                 }
             }
         });
@@ -192,6 +198,7 @@ impl Repl {
             interrupt_flag: Arc::new(AtomicBool::new(false)),
             steer_buffer: Arc::new(Mutex::new(Vec::new())),
             startup_banner: String::new(),
+            mcp_init_lines,
             runtime,
         })
     }
@@ -212,6 +219,13 @@ impl Repl {
         std::mem::take(&mut self.startup_banner)
     }
 
+    /// Drain the "MCP server '…' initialized" lines collected during
+    /// [`Self::new`] so the caller can splice them into the startup
+    /// banner.
+    pub(crate) fn take_mcp_init_lines(&mut self) -> String {
+        std::mem::take(&mut self.mcp_init_lines)
+    }
+
     /// Install the interrupt flag used by the TUI to signal ESC/Ctrl+C during
     /// an AI turn. Called once before the worker thread takes ownership.
     pub fn install_interrupt_flag(&mut self, flag: Arc<AtomicBool>) {