diff --git a/Cargo.lock b/Cargo.lock
index eda4f78..441e2fb 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1123,6 +1123,7 @@ dependencies = [
  "base64",
  "crossterm",
  "getrandom 0.2.17",
+ "pulldown-cmark",
  "ratatui",
  "serde",
  "serde_json",
@@ -1316,6 +1317,17 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "pulldown-cmark"
+version = "0.13.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e9f068eba8e7071c5f9511831b44f32c740d5adf574e990f946ddb53db2f314e"
+dependencies = [
+ "bitflags 2.13.0",
+ "memchr",
+ "unicase",
+]
+
 [[package]]
 name = "quote"
 version = "1.0.46"
@@ -2040,6 +2052,12 @@ version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2896d95c02a80c6d6a5d6e953d479f5ddf2dfdb6a244441010e373ac0fb88971"
 
+[[package]]
+name = "unicase"
+version = "2.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dbc4bc3a9f746d862c45cb89d705aa10f187bb96c76001afab07a0d35ce60142"
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.24"
diff --git a/Cargo.toml b/Cargo.toml
index bb1cfbc..faecd7c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -25,3 +25,4 @@ sha2 = "0.11.0"
 thiserror = "2.0.18"
 ureq = { version = "3.3.0", features = ["json", "platform-verifier"] }
 url = "2.5.8"
+pulldown-cmark = { version = "0.13.4", default-features = false }
diff --git a/src/lib.rs b/src/lib.rs
index e5186c2..85345c3 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -662,6 +662,7 @@ impl App {
 
         self.note_input.clear();
         self.notes.clear();
+        self.editor_description_scroll = 0;
         self.notes_session_id = self.notes_session_id.wrapping_add(1);
         self.note_submit_pending = None;
         self.notes_issue_iid = Some(iid);
@@ -865,7 +866,7 @@ impl App {
     pub fn scroll_editor_description(&mut self, delta: i16) {
         if !matches!(
             self.overlay,
-            Some(Overlay::Details | Overlay::EditIssue | Overlay::NewIssue)
+            Some(Overlay::Details | Overlay::EditIssue | Overlay::NewIssue | Overlay::Notes)
         ) {
             return;
         }
@@ -881,6 +882,12 @@ impl App {
     }
 
     fn editor_description_scroll_max(&self) -> usize {
+        if self.overlay == Some(Overlay::Notes) {
+            let notes_lines = self.notes.len().clamp(1, 5);
+            let input_lines = self.note_input.lines().count().max(1);
+            return (notes_lines + input_lines + 6).saturating_sub(1);
+        }
+
         // The read-only details view always renders the markdown preview.
         let preview = self.editor_preview || self.overlay == Some(Overlay::Details);
         crate::ui::markdown::description_lines(
@@ -936,7 +943,13 @@ impl App {
         if self.overlay != Some(Overlay::GenerateStories) {
             return;
         }
-        let max_scroll = self.story_source.lines().count().saturating_sub(1);
+        let max_scroll = if self.story_preview {
+            crate::ui::markdown::markdown_preview_lines(&self.story_source)
+                .len()
+                .saturating_sub(1)
+        } else {
+            self.story_source.lines().count().saturating_sub(1)
+        };
         if delta > 0 {
             self.story_source_scroll = (self.story_source_scroll + delta as usize).min(max_scroll);
         } else {
@@ -1271,6 +1284,39 @@ impl App {
         self.story_selected = self.story_selected.saturating_sub(1);
     }
 
+    pub fn scroll_palette(&mut self, delta: i16) {
+        if self.overlay != Some(Overlay::Palette) {
+            return;
+        }
+        let len = self.commands().len();
+        if len == 0 {
+            return;
+        }
+        if delta > 0 {
+            self.palette_selected = (self.palette_selected + delta as usize).min(len - 1);
+        } else {
+            self.palette_selected = self
+                .palette_selected
+                .saturating_sub(delta.unsigned_abs() as usize);
+        }
+    }
+
+    pub fn scroll_settings(&mut self, delta: i16) {
+        let Some(form) = self.settings_form.as_mut() else {
+            return;
+        };
+        if self.overlay != Some(Overlay::Settings) {
+            return;
+        }
+        for _ in 0..delta.unsigned_abs() {
+            if delta > 0 {
+                form.focus_next();
+            } else {
+                form.focus_prev();
+            }
+        }
+    }
+
     pub fn toggle_selected_story(&mut self) {
         if self.overlay != Some(Overlay::GenerateStories)
             || !matches!(
@@ -1862,12 +1908,32 @@ impl App {
                 self.scroll_editor_description(delta);
                 return;
             }
+            Some(Overlay::Notes) => {
+                self.scroll_editor_description(delta);
+                return;
+            }
             Some(Overlay::Help) => {
                 self.scroll_help(delta);
                 return;
             }
             Some(Overlay::GenerateStories) => {
-                self.scroll_story_source(delta);
+                if self.story_tab() == StoryTab::Generated {
+                    if delta > 0 {
+                        self.move_story_selection_down();
+                    } else {
+                        self.move_story_selection_up();
+                    }
+                } else {
+                    self.scroll_story_source(delta);
+                }
+                return;
+            }
+            Some(Overlay::Palette) => {
+                self.scroll_palette(delta);
+                return;
+            }
+            Some(Overlay::Settings) => {
+                self.scroll_settings(delta);
                 return;
             }
             _ => {}
diff --git a/src/main.rs b/src/main.rs
index d5aeb4d..3d2b657 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -111,6 +111,7 @@ fn run(terminal: &mut Terminal<CrosstermBackend<io::Stdout>>, app: &mut App) ->
     let mut config = load_config();
     prepare_startup(&config, app);
     let mut job_rx: Option<Receiver<JobResult>> = None;
+    let mut mouse_capture = true;
 
     loop {
         if app.config_dirty {
@@ -132,7 +133,20 @@ fn run(terminal: &mut Terminal<CrosstermBackend<io::Stdout>>, app: &mut App) ->
         }
 
         if event::poll(Duration::from_millis(40))? {
-            handle_event(event::read()?, app);
+            let event = event::read()?;
+            if mouse_capture_toggle_requested(&event) {
+                mouse_capture = !mouse_capture;
+                set_mouse_capture(terminal, mouse_capture)?;
+                report_mouse_capture(app, mouse_capture);
+                continue;
+            }
+            if mouse_capture && terminal_mouse_requested(&event) {
+                mouse_capture = false;
+                set_mouse_capture(terminal, false)?;
+                report_mouse_capture(app, false);
+                continue;
+            }
+            handle_event(event, app);
         }
         if let Some(text) = app.clipboard_request.take() {
             let _ = copy_to_clipboard(&text);
@@ -140,6 +154,50 @@ fn run(terminal: &mut Terminal<CrosstermBackend<io::Stdout>>, app: &mut App) ->
     }
 }
 
+fn set_mouse_capture(
+    terminal: &mut Terminal<CrosstermBackend<io::Stdout>>,
+    enabled: bool,
+) -> io::Result<()> {
+    if enabled {
+        execute!(terminal.backend_mut(), EnableMouseCapture)?;
+    } else {
+        execute!(terminal.backend_mut(), DisableMouseCapture)?;
+    }
+    Ok(())
+}
+
+fn mouse_capture_toggle_requested(event: &Event) -> bool {
+    matches!(
+        event,
+        Event::Key(key)
+            if (key.kind == KeyEventKind::Press || key.kind == KeyEventKind::Repeat)
+                && matches!(key.code, KeyCode::Char('m') | KeyCode::Char('M'))
+                && key.modifiers.contains(KeyModifiers::ALT)
+    )
+}
+
+fn terminal_mouse_requested(event: &Event) -> bool {
+    matches!(
+        event,
+        Event::Mouse(mouse)
+            if matches!(
+                mouse.kind,
+                MouseEventKind::Down(MouseButton::Right) | MouseEventKind::Up(MouseButton::Right)
+            )
+    )
+}
+
+fn report_mouse_capture(app: &mut App, enabled: bool) {
+    if enabled {
+        app.set_status(StatusKind::Info, "App mouse enabled");
+    } else {
+        app.set_status(
+            StatusKind::Info,
+            "Terminal select/copy/paste enabled. Alt+M restores app mouse.",
+        );
+    }
+}
+
 fn prepare_startup(config: &Result<AppConfig, ConfigError>, app: &mut App) {
     app.settings = lane_ratatui_premium::settings::load();
     match config {
@@ -827,6 +885,28 @@ mod tests {
         assert_eq!(app.hover, Some(ClickTarget::Help));
     }
 
+    #[test]
+    fn alt_m_toggles_terminal_mouse_mode() {
+        let event = Event::Key(crossterm::event::KeyEvent::new(
+            KeyCode::Char('m'),
+            KeyModifiers::ALT,
+        ));
+
+        assert!(mouse_capture_toggle_requested(&event));
+    }
+
+    #[test]
+    fn right_click_requests_terminal_mouse_mode() {
+        let event = Event::Mouse(crossterm::event::MouseEvent {
+            kind: MouseEventKind::Down(MouseButton::Right),
+            column: 5,
+            row: 5,
+            modifiers: KeyModifiers::NONE,
+        });
+
+        assert!(terminal_mouse_requested(&event));
+    }
+
     #[test]
     fn startup_requests_connect_when_config_is_valid() {
         let config = AppConfig::from_env_values(EnvConfig {
diff --git a/src/ui/help.rs b/src/ui/help.rs
index c95d940..9302077 100644
--- a/src/ui/help.rs
+++ b/src/ui/help.rs
@@ -70,7 +70,8 @@ fn help_columns() -> (Vec<Line<'static>>, Vec<Line<'static>>) {
             ("c", "Connect"),
             ("s / r", "Sync"),
             ("Ctrl+C", "Copy field"),
-            ("Drag", "Text select"),
+            ("Alt+M", "Mouse mode"),
+            ("Right click", "Terminal select/paste"),
             ("q", "Quit"),
         ],
     );
diff --git a/src/ui/markdown.rs b/src/ui/markdown.rs
index 4652c98..ab2ba02 100644
--- a/src/ui/markdown.rs
+++ b/src/ui/markdown.rs
@@ -1,11 +1,7 @@
-//! Hand-rolled markdown rendering for card/issue descriptions.
-//!
-//! Supports a small, TUI-friendly subset of markdown: headings (levels 1-3),
-//! task list items, bullets, blockquotes, ordered lists, fenced code blocks,
-//! and inline bold/code/link/italic spans. There is no external markdown
-//! dependency; everything here is a manual scanner over `&str`.
+//! Markdown rendering for card/issue descriptions.
 
 use crate::theme;
+use pulldown_cmark::{Event, HeadingLevel, Options, Parser, Tag, TagEnd};
 use ratatui::prelude::*;
 
 /// Renders a description as either raw source (edit mode) or a styled
@@ -45,250 +41,253 @@ pub fn markdown_preview_lines(markdown: &str) -> Vec<Line<'static>> {
         )])];
     }
 
-    let mut lines = Vec::new();
-    let mut in_code = false;
-    for raw_line in markdown.lines() {
-        let line = raw_line.trim_end();
-        let trimmed = line.trim_start();
+    let mut options = Options::empty();
+    options.insert(Options::ENABLE_TABLES);
+    options.insert(Options::ENABLE_STRIKETHROUGH);
+    options.insert(Options::ENABLE_TASKLISTS);
+    options.insert(Options::ENABLE_GFM);
 
-        if trimmed.starts_with("```") {
-            in_code = !in_code;
-            continue;
-        }
+    let mut renderer = MarkdownRenderer::default();
+    for event in Parser::new_ext(markdown, options) {
+        renderer.push_event(event);
+    }
+    renderer.finish()
+}
 
-        if in_code {
-            lines.push(Line::from(vec![Span::styled(
-                format!("  {line}"),
-                theme::code_style(),
-            )]));
-            continue;
-        }
+#[derive(Default)]
+struct MarkdownRenderer {
+    lines: Vec<Line<'static>>,
+    current: Vec<Span<'static>>,
+    styles: Vec<Style>,
+    lists: Vec<ListState>,
+    quote_depth: usize,
+    heading: Option<HeadingLevel>,
+    code_block: bool,
+    item_marker: Option<(usize, String)>,
+}
 
-        if trimmed.is_empty() {
-            lines.push(Line::raw(""));
-            continue;
-        }
+#[derive(Clone, Copy)]
+struct ListState {
+    next: Option<u64>,
+}
 
-        if markdown_horizontal_rule(trimmed) {
-            lines.push(Line::from(vec![Span::styled(
+impl MarkdownRenderer {
+    fn push_event(&mut self, event: Event<'_>) {
+        match event {
+            Event::Start(tag) => self.start_tag(tag),
+            Event::End(tag) => self.end_tag(tag),
+            Event::Text(text) | Event::Html(text) | Event::InlineHtml(text) => {
+                self.push_text(text.as_ref())
+            }
+            Event::Code(code) | Event::InlineMath(code) | Event::DisplayMath(code) => {
+                self.push_span(code.as_ref(), theme::code_style())
+            }
+            Event::SoftBreak | Event::HardBreak => self.flush_current(),
+            Event::Rule => self.lines.push(Line::from(Span::styled(
                 "─".repeat(24),
                 Style::default().fg(theme::BORDER),
-            )]));
-            continue;
+            ))),
+            Event::TaskListMarker(done) => self.replace_item_marker(done),
+            Event::FootnoteReference(label) => self.push_text(&format!("[^{label}]")),
         }
+    }
 
-        if let Some((level, heading)) = markdown_heading(trimmed) {
-            let style = match level {
-                1 => Style::default()
-                    .fg(theme::ACCENT)
-                    .add_modifier(Modifier::BOLD),
-                2 | 3 => Style::default()
-                    .fg(theme::TEXT)
-                    .add_modifier(Modifier::BOLD),
-                _ => Style::default()
+    fn start_tag(&mut self, tag: Tag<'_>) {
+        match tag {
+            Tag::Paragraph => self.ensure_quote_prefix(),
+            Tag::Heading { level, .. } => {
+                self.heading = Some(level);
+                self.styles.push(heading_style(level));
+            }
+            Tag::BlockQuote(_) => self.quote_depth += 1,
+            Tag::CodeBlock(_) => self.code_block = true,
+            Tag::List(start) => self.lists.push(ListState { next: start }),
+            Tag::Item => self.start_item(),
+            Tag::Table(_) => {}
+            Tag::TableHead => {}
+            Tag::TableRow => {}
+            Tag::TableCell if !self.current.is_empty() => self.current.push(Span::raw(" ")),
+            Tag::TableCell => {}
+            Tag::Emphasis => self.styles.push(
+                Style::default()
                     .fg(theme::TEXT_SECONDARY)
-                    .add_modifier(Modifier::BOLD),
-            };
-            lines.push(Line::from(vec![Span::styled(
-                heading.to_uppercase(),
-                style,
-            )]));
-            continue;
-        }
-
-        if let Some(task) = trimmed
-            .strip_prefix("- [x] ")
-            .or_else(|| trimmed.strip_prefix("- [X] "))
-        {
-            lines.push(Line::from(vec![
-                Span::styled(
-                    "☑ ",
-                    Style::default()
-                        .fg(theme::SUCCESS)
-                        .add_modifier(Modifier::BOLD),
-                ),
-                Span::styled(task.to_string(), Style::default().fg(theme::TEXT)),
-            ]));
-            continue;
+                    .add_modifier(Modifier::ITALIC),
+            ),
+            Tag::Strong => self
+                .styles
+                .push(current_style(&self.styles).add_modifier(Modifier::BOLD)),
+            Tag::Strikethrough => self
+                .styles
+                .push(current_style(&self.styles).add_modifier(Modifier::CROSSED_OUT)),
+            Tag::Link { .. } => self.styles.push(
+                Style::default()
+                    .fg(theme::ACCENT_SECONDARY)
+                    .add_modifier(Modifier::UNDERLINED),
+            ),
+            Tag::Image { .. } => self.push_text("[image]"),
+            _ => {}
         }
+    }
 
-        if let Some(task) = trimmed.strip_prefix("- [ ] ") {
-            lines.push(Line::from(vec![
-                Span::styled("☐ ", Style::default().fg(theme::TEXT_MUTED)),
-                Span::styled(task.to_string(), Style::default().fg(theme::TEXT)),
-            ]));
-            continue;
+    fn end_tag(&mut self, tag: TagEnd) {
+        match tag {
+            TagEnd::Paragraph | TagEnd::Heading(_) | TagEnd::Item | TagEnd::CodeBlock => {
+                self.flush_current()
+            }
+            TagEnd::BlockQuote(_) => {
+                self.flush_current();
+                self.quote_depth = self.quote_depth.saturating_sub(1);
+            }
+            TagEnd::List(_) => {
+                self.flush_current();
+                self.lists.pop();
+            }
+            TagEnd::TableCell => self
+                .current
+                .push(Span::styled(" │ ", Style::default().fg(theme::TEXT_MUTED))),
+            TagEnd::TableRow => {
+                if self
+                    .current
+                    .last()
+                    .is_some_and(|span| span.content.ends_with(" │ "))
+                {
+                    self.current.pop();
+                }
+                self.flush_current();
+            }
+            TagEnd::TableHead => {
+                self.lines.push(Line::from(Span::styled(
+                    "─".repeat(24),
+                    Style::default().fg(theme::BORDER),
+                )));
+            }
+            TagEnd::Emphasis | TagEnd::Strong | TagEnd::Strikethrough | TagEnd::Link => {
+                self.styles.pop();
+            }
+            _ => {}
         }
-
-        if let Some(item) = trimmed
-            .strip_prefix("- ")
-            .or_else(|| trimmed.strip_prefix("* "))
-        {
-            let mut spans = vec![Span::styled("• ", Style::default().fg(theme::ACCENT))];
-            spans.extend(markdown_inline_spans(
-                item,
-                Style::default().fg(theme::TEXT),
-            ));
-            lines.push(Line::from(spans));
-            continue;
+        if matches!(tag, TagEnd::Heading(_)) {
+            self.heading = None;
+            self.styles.pop();
         }
-
-        if let Some((number, rest)) = markdown_ordered_list_item(trimmed) {
-            let mut spans = vec![Span::styled(
-                format!("{number}. "),
-                Style::default().fg(theme::ACCENT),
-            )];
-            spans.extend(markdown_inline_spans(
-                rest,
-                Style::default().fg(theme::TEXT),
-            ));
-            lines.push(Line::from(spans));
-            continue;
+        if matches!(tag, TagEnd::CodeBlock) {
+            self.code_block = false;
         }
-
-        if let Some(quote) = trimmed.strip_prefix("> ") {
-            let mut spans = vec![Span::styled("▎ ", Style::default().fg(theme::TEXT_MUTED))];
-            spans.extend(markdown_inline_spans(
-                quote,
-                Style::default().fg(theme::TEXT_MUTED),
-            ));
-            lines.push(Line::from(spans));
-            continue;
+        if matches!(tag, TagEnd::Item) {
+            self.item_marker = None;
         }
-
-        lines.push(Line::from(markdown_inline_spans(
-            trimmed,
-            Style::default().fg(theme::TEXT),
-        )));
     }
 
-    lines
-}
+    fn push_text(&mut self, text: &str) {
+        if self.code_block {
+            for line in text.trim_end_matches('\n').split('\n') {
+                self.lines.push(Line::from(Span::styled(
+                    format!("  {line}"),
+                    theme::code_style(),
+                )));
+            }
+            return;
+        }
 
-fn markdown_heading(line: &str) -> Option<(usize, &str)> {
-    let level = line.chars().take_while(|ch| *ch == '#').count();
-    if (1..=6).contains(&level) && line.chars().nth(level) == Some(' ') {
-        Some((level, line[level + 1..].trim()))
-    } else {
-        None
+        self.ensure_quote_prefix();
+        let text = if self.heading.is_some() {
+            text.to_uppercase()
+        } else {
+            text.to_string()
+        };
+        self.push_span(&text, current_style(&self.styles));
     }
-}
-
-/// `---`, `***`, or `___` (three or more of one marker) on its own line.
-fn markdown_horizontal_rule(line: &str) -> bool {
-    line.len() >= 3
-        && (line.chars().all(|ch| ch == '-')
-            || line.chars().all(|ch| ch == '*')
-            || line.chars().all(|ch| ch == '_'))
-}
 
-/// Matches a trimmed line starting with `^\d+\. ` (digits, dot, space).
-/// Returns the digit run and the remaining text. Parsed manually since the
-/// crate has no regex dependency.
-fn markdown_ordered_list_item(line: &str) -> Option<(&str, &str)> {
-    let digit_end = line
-        .char_indices()
-        .find(|(_, ch)| !ch.is_ascii_digit())
-        .map(|(index, _)| index)?;
-    if digit_end == 0 {
-        return None;
+    fn push_span(&mut self, text: &str, style: Style) {
+        if text.is_empty() {
+            return;
+        }
+        self.current.push(Span::styled(text.to_string(), style));
     }
-    let rest = line[digit_end..].strip_prefix(". ")?;
-    Some((&line[..digit_end], rest))
-}
 
-fn markdown_inline_spans(input: &str, base_style: Style) -> Vec<Span<'static>> {
-    let mut spans = Vec::new();
-    let mut rest = input;
-
-    while !rest.is_empty() {
-        if let Some(stripped) = rest.strip_prefix("**") {
-            if let Some(end) = stripped.find("**") {
-                spans.push(Span::styled(
-                    stripped[..end].to_string(),
-                    base_style.add_modifier(Modifier::BOLD),
-                ));
-                rest = &stripped[end + 2..];
-                continue;
+    fn start_item(&mut self) {
+        self.ensure_quote_prefix();
+        let indent = "  ".repeat(self.lists.len().saturating_sub(1));
+        let marker = if let Some(list) = self.lists.last_mut() {
+            if let Some(next) = list.next.as_mut() {
+                let marker = format!("{indent}{next}. ");
+                *next += 1;
+                marker
+            } else {
+                format!("{indent}• ")
             }
-        }
+        } else {
+            "• ".to_string()
+        };
+        let index = self.current.len();
+        self.current.push(Span::styled(
+            marker.clone(),
+            Style::default().fg(theme::ACCENT),
+        ));
+        self.item_marker = Some((index, indent));
+    }
 
-        if let Some(stripped) = rest.strip_prefix('`') {
-            if let Some(end) = stripped.find('`') {
-                spans.push(Span::styled(
-                    stripped[..end].to_string(),
-                    theme::code_style(),
-                ));
-                rest = &stripped[end + 1..];
-                continue;
-            }
+    fn replace_item_marker(&mut self, done: bool) {
+        let Some((index, indent)) = self.item_marker.clone() else {
+            return;
+        };
+        let marker = if done { "☑ " } else { "☐ " };
+        let color = if done {
+            theme::SUCCESS
+        } else {
+            theme::TEXT_MUTED
+        };
+        if let Some(span) = self.current.get_mut(index) {
+            *span = Span::styled(format!("{indent}{marker}"), Style::default().fg(color));
         }
+    }
 
-        if let Some(link) = markdown_link(rest) {
-            spans.push(Span::styled(
-                link.text.to_string(),
-                Style::default()
-                    .fg(theme::ACCENT_SECONDARY)
-                    .add_modifier(Modifier::UNDERLINED),
+    fn ensure_quote_prefix(&mut self) {
+        if self.quote_depth > 0 && self.current.is_empty() {
+            self.current.push(Span::styled(
+                "▎ ".repeat(self.quote_depth),
+                Style::default().fg(theme::TEXT_MUTED),
             ));
-            rest = &rest[link.end..];
-            continue;
         }
+    }
 
-        if let Some(stripped) = rest.strip_prefix("~~") {
-            if let Some(end) = stripped.find("~~") {
-                spans.push(Span::styled(
-                    stripped[..end].to_string(),
-                    base_style.add_modifier(Modifier::CROSSED_OUT),
-                ));
-                rest = &stripped[end + 2..];
-                continue;
-            }
+    fn flush_current(&mut self) {
+        if self.current.is_empty() {
+            return;
         }
+        self.lines
+            .push(Line::from(std::mem::take(&mut self.current)));
+    }
 
-        if let Some(stripped) = rest.strip_prefix('_') {
-            if let Some(end) = stripped.find('_') {
-                spans.push(Span::styled(
-                    stripped[..end].to_string(),
-                    Style::default()
-                        .fg(theme::TEXT_SECONDARY)
-                        .add_modifier(Modifier::ITALIC),
-                ));
-                rest = &stripped[end + 1..];
-                continue;
-            }
+    fn finish(mut self) -> Vec<Line<'static>> {
+        self.flush_current();
+        if self.lines.is_empty() {
+            markdown_preview_lines("")
+        } else {
+            self.lines
         }
-
-        let next = rest
-            .char_indices()
-            .skip(1)
-            .find_map(|(index, ch)| {
-                (ch == '*' || ch == '`' || ch == '[' || ch == '_' || ch == '~').then_some(index)
-            })
-            .unwrap_or(rest.len());
-        spans.push(Span::styled(rest[..next].to_string(), base_style));
-        rest = &rest[next..];
     }
-
-    spans
 }
 
-struct MarkdownLink<'a> {
-    text: &'a str,
-    end: usize,
+fn current_style(styles: &[Style]) -> Style {
+    styles
+        .last()
+        .copied()
+        .unwrap_or_else(|| Style::default().fg(theme::TEXT))
 }
 
-fn markdown_link(input: &str) -> Option<MarkdownLink<'_>> {
-    if !input.starts_with('[') {
-        return None;
+fn heading_style(level: HeadingLevel) -> Style {
+    match level {
+        HeadingLevel::H1 => Style::default()
+            .fg(theme::ACCENT)
+            .add_modifier(Modifier::BOLD),
+        HeadingLevel::H2 | HeadingLevel::H3 => Style::default()
+            .fg(theme::TEXT)
+            .add_modifier(Modifier::BOLD),
+        _ => Style::default()
+            .fg(theme::TEXT_SECONDARY)
+            .add_modifier(Modifier::BOLD),
     }
-    let close_text = input.find("](")?;
-    let after_open_url = close_text + 2;
-    let close_url = input[after_open_url..].find(')')? + after_open_url;
-    Some(MarkdownLink {
-        text: &input[1..close_text],
-        end: close_url + 1,
-    })
 }
 
 #[cfg(test)]
@@ -300,89 +299,26 @@ mod tests {
     }
 
     #[test]
-    fn heading_uppercases_and_styles_h1_distinctly_from_h2() {
-        let h1 = markdown_preview_lines("# Heading");
-        assert_eq!(span_text(&h1[0], 0), "HEADING");
-        assert_eq!(h1[0].spans[0].style.fg, Some(theme::ACCENT));
-        assert!(h1[0].spans[0].style.add_modifier.contains(Modifier::BOLD));
-
-        let h2 = markdown_preview_lines("## Sub Heading");
-        assert_eq!(span_text(&h2[0], 0), "SUB HEADING");
-        assert_eq!(h2[0].spans[0].style.fg, Some(theme::TEXT));
-        assert!(h2[0].spans[0].style.add_modifier.contains(Modifier::BOLD));
-
-        let h3 = markdown_preview_lines("### Sub Sub");
-        assert_eq!(h3[0].spans[0].style.fg, Some(theme::TEXT));
-
-        // Level 4-6 render as secondary headings.
-        let h4 = markdown_preview_lines("#### Deep heading");
-        assert_eq!(span_text(&h4[0], 0), "DEEP HEADING");
-        assert_eq!(h4[0].spans[0].style.fg, Some(theme::TEXT_SECONDARY));
-    }
-
-    #[test]
-    fn horizontal_rule_renders_divider_line() {
-        for rule in ["---", "----", "***", "___"] {
-            let lines = markdown_preview_lines(rule);
-            assert_eq!(span_text(&lines[0], 0), "─".repeat(24), "rule: {rule}");
-            assert_eq!(lines[0].spans[0].style.fg, Some(theme::BORDER));
-        }
-    }
-
-    #[test]
-    fn strikethrough_renders_crossed_out() {
-        let spans = markdown_inline_spans("~~gone~~ kept", Style::default().fg(theme::TEXT));
-        assert_eq!(spans[0].content.to_string(), "gone");
-        assert!(spans[0].style.add_modifier.contains(Modifier::CROSSED_OUT));
-        assert_eq!(spans[1].content.to_string(), " kept");
-    }
-
-    #[test]
-    fn checked_and_unchecked_tasks_render_distinct_markers() {
-        let checked = markdown_preview_lines("- [x] Done");
-        assert_eq!(span_text(&checked[0], 0), "☑ ");
-        assert_eq!(checked[0].spans[0].style.fg, Some(theme::SUCCESS));
-        assert!(checked[0].spans[0]
-            .style
-            .add_modifier
-            .contains(Modifier::BOLD));
-        assert_eq!(span_text(&checked[0], 1), "Done");
-        assert_eq!(checked[0].spans[1].style.fg, Some(theme::TEXT));
-
-        let checked_upper = markdown_preview_lines("- [X] Done");
-        assert_eq!(span_text(&checked_upper[0], 0), "☑ ");
-
-        let unchecked = markdown_preview_lines("- [ ] Todo");
-        assert_eq!(span_text(&unchecked[0], 0), "☐ ");
-        assert_eq!(unchecked[0].spans[0].style.fg, Some(theme::TEXT_MUTED));
-        assert_eq!(span_text(&unchecked[0], 1), "Todo");
-    }
-
-    #[test]
-    fn bullets_render_marker_and_inline_item() {
-        let dash = markdown_preview_lines("- item one");
-        assert_eq!(span_text(&dash[0], 0), "• ");
-        assert_eq!(dash[0].spans[0].style.fg, Some(theme::ACCENT));
-        assert_eq!(span_text(&dash[0], 1), "item one");
-
-        let star = markdown_preview_lines("* item two");
-        assert_eq!(span_text(&star[0], 0), "• ");
-        assert_eq!(span_text(&star[0], 1), "item two");
-    }
+    fn preview_renders_common_markdown_blocks() {
+        let lines = markdown_preview_lines(
+            "# Heading\n\n- [x] Done\n- [ ] Todo\n1. First\n> quote\n\n| A | B |\n| - | - |\n| x | y |",
+        );
 
-    #[test]
-    fn blockquote_renders_muted_marker_and_muted_base_text() {
-        let lines = markdown_preview_lines("> a quote");
-        assert_eq!(span_text(&lines[0], 0), "▎ ");
-        assert_eq!(lines[0].spans[0].style.fg, Some(theme::TEXT_MUTED));
-        assert_eq!(span_text(&lines[0], 1), "a quote");
-        assert_eq!(lines[0].spans[1].style.fg, Some(theme::TEXT_MUTED));
+        assert_eq!(span_text(&lines[0], 0), "HEADING");
+        assert_eq!(lines[0].spans[0].style.fg, Some(theme::ACCENT));
+        assert_eq!(span_text(&lines[1], 0), "☑ ");
+        assert_eq!(span_text(&lines[2], 0), "☐ ");
+        assert_eq!(span_text(&lines[3], 0), "1. ");
+        assert_eq!(span_text(&lines[4], 0), "▎ ");
+        assert!(lines
+            .iter()
+            .any(|line| line.spans.iter().any(|span| span.content.contains("x"))));
     }
 
     #[test]
     fn fenced_code_block_drops_fences_and_styles_inner_lines() {
-        let markdown = "```\nlet x = 1;\nlet y = 2;\n```";
-        let lines = markdown_preview_lines(markdown);
+        let lines = markdown_preview_lines("```\nlet x = 1;\nlet y = 2;\n```");
+
         assert_eq!(lines.len(), 2);
         assert_eq!(span_text(&lines[0], 0), "  let x = 1;");
         assert_eq!(lines[0].spans[0].style, theme::code_style());
@@ -390,36 +326,30 @@ mod tests {
     }
 
     #[test]
-    fn inline_bold_code_link_and_italic_are_styled() {
-        let bold = markdown_inline_spans("**strong**", Style::default().fg(theme::TEXT));
-        assert_eq!(bold[0].content.to_string(), "strong");
-        assert!(bold[0].style.add_modifier.contains(Modifier::BOLD));
-
-        let code = markdown_inline_spans("`code`", Style::default().fg(theme::TEXT));
-        assert_eq!(code[0].content.to_string(), "code");
-        assert_eq!(code[0].style, theme::code_style());
-
-        let link = markdown_inline_spans(
-            "[label](https://example.com)",
-            Style::default().fg(theme::TEXT),
+    fn inline_styles_survive_parser() {
+        let lines = markdown_preview_lines(
+            "**strong** `code` [label](https://example.com) _soft_ ~~gone~~",
         );
-        assert_eq!(link[0].content.to_string(), "label");
-        assert_eq!(link[0].style.fg, Some(theme::ACCENT_SECONDARY));
-        assert!(link[0].style.add_modifier.contains(Modifier::UNDERLINED));
-
-        let italic = markdown_inline_spans("_soft_", Style::default().fg(theme::TEXT));
-        assert_eq!(italic[0].content.to_string(), "soft");
-        assert_eq!(italic[0].style.fg, Some(theme::TEXT_SECONDARY));
-        assert!(italic[0].style.add_modifier.contains(Modifier::ITALIC));
-    }
 
-    #[test]
-    fn ordered_list_item_splits_number_and_text() {
-        let lines = markdown_preview_lines("1. First");
-        assert_eq!(span_text(&lines[0], 0), "1. ");
-        assert_eq!(lines[0].spans[0].style.fg, Some(theme::ACCENT));
-        assert_eq!(span_text(&lines[0], 1), "First");
-        assert_eq!(lines[0].spans[1].style.fg, Some(theme::TEXT));
+        assert_eq!(span_text(&lines[0], 0), "strong");
+        assert!(lines[0].spans[0]
+            .style
+            .add_modifier
+            .contains(Modifier::BOLD));
+        assert_eq!(span_text(&lines[0], 2), "code");
+        assert_eq!(lines[0].spans[2].style, theme::code_style());
+        assert_eq!(span_text(&lines[0], 4), "label");
+        assert_eq!(lines[0].spans[4].style.fg, Some(theme::ACCENT_SECONDARY));
+        assert_eq!(span_text(&lines[0], 6), "soft");
+        assert!(lines[0].spans[6]
+            .style
+            .add_modifier
+            .contains(Modifier::ITALIC));
+        assert_eq!(span_text(&lines[0], 8), "gone");
+        assert!(lines[0].spans[8]
+            .style
+            .add_modifier
+            .contains(Modifier::CROSSED_OUT));
     }
 
     #[test]
@@ -428,9 +358,6 @@ mod tests {
         assert_eq!(lines.len(), 1);
         assert_eq!(span_text(&lines[0], 0), "No description yet");
         assert_eq!(lines[0].spans[0].style.fg, Some(theme::TEXT_MUTED));
-
-        let empty = markdown_preview_lines("");
-        assert_eq!(span_text(&empty[0], 0), "No description yet");
     }
 
     #[test]
@@ -443,15 +370,4 @@ mod tests {
         let last = inactive.last().unwrap();
         assert_eq!(last.spans.last().unwrap().content.to_string(), "  hello");
     }
-
-    #[test]
-    fn source_mode_empty_input_active_is_single_cursor_line() {
-        let active = description_lines("", true, false);
-        assert_eq!(active.len(), 1);
-        assert_eq!(active[0].spans[0].content.to_string(), "  ▌");
-
-        let inactive = description_lines("", false, false);
-        assert_eq!(inactive.len(), 1);
-        assert_eq!(inactive[0].spans[0].content.to_string(), "  ");
-    }
 }
diff --git a/src/ui/modals.rs b/src/ui/modals.rs
index e4fba66..7c6a8fb 100644
--- a/src/ui/modals.rs
+++ b/src/ui/modals.rs
@@ -446,7 +446,12 @@ pub fn render_notes_modal(frame: &mut Frame, area: Rect, app: &mut App) {
         Style::default().fg(theme::TEXT_MUTED),
     )]));
     frame.render_widget(
-        Paragraph::new(Text::from(lines)).wrap(Wrap { trim: false }),
+        Paragraph::new(Text::from(lines))
+            .wrap(Wrap { trim: false })
+            .scroll((
+                app.editor_description_scroll.min(u16::MAX as usize) as u16,
+                0,
+            )),
         chrome.body,
     );