✨ Add streaming response display for TUI chat modal

Show real-time LLM output in the chat modal instead of only a thinking
indicator. The chat now displays markdown-formatted streaming content
as it arrives, with a spinner cursor at the end.

Also adds mouse scroll support for the chat modal, allowing users to
scroll through conversation history while Iris is responding.

Author: hyperb1iss

src/agents/setup.rs

@@ -372,6 +372,24 @@ impl IrisAgentService {
         agent.execute_task("chat", task_prompt).await
     }
 
+    /// Execute a chat task with streaming and content update capabilities
+    ///
+    /// Combines streaming output with tool-based content updates for the TUI chat.
+    pub async fn execute_chat_streaming<F>(
+        &self,
+        task_prompt: &str,
+        content_update_sender: crate::agents::tools::ContentUpdateSender,
+        on_chunk: F,
+    ) -> Result<StructuredResponse>
+    where
+        F: FnMut(&str, &str) + Send,
+    {
+        let mut agent = self.create_agent_with_content_updates(content_update_sender)?;
+        agent
+            .execute_task_streaming("chat", task_prompt, on_chunk)
+            .await
+    }
+
     /// Execute an agent task with streaming
     ///
     /// This method streams LLM output in real-time, calling the callback with each

src/studio/app.rs

@@ -852,9 +852,26 @@ Simply call the appropriate tool with the new content. Do NOT echo back the full
                 mode_context, content_section, history_str, update_instructions, message
             );
 
-            // Execute with content update tools enabled
-            match agent.execute_chat_with_updates(&prompt, content_tx).await {
+            // Execute with streaming and content update tools
+            let streaming_tx = tx.clone();
+            let on_chunk = move |chunk: &str, aggregated: &str| {
+                let _ = streaming_tx.send(IrisTaskResult::StreamingChunk {
+                    task_type: TaskType::Chat,
+                    chunk: chunk.to_string(),
+                    aggregated: aggregated.to_string(),
+                });
+            };
+
+            match agent
+                .execute_chat_streaming(&prompt, content_tx, on_chunk)
+                .await
+            {
                 Ok(response) => {
+                    // Signal streaming complete
+                    let _ = tx.send(IrisTaskResult::StreamingComplete {
+                        task_type: TaskType::Chat,
+                    });
+
                     let text = match response {
                         StructuredResponse::PlainText(text) => text,
                         other => other.to_string(),

src/studio/reducer.rs

@@ -1063,6 +1063,30 @@ fn reduce_mouse_event(
 ) -> Vec<SideEffect> {
     let effects = Vec::new();
 
+    // Check if chat modal is open - scroll it instead of the main view
+    if let Some(Modal::Chat(ref mut chat)) = state.modal {
+        match mouse.kind {
+            MouseEventKind::ScrollUp => {
+                chat.scroll_up(3);
+                state.mark_dirty();
+            }
+            MouseEventKind::ScrollDown => {
+                // For scroll_down we need max_scroll, but we don't have render info here.
+                // Just increment and let render clamp it.
+                chat.scroll_offset = chat.scroll_offset.saturating_add(3);
+                // Don't auto-scroll since user is manually scrolling
+                chat.auto_scroll = false;
+                state.mark_dirty();
+            }
+            MouseEventKind::Down(_) => {
+                state.mark_dirty();
+            }
+            _ => {}
+        }
+        return effects;
+    }
+
+    // Normal scroll handling for main views
     match mouse.kind {
         MouseEventKind::ScrollUp => {
             apply_scroll(state, ScrollDirection::Up, 3);

src/studio/render/chat.rs

@@ -52,26 +52,57 @@ pub fn render_messages(
         }
     }
 
-    // Show typing indicator if Iris is responding
+    // Show streaming response or typing indicator if Iris is responding
     if chat_state.is_responding {
         if !chat_state.messages.is_empty() {
             lines.push(Line::from(""));
+            lines.push(Line::from(Span::styled(
+                "─".repeat(content_width.min(40)),
+                Style::default().fg(theme::TEXT_DIM),
+            )));
+            lines.push(Line::from(""));
         }
-        let spinner =
-            theme::SPINNER_BRAILLE[last_render_ms as usize / 80 % theme::SPINNER_BRAILLE.len()];
-        lines.push(Line::from(vec![
-            Span::styled(
-                format!("{} ", spinner),
-                Style::default().fg(theme::ELECTRIC_PURPLE),
-            ),
-            Span::styled(
-                "Iris is thinking",
+
+        // Show streaming content if available
+        if let Some(ref streaming) = chat_state.streaming_response {
+            // Iris header for streaming response
+            lines.push(Line::from(Span::styled(
+                "◇ Iris",
                 Style::default()
                     .fg(theme::ELECTRIC_PURPLE)
-                    .add_modifier(Modifier::ITALIC),
-            ),
-            Span::styled("...", Style::default().fg(theme::TEXT_DIM)),
-        ]));
+                    .add_modifier(Modifier::BOLD),
+            )));
+
+            // Render the streaming content with markdown formatting
+            let content_style = Style::default().fg(theme::TEXT_SECONDARY);
+            let formatted_lines = format_markdown(streaming, content_width, content_style);
+            lines.extend(formatted_lines);
+
+            // Add streaming cursor
+            let spinner =
+                theme::SPINNER_BRAILLE[last_render_ms as usize / 80 % theme::SPINNER_BRAILLE.len()];
+            lines.push(Line::from(Span::styled(
+                format!(" {}", spinner),
+                Style::default().fg(theme::ELECTRIC_PURPLE),
+            )));
+        } else {
+            // Just show thinking indicator when no streaming content yet
+            let spinner =
+                theme::SPINNER_BRAILLE[last_render_ms as usize / 80 % theme::SPINNER_BRAILLE.len()];
+            lines.push(Line::from(vec![
+                Span::styled(
+                    format!("{} ", spinner),
+                    Style::default().fg(theme::ELECTRIC_PURPLE),
+                ),
+                Span::styled(
+                    "Iris is thinking",
+                    Style::default()
+                        .fg(theme::ELECTRIC_PURPLE)
+                        .add_modifier(Modifier::ITALIC),
+                ),
+                Span::styled("...", Style::default().fg(theme::TEXT_DIM)),
+            ]));
+        }
     }
 
     // Empty state with helpful message