cap bash tool at 30 lines on screen

Author: alexylon

CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to Sofos are documented in this file.
 
 ## [Unreleased]
 
+### Changed
+
+- **Bash tool output is capped at 30 lines on screen** with a `... (N more lines hidden)` footer when longer. Long file dumps from `cat`, `head`, `tail`, `nl | sed -n '1,Np'`, and verbose builds no longer flood the terminal. The model still receives the full output (subject to the existing tool-output token cap), so context and follow-up reasoning are unaffected — only the on-screen view and the saved session transcript are shortened. Note: line-counting is `\n`-based, so a single multi-megabyte line (e.g. `cat binary | base64`) is still printed in full.
+
+### Fixed
+
+- **Session resume now shows the bash command above its output again.** The replay path was extracting the command from the wrong field (the saved output text instead of the saved input JSON), so the `Executing: <command>` header silently fell through to nothing on every replayed bash entry — users saw the output of a bash call but not which command produced it. Live execution was unaffected; only the `--resume` rendering was broken.
+
 ## [0.2.8] - 2026-05-06
 
 ### Added

src/tools/tool_name.rs

@@ -132,6 +132,23 @@ impl ToolName {
                 let char_count = output.len();
                 format!("Fetched {} ({} chars)", url.bright_cyan(), char_count)
             }
+            ToolName::ExecuteBash => {
+                // Truncate the on-screen view. The full text still
+                // reaches the model via the tool_result block.
+                const MAX_DISPLAY_LINES: usize = 30;
+                let mut lines = output.lines();
+                let kept: Vec<&str> = lines.by_ref().take(MAX_DISPLAY_LINES).collect();
+                let hidden = lines.count();
+                if hidden == 0 {
+                    return output.to_string();
+                }
+                format!(
+                    "{}\n... ({} more line{} hidden)",
+                    kept.join("\n"),
+                    hidden,
+                    if hidden == 1 { "" } else { "s" }
+                )
+            }
             ToolName::SearchCode => {
                 let pattern = tool_input
                     .get("pattern")
@@ -213,4 +230,45 @@ mod tests {
     fn test_unknown_tool() {
         assert!(ToolName::from_str("unknown_tool").is_err());
     }
+
+    #[test]
+    fn execute_bash_display_caps_long_output() {
+        let input = serde_json::json!({"command": "seq 1 100"});
+        let output: String = (1..=100)
+            .map(|n| n.to_string())
+            .collect::<Vec<_>>()
+            .join("\n");
+
+        let summary = ToolName::ExecuteBash.display_summary(&input, &output);
+
+        let line_count = summary.lines().count();
+        assert_eq!(line_count, 31, "expected 30 content lines + 1 footer");
+        assert!(summary.starts_with("1\n"));
+        assert!(summary.contains("\n30\n"));
+        assert!(!summary.contains("\n31\n"));
+        assert!(summary.ends_with("... (70 more lines hidden)"));
+    }
+
+    #[test]
+    fn execute_bash_display_passes_short_output_through() {
+        let input = serde_json::json!({"command": "echo hi"});
+        let output = "STDOUT:\nhi\n";
+
+        let summary = ToolName::ExecuteBash.display_summary(&input, output);
+
+        assert_eq!(summary, output);
+    }
+
+    #[test]
+    fn execute_bash_display_singular_footer() {
+        let input = serde_json::json!({"command": "seq 1 31"});
+        let output: String = (1..=31)
+            .map(|n| n.to_string())
+            .collect::<Vec<_>>()
+            .join("\n");
+
+        let summary = ToolName::ExecuteBash.display_summary(&input, &output);
+
+        assert!(summary.ends_with("... (1 more line hidden)"));
+    }
 }

src/ui/mod.rs

@@ -310,20 +310,21 @@ impl UI {
                 }
                 DisplayMessage::ToolExecution {
                     tool_name,
-                    tool_input: _,
+                    tool_input,
                     tool_output,
                 } => {
-                    if tool_name == "execute_bash" {
-                        if let Ok(input_val) = serde_json::from_value::<serde_json::Value>(
-                            serde_json::to_value(tool_output).unwrap_or_default(),
-                        ) {
-                            if let Some(command) = input_val.get("command").and_then(|v| v.as_str())
-                            {
-                                self.print_tool_header(tool_name, Some(command));
-                            }
-                        }
+                    let command = if tool_name == "execute_bash" {
+                        tool_input.get("command").and_then(|v| v.as_str())
                     } else {
-                        self.print_tool_header(tool_name, None);
+                        None
+                    };
+                    self.print_tool_header(tool_name, command);
+                    // `print_tool_header` doesn't terminate the bash
+                    // header with a newline — the live path relies on
+                    // the post-execution `println!()` to do that. Replay
+                    // it here so the header doesn't run into the output.
+                    if tool_name == "execute_bash" && command.is_some() {
+                        println!();
                     }
                     self.print_tool_output(tool_output);
                 }