fix(cortex-tui): fix content ordering and streaming cursor display

- Add render_text_content() for finalized text segments (no cursor)
- Use render_text_content() for content_segments Text entries
- Keep render_streaming_content() with cursor only for pending_text_segment
- Remove inconsistent ordering logic that switched based on all_tools_completed
- Use consistent ordering: streaming content first, then tool calls by sequence

This fixes visual 'refreshing' issues where content would reorder when
tool calls completed or streaming state changed.

Author: factorydroid

cortex-tui/src/views/minimal_session.rs

@@ -486,29 +486,18 @@ impl<'a> MinimalSessionView<'a> {
 
         let mut all_lines: Vec<Line<'static>> = Vec::new();
 
-        // Determine if we need to insert tool calls before the last assistant message
+        // Determine what content we have for display
         let has_tool_calls = !self.app_state.tool_calls.is_empty();
+        let has_content_segments = !self.app_state.content_segments.is_empty();
         let last_is_assistant = self
             .app_state
             .messages
             .last()
             .map(|m| m.role == cortex_core::widgets::MessageRole::Assistant)
             .unwrap_or(false);
 
-        // Determine if all tool calls are completed (have results)
-        // This indicates we're in a continuation phase (2nd turn after tool execution)
-        let all_tools_completed = has_tool_calls
-            && self
-                .app_state
-                .tool_calls
-                .iter()
-                .all(|c| c.status == ToolStatus::Completed || c.status == ToolStatus::Failed);
-
-        // Render messages (except the last assistant message if we have content segments)
-        // Content segments will replace the last assistant message rendering when present
-        let has_content_segments = !self.app_state.content_segments.is_empty();
-
         // If we have content segments, skip the last assistant message (it's in the segments)
+        // Content segments replace the last assistant message rendering when present
         let messages_to_render = if has_content_segments && last_is_assistant {
             // Skip the last message if it's an assistant message and we have segments
             let len = self.app_state.messages.len();
@@ -532,12 +521,14 @@ impl<'a> MinimalSessionView<'a> {
             None
         };
 
-        // Check if tool is currently executing (for real-time display)
-        let is_tool_executing = self.app_state.streaming.is_tool_executing();
-
         // Render interleaved content using segments timeline
         // This properly interleaves text and tool calls in arrival order
         // IMPORTANT: Use content_segments even during streaming to preserve correct order
+        //
+        // The ordering logic is simple:
+        // 1. If we have content_segments, use them (sorted by sequence) - this ensures correct order
+        // 2. Only the pending_text_segment (not yet committed) gets the streaming cursor
+        // 3. Finalized text segments use render_text_content (no cursor)
         if has_content_segments {
             // Sort segments by sequence to ensure correct order
             let mut sorted_segments: Vec<_> = self.app_state.content_segments.iter().collect();
@@ -546,8 +537,8 @@ impl<'a> MinimalSessionView<'a> {
             for segment in sorted_segments {
                 match segment {
                     ContentSegment::Text { content, .. } => {
-                        // Render text segment as streaming content
-                        all_lines.extend(self.render_streaming_content(content, area.width));
+                        // Render finalized text segment (no cursor)
+                        all_lines.extend(self.render_text_content(content, area.width));
                     }
                     ContentSegment::ToolCall { tool_call_id, .. } => {
                         // Find and render the corresponding tool call
@@ -564,40 +555,34 @@ impl<'a> MinimalSessionView<'a> {
             }
 
             // If still streaming, also render the pending text that hasn't been segmented yet
-            // This is the text that arrived after the last tool call
+            // This is the text that arrived after the last tool call - show with cursor
             if self.app_state.streaming.is_streaming {
                 let pending_text = &self.app_state.pending_text_segment;
                 if !pending_text.is_empty() {
                     all_lines.extend(self.render_streaming_content(pending_text, area.width));
                 }
             }
         } else if has_tool_calls {
-            // No content segments yet but have tool calls - means we're in the middle of first response
-            // ALWAYS render tool calls when they exist (for real-time display)
+            // No content segments but have tool calls
+            // This is a fallback case that shouldn't normally happen since add_tool_call()
+            // always creates content segments. But handle it gracefully.
+            //
+            // Use consistent ordering: always sort tool calls by sequence (arrival order)
+            // and render them after any streaming content
             let mut sorted_calls: Vec<_> = self.app_state.tool_calls.iter().collect();
             sorted_calls.sort_by_key(|c| c.sequence);
 
-            if all_tools_completed {
-                // 2nd turn: tools first (sorted by arrival), then streaming response
-                for call in &sorted_calls {
-                    all_lines.extend(self.render_tool_call(call));
-                }
-                // Then streaming (the response after tool execution)
-                if let Some(ref content) = streaming_content {
-                    all_lines.extend(self.render_streaming_content(content, area.width));
-                }
-            } else {
-                // 1st turn or during execution: streaming first, then tools
-                if let Some(ref content) = streaming_content {
-                    all_lines.extend(self.render_streaming_content(content, area.width));
-                }
-                // Always show tool calls (including those being executed)
-                for call in &sorted_calls {
-                    all_lines.extend(self.render_tool_call(call));
-                }
+            // Render any streaming content first (with cursor)
+            if let Some(ref content) = streaming_content {
+                all_lines.extend(self.render_streaming_content(content, area.width));
+            }
+
+            // Then render tool calls in arrival order
+            for call in &sorted_calls {
+                all_lines.extend(self.render_tool_call(call));
             }
         } else if let Some(ref content) = streaming_content {
-            // No tool calls - just render streaming
+            // No tool calls - just render streaming content with cursor
             all_lines.extend(self.render_streaming_content(content, area.width));
         }
 
@@ -851,7 +836,21 @@ impl<'a> MinimalSessionView<'a> {
             .render(area, buf, &mut scrollbar_state);
     }
 
+    /// Renders finalized text content (without streaming cursor).
+    /// Used for text segments that are already committed in content_segments.
+    fn render_text_content(&self, content: &str, width: u16) -> Vec<Line<'static>> {
+        use cortex_core::markdown::MarkdownRenderer;
+
+        let content_width = width.saturating_sub(4) as u16;
+        let renderer = MarkdownRenderer::new().with_width(content_width);
+        let rendered_lines = renderer.render(content);
+
+        // No cursor for finalized content
+        rendered_lines
+    }
+
     /// Renders streaming content with cursor.
+    /// Used only for actively streaming content (pending_text_segment).
     fn render_streaming_content(&self, content: &str, width: u16) -> Vec<Line<'static>> {
         use cortex_core::markdown::MarkdownRenderer;