feat(tui): UX improvements and v0.9.1 release (#165)

* feat(tui): add mouse scroll support for chat widget

* feat(tui): add ASCII art splash screen on startup

* feat(tui): add colored splash screen with block-letter banner

* feat(tui): load conversation history into chat on startup

* feat(tui): render model thinking blocks in darker color

Parse <think>...</think> tags in assistant messages and display
thinking content with DarkGray style to visually distinguish
intermediate reasoning from the final result.

* fix(tui): fix scroll overflow and add scrollbar to chat widget

Pre-wrap lines manually instead of relying on Paragraph::Wrap to
ensure lines.len() matches visual line count. Clamp scroll_offset
to max_scroll on every draw frame to prevent sticky scroll at top.
Add scrollbar track with thumb indicator.

* feat(tui): render chat messages with pulldown-cmark markdown

Replace hand-rolled inline parser with pulldown-cmark AST walker.
Supports bold, italic, strikethrough, inline code, fenced code blocks
with language tags, headings, bullet/numbered lists, blockquotes, and
horizontal rules. Thinking blocks (<think>) processed separately
before markdown pass to preserve style segmentation.

* release: prepare v0.9.1

* style(tui): fix rustfmt formatting in chat widget

* fix: resolve clippy warnings in tests

* fix(tui): resolve clippy warnings in chat widget

Author: bug-ops

CHANGELOG.md

@@ -6,6 +6,20 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.9.1] - 2026-02-12
+
+### Added
+- Mouse scroll support for TUI chat widget (scroll up/down via mouse wheel)
+- Splash screen with colored block-letter "ZEPH" banner on TUI startup
+- Conversation history loading into chat on TUI startup
+- Model thinking block rendering (`<think>` tags from Ollama DeepSeek/Qwen models) in distinct darker style
+- Markdown rendering for all chat messages via `pulldown-cmark`: bold, italic, strikethrough, headings, code blocks, inline code, lists, blockquotes, horizontal rules
+- Scrollbar track with proportional thumb indicator in chat widget
+
+### Fixed
+- Chat messages no longer overflow below the viewport when lines wrap
+- Scroll no longer sticks at top after over-scrolling past content boundary
+
 ## [0.9.0] - 2026-02-12
 
 ### Added

Cargo.lock

@@ -5,7 +5,7 @@ resolver = "3"
 [workspace.package]
 edition = "2024"
 rust-version = "1.88"
-version = "0.9.0"
+version = "0.9.1"
 authors = ["bug-ops"]
 license = "MIT"
 repository = "https://github.com/bug-ops/zeph"

Cargo.toml

@@ -93,7 +93,7 @@ cargo build --release --features tui
 | **A2A Protocol** | Agent-to-agent communication via JSON-RPC 2.0 with SSE streaming | [A2A](https://bug-ops.github.io/zeph/guide/a2a.html) |
 | **Model Orchestrator** | Route tasks to different providers with fallback chains | [Orchestrator](https://bug-ops.github.io/zeph/guide/orchestrator.html) |
 | **Self-Learning** | Skills evolve via failure detection and LLM-generated improvements | [Self-Learning](https://bug-ops.github.io/zeph/guide/self-learning.html) |
-| **TUI Dashboard** | ratatui terminal UI with live metrics, confirmation dialogs, responsive layout, multiline input | [TUI](https://bug-ops.github.io/zeph/guide/tui.html) |
+| **TUI Dashboard** | ratatui terminal UI with markdown rendering, scrollbar, mouse scroll, thinking blocks, conversation history, splash screen, live metrics | [TUI](https://bug-ops.github.io/zeph/guide/tui.html) |
 | **Multi-Channel I/O** | CLI, Telegram, and TUI with streaming support | [Channels](https://bug-ops.github.io/zeph/guide/channels.html) |
 | **Defense-in-Depth** | Shell sandbox, command filter, secret redaction, audit log, SSRF protection | [Security](https://bug-ops.github.io/zeph/security.html) |
 

README.md

@@ -223,6 +223,11 @@ impl<P: LlmProvider + Clone + 'static, C: Channel, T: ToolExecutor> Agent<P, C,
         }
     }
 
+    #[must_use]
+    pub fn context_messages(&self) -> &[Message] {
+        &self.messages
+    }
+
     /// Load conversation history from memory and inject into messages.
     ///
     /// # Errors

crates/zeph-core/src/agent.rs

@@ -9,6 +9,7 @@ repository.workspace = true
 [dependencies]
 anyhow.workspace = true
 crossterm.workspace = true
+pulldown-cmark.workspace = true
 ratatui.workspace = true
 tokio = { workspace = true, features = ["sync", "rt", "time"] }
 tracing.workspace = true

crates/zeph-tui/Cargo.toml

@@ -45,6 +45,7 @@ pub struct App {
     cursor_position: usize,
     input_mode: InputMode,
     messages: Vec<ChatMessage>,
+    show_splash: bool,
     scroll_offset: usize,
     pub metrics: MetricsSnapshot,
     metrics_rx: Option<watch::Receiver<MetricsSnapshot>>,
@@ -66,6 +67,7 @@ impl App {
             cursor_position: 0,
             input_mode: InputMode::Insert,
             messages: Vec::new(),
+            show_splash: true,
             scroll_offset: 0,
             metrics: MetricsSnapshot::default(),
             metrics_rx: None,
@@ -77,6 +79,29 @@ impl App {
         }
     }
 
+    #[must_use]
+    pub fn show_splash(&self) -> bool {
+        self.show_splash
+    }
+
+    pub fn load_history(&mut self, messages: &[(&str, &str)]) {
+        for &(role_str, content) in messages {
+            let role = match role_str {
+                "user" => MessageRole::User,
+                "assistant" => MessageRole::Assistant,
+                _ => continue,
+            };
+            self.messages.push(ChatMessage {
+                role,
+                content: content.to_owned(),
+                streaming: false,
+            });
+        }
+        if !self.messages.is_empty() {
+            self.show_splash = false;
+        }
+    }
+
     #[must_use]
     pub fn with_metrics_rx(mut self, rx: watch::Receiver<MetricsSnapshot>) -> Self {
         self.metrics_rx = Some(rx);
@@ -123,6 +148,15 @@ impl App {
         match event {
             AppEvent::Key(key) => self.handle_key(key),
             AppEvent::Tick | AppEvent::Resize(_, _) => {}
+            AppEvent::MouseScroll(delta) => {
+                if self.confirm_state.is_none() {
+                    if delta > 0 {
+                        self.scroll_offset = self.scroll_offset.saturating_add(1);
+                    } else {
+                        self.scroll_offset = self.scroll_offset.saturating_sub(1);
+                    }
+                }
+            }
             AppEvent::Agent(agent_event) => self.handle_agent_event(agent_event),
         }
         Ok(())
@@ -182,11 +216,16 @@ impl App {
         self.confirm_state.as_ref()
     }
 
-    pub fn draw(&self, frame: &mut ratatui::Frame) {
+    pub fn draw(&mut self, frame: &mut ratatui::Frame) {
         let layout = AppLayout::compute(frame.area());
 
         self.draw_header(frame, layout.header);
-        widgets::chat::render(self, frame, layout.chat);
+        if self.show_splash {
+            widgets::splash::render(frame, layout.chat);
+        } else {
+            let max_scroll = widgets::chat::render(self, frame, layout.chat);
+            self.scroll_offset = self.scroll_offset.min(max_scroll);
+        }
         self.draw_side_panel(frame, &layout);
         widgets::input::render(self, frame, layout.input);
         widgets::status::render(self, &self.metrics, frame, layout.status);
@@ -356,6 +395,7 @@ impl App {
         if text.is_empty() {
             return;
         }
+        self.show_splash = false;
         self.messages.push(ChatMessage {
             role: MessageRole::User,
             content: text.clone(),
@@ -377,7 +417,8 @@ mod tests {
     fn make_app() -> (App, mpsc::Receiver<String>, mpsc::Sender<AgentEvent>) {
         let (user_tx, user_rx) = mpsc::channel(16);
         let (agent_tx, agent_rx) = mpsc::channel(16);
-        let app = App::new(user_tx, agent_rx);
+        let mut app = App::new(user_tx, agent_rx);
+        app.messages.clear();
         (app, user_rx, agent_tx)
     }
 
@@ -387,6 +428,7 @@ mod tests {
         assert!(app.input().is_empty());
         assert_eq!(app.input_mode(), InputMode::Insert);
         assert!(app.messages().is_empty());
+        assert!(app.show_splash());
         assert!(!app.should_quit);
     }
 
@@ -732,4 +774,49 @@ mod tests {
         assert_eq!(app.input(), "a\nb");
         assert_eq!(app.cursor_position(), 2);
     }
+
+    #[test]
+    fn mouse_scroll_up() {
+        let (mut app, _rx, _tx) = make_app();
+        assert_eq!(app.scroll_offset(), 0);
+        app.handle_event(AppEvent::MouseScroll(1)).unwrap();
+        assert_eq!(app.scroll_offset(), 1);
+        app.handle_event(AppEvent::MouseScroll(1)).unwrap();
+        assert_eq!(app.scroll_offset(), 2);
+    }
+
+    #[test]
+    fn mouse_scroll_down() {
+        let (mut app, _rx, _tx) = make_app();
+        app.scroll_offset = 5;
+        app.handle_event(AppEvent::MouseScroll(-1)).unwrap();
+        assert_eq!(app.scroll_offset(), 4);
+        app.handle_event(AppEvent::MouseScroll(-1)).unwrap();
+        assert_eq!(app.scroll_offset(), 3);
+    }
+
+    #[test]
+    fn mouse_scroll_down_saturates_at_zero() {
+        let (mut app, _rx, _tx) = make_app();
+        app.scroll_offset = 1;
+        app.handle_event(AppEvent::MouseScroll(-1)).unwrap();
+        assert_eq!(app.scroll_offset(), 0);
+        app.handle_event(AppEvent::MouseScroll(-1)).unwrap();
+        assert_eq!(app.scroll_offset(), 0);
+    }
+
+    #[test]
+    fn mouse_scroll_during_confirm_blocked() {
+        let (mut app, _rx, _tx) = make_app();
+        let (tx, _oneshot_rx) = tokio::sync::oneshot::channel();
+        app.confirm_state = Some(ConfirmState {
+            prompt: "test?".into(),
+            response_tx: Some(tx),
+        });
+        app.scroll_offset = 5;
+        app.handle_event(AppEvent::MouseScroll(1)).unwrap();
+        assert_eq!(app.scroll_offset(), 5);
+        app.handle_event(AppEvent::MouseScroll(-1)).unwrap();
+        assert_eq!(app.scroll_offset(), 5);
+    }
 }

crates/zeph-tui/src/app.rs

@@ -1,13 +1,14 @@
 use std::time::Duration;
 
-use crossterm::event::{self, Event as CrosstermEvent, KeyEvent};
+use crossterm::event::{self, Event as CrosstermEvent, KeyEvent, MouseEventKind};
 use tokio::sync::{mpsc, oneshot};
 
 #[derive(Debug)]
 pub enum AppEvent {
     Key(KeyEvent),
     Tick,
     Resize(u16, u16),
+    MouseScroll(i8),
     Agent(AgentEvent),
 }
 
@@ -41,6 +42,11 @@ impl EventReader {
                 let evt = match event::read() {
                     Ok(CrosstermEvent::Key(key)) => AppEvent::Key(key),
                     Ok(CrosstermEvent::Resize(w, h)) => AppEvent::Resize(w, h),
+                    Ok(CrosstermEvent::Mouse(mouse)) => match mouse.kind {
+                        MouseEventKind::ScrollUp => AppEvent::MouseScroll(1),
+                        MouseEventKind::ScrollDown => AppEvent::MouseScroll(-1),
+                        _ => continue,
+                    },
                     _ => continue,
                 };
                 if self.tx.blocking_send(evt).is_err() {
@@ -91,4 +97,13 @@ mod tests {
         assert!(s.contains("ConfirmRequest"));
         assert!(s.contains("delete?"));
     }
+
+    #[test]
+    fn app_event_mouse_scroll_variant() {
+        let scroll_up = AppEvent::MouseScroll(1);
+        assert!(matches!(scroll_up, AppEvent::MouseScroll(1)));
+
+        let scroll_down = AppEvent::MouseScroll(-1);
+        assert!(matches!(scroll_down, AppEvent::MouseScroll(-1)));
+    }
 }

crates/zeph-tui/src/event.rs

@@ -11,6 +11,9 @@ pub struct Theme {
     pub panel_title: Style,
     pub highlight: Style,
     pub error: Style,
+    pub thinking_message: Style,
+    pub code_inline: Style,
+    pub code_block: Style,
     pub streaming_cursor: Style,
 }
 
@@ -31,6 +34,9 @@ impl Default for Theme {
                 .add_modifier(Modifier::BOLD),
             highlight: Style::default().fg(Color::Green),
             error: Style::default().fg(Color::Red),
+            thinking_message: Style::default().fg(Color::DarkGray),
+            code_inline: Style::default().fg(Color::Yellow),
+            code_block: Style::default().fg(Color::Green),
             streaming_cursor: Style::default()
                 .fg(Color::Yellow)
                 .add_modifier(Modifier::SLOW_BLINK),