feat(tui): cache rendered message lines and throttle streaming redraws to improve TUI responsiveness

- Introduce `MessageRenderContext` and `MessageCacheEntry` for caching wrapped lines per message.
- Implement `render_message_lines_cached` using cache, invalidating on updates.
- Add role/style helpers and content hashing for cache validation.
- Throttle UI redraws in the main loop during active streaming (50 ms interval) and adjust idle tick timing.
- Update drawing logic to use cached rendering and manage draw intervals.
- Remove unused `role_color` function and adjust imports accordingly.

crates/owlen-cli/src/main.rs

@@ -478,11 +478,25 @@ async fn run_app(
     mut event_rx: mpsc::UnboundedReceiver<Event>,
     session_rx: &mut mpsc::UnboundedReceiver<SessionEvent>,
 ) -> Result<()> {
+    let stream_draw_interval = tokio::time::Duration::from_millis(50);
+    let idle_tick = tokio::time::Duration::from_millis(100);
+    let mut last_draw = tokio::time::Instant::now() - stream_draw_interval;
+
     loop {
         // Advance loading animation frame
         app.advance_loading_animation();
 
-        terminal.draw(|f| ui::render_chat(f, app))?;
+        let streaming_active = app.streaming_count() > 0;
+        let draw_due = if streaming_active {
+            last_draw.elapsed() >= stream_draw_interval
+        } else {
+            true
+        };
+
+        if draw_due {
+            terminal.draw(|f| ui::render_chat(f, app))?;
+            last_draw = tokio::time::Instant::now();
+        }
 
         // Process any pending LLM requests AFTER UI has been drawn
         if let Err(e) = app.process_pending_llm_request().await {
@@ -494,6 +508,14 @@ async fn run_app(
             eprintln!("Error processing tool execution: {}", e);
         }
 
+        let sleep_duration = if streaming_active {
+            stream_draw_interval
+                .checked_sub(last_draw.elapsed())
+                .unwrap_or_else(|| tokio::time::Duration::from_millis(0))
+        } else {
+            idle_tick
+        };
+
         tokio::select! {
             Some(event) = event_rx.recv() => {
                 if let AppState::Quit = app.handle_event(event).await? {
@@ -503,10 +525,7 @@ async fn run_app(
             Some(session_event) = session_rx.recv() => {
                 app.handle_session_event(session_event)?;
             }
-            // Add a timeout to keep the animation going even when there are no events
-            _ = tokio::time::sleep(tokio::time::Duration::from_millis(100)) => {
-                // This will cause the loop to continue and advance the animation
-            }
+            _ = tokio::time::sleep(sleep_duration) => {}
         }
     }
 }