fix(read-text): align read limits, guidance, and output previews

crates/merry-cli/src/tui/process_output.rs

@@ -1,4 +1,4 @@
-use crate::tui::state::ProcessOutputPreview;
+use crate::tui::state::ToolOutputPreview;
 use merry_runtime::ArtifactContent;
 use serde::Deserialize;
 use serde_json::Value;
@@ -68,7 +68,7 @@ impl CapturedOutput {
     }
 }
 
-pub(crate) fn process_output_preview(output: &str) -> Option<ProcessOutputPreview> {
+pub(crate) fn process_output_preview(output: &str) -> Option<ToolOutputPreview> {
     let value = serde_json::from_str::<Value>(output).ok()?;
     if value.get("kind").and_then(Value::as_str) != Some("process_action") {
         return None;
@@ -83,7 +83,10 @@ pub(crate) fn process_output_preview(output: &str) -> Option<ProcessOutputPrevie
         .unwrap_or_default();
     let truncated = value.pointer("/stdout/truncated").and_then(Value::as_bool) == Some(true)
         || value.pointer("/stderr/truncated").and_then(Value::as_bool) == Some(true);
-    Some(ProcessOutputPreview::new(stdout, stderr, truncated))
+    Some(ToolOutputPreview::new(
+        stdout.lines().chain(stderr.lines()),
+        truncated,
+    ))
 }
 
 pub(crate) fn process_exit_code(output: &str) -> Option<i64> {

crates/merry-cli/src/tui/projector.rs

@@ -4,17 +4,17 @@ use crate::tui::{
     process_output::process_exit_code,
     projector::tool_output::{
         compact_tool_output, completed_process_view, completed_tool_title, expanded_tool_title,
-        failed_tool_body, parse_apply_patch_view, started_tool_title_and_detail,
-        success_tool_bodies, tool_output_text,
+        failed_tool_body, parse_apply_patch_view, permission_output_bodies,
+        read_text_output_preview, started_tool_title_and_detail, tool_output_text,
     },
-    state::{CommandView, QueuePreview, TimelineItem, TuiState},
+    state::{CommandView, QueuePreview, TimelineItem, ToolOutputPreview, TuiState},
 };
 use merry_core::{
     PlanAttemptOutcome, PlanDirectiveStatus, PlanPhase, RuntimeEvent, TOOL_CANCELLED_BY_USER_CODE,
     ToolCallId, ToolCallResultStatus, ToolName,
 };
 use merry_runtime::SessionTranscriptItem;
-use merry_tools::APPLY_PATCH_TOOL;
+use merry_tools::{APPLY_PATCH_TOOL, READ_TEXT_TOOL};
 use serde_json::Value;
 use std::collections::HashMap;
 use tokio::time::Instant;
@@ -209,7 +209,19 @@ impl TuiProjector {
                         state.push_timeline_item(patch_item);
                     }
                 } else if let Some(tool) = tool.as_ref()
-                    && let Some(preview) = success_tool_bodies(tool.name.as_str(), &text)
+                    && tool.name.as_str() == READ_TEXT_TOOL
+                {
+                    state.replace_timeline_item(
+                        tool.timeline_index,
+                        TimelineItem::Read {
+                            title: expanded_tool_title(tool),
+                            preview: read_text_output_preview(&text)
+                                .unwrap_or_else(|| ToolOutputPreview::new(text.lines(), false)),
+                        },
+                    );
+                } else if let Some(tool) = tool.as_ref()
+                    && tool.name.as_str() == "request_permissions"
+                    && let Some(preview) = permission_output_bodies(&text)
                 {
                     state.replace_timeline_item(
                         tool.timeline_index,

crates/merry-cli/src/tui/projector/tool_output.rs

@@ -8,9 +8,8 @@ use crate::{
         projector::StartedToolView,
         state::{
             CommandFailure, CommandView, PatchChangeView, PatchLineKind, PatchLineView,
-            PatchOperationView, ProcessOutputPreview, TimelineItem,
+            PatchOperationView, TimelineItem, ToolOutputPreview,
         },
-        text_wrap::truncate_chars,
         tool_error::compact_failed_tool_body,
     },
 };
@@ -23,11 +22,6 @@ use serde::Deserialize;
 use serde_json::Value;
 use std::collections::HashMap;
 
-// This bounds the timeline preview only; the workspace tool and Focus retain the full file.
-pub(super) const READ_FILE_PREVIEW_MAX_LINES: usize = 120;
-
-pub(super) const READ_FILE_PREVIEW_MAX_CHARS: usize = 180;
-
 pub(super) fn expanded_tool_title(tool: &StartedToolView) -> String {
     if tool.detail.is_empty() {
         return tool.title.clone();
@@ -111,14 +105,6 @@ pub(super) fn parse_mcp_tool_name(name: &str) -> Option<(&str, &str)> {
     Some((server, tool))
 }
 
-pub(super) fn success_tool_bodies(name: &str, output: &str) -> Option<String> {
-    match name {
-        "request_permissions" => permission_output_bodies(output),
-        "read_text" => read_text_output_bodies(output),
-        _ => None,
-    }
-}
-
 pub(super) fn permission_output_bodies(output: &str) -> Option<String> {
     let value = serde_json::from_str::<Value>(output).ok()?;
     if value.get("ok").and_then(Value::as_bool) != Some(true)
@@ -138,25 +124,22 @@ pub(super) fn permission_output_bodies(output: &str) -> Option<String> {
     Some(body)
 }
 
-pub(super) fn read_text_output_bodies(output: &str) -> Option<String> {
+pub(super) fn read_text_output_preview(output: &str) -> Option<ToolOutputPreview> {
     let output = serde_json::from_str::<WorkspaceReadTextOutput>(output).ok()?;
     if !output.ok || output.tool.as_deref() != Some("read_text") {
         return None;
     }
 
-    let mut lines = output
-        .content
-        .lines()
-        .take(READ_FILE_PREVIEW_MAX_LINES)
-        .map(|line| truncate_chars(line, READ_FILE_PREVIEW_MAX_CHARS))
-        .collect::<Vec<_>>();
-    if output.truncated {
-        lines.push("... truncated".to_owned());
-    }
-    if lines.is_empty() {
-        lines.push(format!("{} is empty", output.path));
+    if output.content.is_empty() {
+        return Some(ToolOutputPreview::new(
+            std::iter::once(format!("{} is empty", output.path).as_str()),
+            output.truncated,
+        ));
     }
-    Some(lines.join("\n"))
+    Some(ToolOutputPreview::new(
+        output.content.lines(),
+        output.truncated,
+    ))
 }
 
 #[derive(Debug, Deserialize)]
@@ -188,11 +171,10 @@ pub(super) fn completed_process_view(
         None
     };
     let mut preview = process_output_preview(output)
-        .unwrap_or_else(|| ProcessOutputPreview::new(&compact_tool_output(output), "", false));
+        .unwrap_or_else(|| ToolOutputPreview::new(compact_tool_output(output).lines(), false));
     if failure == Some(CommandFailure::Failed) {
-        preview = ProcessOutputPreview::new(
-            &failed_tool_body(result.diagnostic(), output),
-            "",
+        preview = ToolOutputPreview::new(
+            failed_tool_body(result.diagnostic(), output).lines(),
             preview.truncated,
         );
     }

crates/merry-cli/src/tui/render/timeline.rs

@@ -6,7 +6,8 @@ use crate::tui::{
     markdown::{RenderedMarkdown, markdown_lines},
     render::command_style::command_spans,
     state::{
-        CommandFailure, CommandView, PatchChangeView, PatchOperationView, TimelineItem, TuiState,
+        CommandFailure, CommandView, PatchChangeView, PatchOperationView, TimelineItem,
+        ToolOutputPreview, TuiState,
     },
     text_interaction::TextSelection,
     text_wrap::{
@@ -31,9 +32,6 @@ use super::timeline_layout::{
     TimelineLayout, timeline_layout, timeline_scroll_start, timeline_viewport,
 };
 
-// Keep prefix eviction below the viewport start when Paragraph scroll exceeds u16.
-pub(super) const TOOL_RESULT_PREVIEW_MAX_LINES: usize = 5;
-
 pub(super) fn render_timeline_pane(frame: &mut Frame<'_>, state: &TuiState, region: Rect) {
     let mut block = Block::default()
         .borders(Borders::BOTTOM)
@@ -345,12 +343,38 @@ pub(super) fn expanded_timeline_lines(
         return lines;
     }
 
+    lines.extend(output_preview_lines(
+        state,
+        &ToolOutputPreview::new(body.lines(), false),
+        true,
+        region_width,
+    ));
+    lines
+}
+
+pub(super) fn read_output_lines(
+    state: &TuiState,
+    title: &str,
+    preview: &ToolOutputPreview,
+    region_width: u16,
+) -> Vec<Line<'static>> {
+    let mut lines = vec![expanded_title_line(state, title)];
+    lines.extend(output_preview_lines(state, preview, false, region_width));
+    lines
+}
+
+fn output_preview_lines(
+    state: &TuiState,
+    preview: &ToolOutputPreview,
+    always_show: bool,
+    region_width: u16,
+) -> Vec<Line<'static>> {
+    let mut lines = Vec::new();
+    if !always_show && !state.show_successful_command_output() {
+        return lines;
+    }
     let body_width = usize::from(region_width).saturating_sub(2).max(4);
-    for line in body
-        .lines()
-        .filter(|line| !line.trim().is_empty())
-        .take(TOOL_RESULT_PREVIEW_MAX_LINES)
-    {
+    for line in &preview.lines {
         let clean = crate::text::without_control_chars(line);
         let clean = clean.trim();
         if clean.is_empty() {
@@ -361,6 +385,12 @@ pub(super) fn expanded_timeline_lines(
             semantic_style(state, SemanticColor::Muted),
         )));
     }
+    if preview.truncated {
+        lines.push(Line::from(Span::styled(
+            "  ...",
+            semantic_style(state, SemanticColor::Muted),
+        )));
+    }
     lines
 }
 
@@ -414,21 +444,8 @@ pub(super) fn command_lines(
             }
             append_command_elapsed(state, &mut title, *elapsed);
             let mut lines = wrap_command_title(title, region_width);
-            if failed || (failure.is_none() && state.show_successful_command_output()) {
-                let body_width = usize::from(region_width).saturating_sub(2).max(4);
-                for line in &preview.lines {
-                    let clean = crate::text::without_control_chars(line);
-                    lines.push(Line::from(Span::styled(
-                        format!("  {}", truncate_chars(clean.trim(), body_width)),
-                        semantic_style(state, SemanticColor::Muted),
-                    )));
-                }
-                if preview.truncated {
-                    lines.push(Line::from(Span::styled(
-                        "  ...",
-                        semantic_style(state, SemanticColor::Muted),
-                    )));
-                }
+            if failed || failure.is_none() {
+                lines.extend(output_preview_lines(state, preview, failed, region_width));
             }
             lines
         }

crates/merry-cli/src/tui/render/timeline_layout.rs

@@ -2,7 +2,7 @@
 
 use super::timeline::{
     assistant_lines, command_lines, compact_patch_lines, diagnostic_lines, expanded_timeline_lines,
-    local_command_lines, muted_lines, user_lines,
+    local_command_lines, muted_lines, read_output_lines, user_lines,
 };
 use crate::tui::{
     copy_controls::CopyTarget,
@@ -67,6 +67,12 @@ pub(super) fn timeline_layout(state: &TuiState, region: Rect) -> TimelineLayout
                 .into_iter()
                 .map(|line| TranscriptRow::new(line, SelectionPolicy::Keep))
                 .collect(),
+            TimelineItem::Read { title, preview } => {
+                read_output_lines(state, title, preview, region.width)
+                    .into_iter()
+                    .map(|line| TranscriptRow::new(line, SelectionPolicy::Keep))
+                    .collect()
+            }
             TimelineItem::LocalCommand { title, body } => {
                 let rendered = local_command_lines(state, title, body, region.width);
                 item_targets = rendered.copy_targets;

crates/merry-cli/src/tui/state.rs

@@ -19,7 +19,7 @@ use std::{
 pub(crate) use timeline::TimelineAnchor;
 pub(crate) use views::{
     CommandFailure, CommandView, PatchChangeView, PatchLineKind, PatchLineView, PatchOperationView,
-    ProcessOutputPreview, QueuePreview, QueuePreviewItem, QueuePreviewState, TimelineItem,
+    QueuePreview, QueuePreviewItem, QueuePreviewState, TimelineItem, ToolOutputPreview,
 };
 
 mod overlays;
@@ -132,7 +132,7 @@ impl TuiState {
         self
     }
 
-    /// Whether completed successful commands show their bounded output preview.
+    /// Whether successful process commands and file reads show their bounded output preview.
     pub(crate) fn show_successful_command_output(&self) -> bool {
         self.show_successful_command_output
     }