diff --git a/src/commands/browse/help.rs b/src/commands/browse/help.rs
index d2d9a107..ebf5cbbe 100644
--- a/src/commands/browse/help.rs
+++ b/src/commands/browse/help.rs
@@ -9,8 +9,9 @@ use crate::tui::content::view::ContentViewMode;
 use crate::tui::terminal::suspend;
 use crate::tui::workspace::{
     can_open_dialogue_vim, selected_index, workspace_content_io_texts, workspace_content_text,
-    workspace_layout, ContentIoFocus, ContentIoFrame, ContentScrolls, WorkspaceDialogue,
-    WorkspaceFocus, WorkspaceHelpAction, WorkspacePickedContent, WorkspaceSession, WorkspaceSource,
+    workspace_layout, ContentIoFocus, ContentIoFrame, ContentScrolls, ExpandedBlocks,
+    WorkspaceDialogue, WorkspaceFocus, WorkspaceHelpAction, WorkspacePickedContent,
+    WorkspaceSession, WorkspaceSource,
 };
 use sivtr_core::record::WorkAt;
 
@@ -51,6 +52,7 @@ pub(super) fn apply_workspace_help_action(
     content_scrolls: &mut ContentScrolls,
     content_io_focus: &mut ContentIoFocus,
     content_mode: &mut ContentViewMode,
+    expanded: &ExpandedBlocks,
     content_input_lines: usize,
     content_output_lines: usize,
     show_help: &mut bool,
@@ -252,6 +254,7 @@ pub(super) fn apply_workspace_help_action(
                 dialogue_idx,
                 *content_mode,
                 content_at,
+                expanded,
             );
             let frame = ContentIoFrame::build(layout.content, io, *content_mode, *content_io_focus);
             let active = frame.active(*content_io_focus, content_scrolls);
diff --git a/src/commands/browse/nav.rs b/src/commands/browse/nav.rs
index 388de090..c11e60c9 100644
--- a/src/commands/browse/nav.rs
+++ b/src/commands/browse/nav.rs
@@ -162,9 +162,15 @@ pub(super) fn move_workspace_cursor_down(
     }
 }
 
-pub(super) fn row_list_index(area: ratatui::layout::Rect, row: u16, len: usize) -> Option<usize> {
+pub(super) fn row_list_index(
+    area: ratatui::layout::Rect,
+    row: u16,
+    len: usize,
+    offset: usize,
+) -> Option<usize> {
     let row = row.checked_sub(area.y.saturating_add(1))? as usize;
-    (row < len).then_some(row)
+    let index = row.saturating_add(offset);
+    (index < len).then_some(index)
 }
 
 pub(super) fn source_list_index(
@@ -173,10 +179,11 @@ pub(super) fn source_list_index(
     row: u16,
     sources: &[WorkspaceSource],
     vertical: bool,
+    offset: usize,
 ) -> Option<usize> {
     if vertical {
         // List panel: one source per row (same as sessions/dialogues).
-        return row_list_index(area, row, sources.len());
+        return row_list_index(area, row, sources.len(), offset);
     }
     // Compact strip: single content row, labels laid out left→right.
     if row != area.y.saturating_add(1)
@@ -210,3 +217,23 @@ pub(super) fn reset_workspace_dialogue_state(
     selected_dialogues.resize(dialogue_count, false);
     *range_anchor = None;
 }
+
+#[cfg(test)]
+mod tests {
+    use super::row_list_index;
+    use ratatui::layout::Rect;
+
+    #[test]
+    fn row_list_index_includes_scroll_offset() {
+        let area = Rect::new(0, 0, 30, 10);
+        // Row 1 is the first content row below the panel title.
+        assert_eq!(row_list_index(area, 1, 100, 0), Some(0));
+        // A scrolled list maps the clicked row onto the offset index.
+        assert_eq!(row_list_index(area, 1, 100, 50), Some(50));
+        assert_eq!(row_list_index(area, 4, 100, 50), Some(53));
+        // Indices beyond the list end are rejected.
+        assert_eq!(row_list_index(area, 4, 100, 98), None);
+        // The title row is not a selectable row.
+        assert_eq!(row_list_index(area, 0, 100, 0), None);
+    }
+}
diff --git a/src/commands/browse/panes.rs b/src/commands/browse/panes.rs
index 0c3dbf8f..7728ee54 100644
--- a/src/commands/browse/panes.rs
+++ b/src/commands/browse/panes.rs
@@ -10,8 +10,8 @@
 use crate::pane::{Pane, PaneInput, SlidingPane, WindowRow};
 use crate::tui::content::view::ContentViewMode;
 use crate::tui::workspace::{
-    workspace_content_io_texts, ContentIoFocus, ContentIoFrame, ContentIoTexts, WorkspaceDialogue,
-    WorkspaceSession, WorkspaceSource,
+    workspace_content_io_texts, ContentIoFocus, ContentIoFrame, ContentIoTexts, ExpandedBlocks,
+    WorkspaceDialogue, WorkspaceSession, WorkspaceSource,
 };
 use sivtr_core::ai::AgentSelection;
 use sivtr_core::record::{WorkAt, WorkRecord, WorkRef};
@@ -419,6 +419,7 @@ pub struct ContentCtx<'a> {
     pub target: Option<WorkAt>,
     pub area: ratatui::layout::Rect,
     pub io_focus: ContentIoFocus,
+    pub expanded: &'a ExpandedBlocks,
 }
 
 /// Tracks layout line counts for Input / Output halves separately.
@@ -444,6 +445,7 @@ impl ContentPane {
             ctx.highlighted_idx,
             ctx.mode,
             ctx.target,
+            ctx.expanded,
         );
         let frame = ContentIoFrame::build(ctx.area, texts, ctx.mode, ctx.io_focus);
         self.input_lines = frame.input_lines;
diff --git a/src/commands/browse/picker.rs b/src/commands/browse/picker.rs
index 6d364f0f..43966150 100644
--- a/src/commands/browse/picker.rs
+++ b/src/commands/browse/picker.rs
@@ -6,7 +6,10 @@ use ratatui::widgets::ListState;
 use std::collections::HashSet;
 use std::path::PathBuf;
 
-use crate::tui::content::view::{content_link_at, ContentViewMode};
+use crate::tui::content::view::{
+    content_link_at, content_position_at, content_row_in_text, content_structure_block_at,
+    ContentViewMode,
+};
 use crate::tui::search::{
     workspace_search_fingerprint, workspace_search_has_query, workspace_search_scope,
     WorkspaceSearchIndex, WorkspaceSearchOutput,
@@ -15,8 +18,8 @@ use crate::tui::terminal::read_interaction;
 use crate::tui::workspace::{
     help_action_for_key, panel_inner_rows, render_workspace, search_match_half, selected_index,
     workspace_help_entries, workspace_hit_test, workspace_layout, ContentIoFocus, ContentIoFrame,
-    ContentScrolls, WorkspaceDialogue, WorkspaceFocus, WorkspacePickedContent, WorkspaceSearchView,
-    WorkspaceSession, WorkspaceSource, WorkspaceView,
+    ContentScrolls, ExpandedBlocks, WorkspaceDialogue, WorkspaceFocus, WorkspacePickedContent,
+    WorkspaceSearchView, WorkspaceSession, WorkspaceSource, WorkspaceView,
 };
 
 use super::content::{
@@ -80,6 +83,13 @@ pub(crate) fn run(
     let mut content_scrolls = ContentScrolls::default();
     let mut content_io_focus = ContentIoFocus::Input;
     let mut content_mode = ContentViewMode::Reading;
+    let mut expanded_blocks = ExpandedBlocks::default();
+    let mut expanded_key = None;
+    // Block under a pending click; toggled on mouse release unless a drag
+    // turned the gesture into a text selection.
+    let mut pending_block_toggle: Option<(ContentIoFocus, usize)> = None;
+    // Last clicked structure block, highlighted like a list row.
+    let mut active_block: Option<(ContentIoFocus, usize)> = None;
     let mut show_help = false;
     let mut show_search = false;
     let mut search_query = String::new();
@@ -324,6 +334,23 @@ pub(crate) fn run(
             if let Some((half, _)) = pending_half {
                 content_io_focus = half;
             }
+            // Expansion indices are per-dialogue; reset when the shown
+            // dialogue's identity, target, or selection changes.
+            let dialogue_identity = dialogues
+                .get(dialogue_idx)
+                .map(|dialogue| (dialogue.source.clone(), dialogue.work_ref.clone()));
+            let expand_key = (
+                dialogue_identity,
+                dialogue_idx,
+                active_content_at,
+                selected_dialogues.clone(),
+            );
+            if expanded_key.as_ref() != Some(&expand_key) {
+                expanded_blocks.clear();
+                pending_block_toggle = None;
+                active_block = None;
+                expanded_key = Some(expand_key);
+            }
             content_frame = ContentIoFrame::build(
                 layout.content,
                 content_pane.ensure(ContentCtx {
@@ -334,6 +361,7 @@ pub(crate) fn run(
                     target: active_content_at,
                     area: layout.content,
                     io_focus: content_io_focus,
+                    expanded: &expanded_blocks,
                 }),
                 content_mode,
                 content_io_focus,
@@ -403,6 +431,7 @@ pub(crate) fn run(
                         fullscreen,
                         content_selection: visual_select_mode
                             .map(|mode: VisualSelectMode| mode.selection),
+                        content_active_block: active_block,
                         content_frame: &content_frame,
                     },
                 )
@@ -650,6 +679,7 @@ pub(crate) fn run(
                                 &mut content_scrolls,
                                 &mut content_io_focus,
                                 &mut content_mode,
+                                &expanded_blocks,
                                 content_pane.line_count(ContentIoFocus::Input),
                                 content_pane.line_count(ContentIoFocus::Output),
                                 &mut show_help,
@@ -763,6 +793,7 @@ pub(crate) fn run(
                         &mut content_scrolls,
                         &mut content_io_focus,
                         &mut content_mode,
+                        &expanded_blocks,
                         content_pane.line_count(ContentIoFocus::Input),
                         content_pane.line_count(ContentIoFocus::Output),
                         &mut show_help,
@@ -857,6 +888,45 @@ pub(crate) fn run(
                                 let _ = open_link_target(&target);
                                 continue;
                             }
+                            // Read mode: clicking a structure tag expands/collapses
+                            // that block (raw mode always shows full blocks).
+                            if content_mode == ContentViewMode::Reading {
+                                if let Some(position) = content_position_at(
+                                    active.area,
+                                    active.text,
+                                    *active.scroll,
+                                    content_mode,
+                                    mouse.column,
+                                    mouse.row,
+                                ) {
+                                    // Clicks below the last rendered line clamp
+                                    // to it in `content_position_at`; ignore
+                                    // them instead of toggling the last block.
+                                    if !content_row_in_text(
+                                        active.area,
+                                        active.text,
+                                        content_mode,
+                                        *active.scroll,
+                                        mouse.row,
+                                    ) {
+                                        continue;
+                                    }
+                                    // Record the block under the click and toggle
+                                    // it on release, so a drag still selects text
+                                    // instead of collapsing the block.
+                                    pending_block_toggle = content_structure_block_at(
+                                        active.area,
+                                        active.text,
+                                        content_mode,
+                                        position.line,
+                                    )
+                                    .map(|block| (half, block));
+                                }
+                            }
+                        }
+                        // A drag selects text and cancels the pending block toggle.
+                        if matches!(mouse.kind, MouseEventKind::Drag(MouseButton::Left)) {
+                            pending_block_toggle = None;
                         }
                         if handle_content_mouse_select(
                             &mut visual_select_mode,
@@ -875,6 +945,15 @@ pub(crate) fn run(
                             if visual_select_mode.is_some() {
                                 set_focus(&mut focus, &mut fullscreen, WorkspaceFocus::Content);
                             }
+                            // Pure click (no drag): release toggles the block
+                            // and marks it as the active highlight.
+                            if matches!(mouse.kind, MouseEventKind::Up(MouseButton::Left)) {
+                                if let Some((half, block)) = pending_block_toggle.take() {
+                                    active_block = Some((half, block));
+                                    expanded_blocks.toggle(half, block);
+                                    redraw = true;
+                                }
+                            }
                             continue;
                         }
                     } else if visual_select_mode.is_some() {
@@ -935,14 +1014,18 @@ pub(crate) fn run(
                                         mouse.row,
                                         &sources,
                                         vertical,
+                                        source_state.offset(),
                                     ) {
                                         source_state.select(Some(idx));
                                     }
                                 }
                                 WorkspaceFocus::Sessions => {
-                                    if let Some(idx) =
-                                        row_list_index(layout.sessions, mouse.row, sessions.len())
-                                    {
+                                    if let Some(idx) = row_list_index(
+                                        layout.sessions,
+                                        mouse.row,
+                                        sessions.len(),
+                                        session_state.offset(),
+                                    ) {
                                         session_state.select(Some(idx));
                                         if !has_selected_sessions(&selected_sessions) {
                                             reset_workspace_dialogue_state(
@@ -956,9 +1039,12 @@ pub(crate) fn run(
                                     }
                                 }
                                 WorkspaceFocus::Dialogues => {
-                                    if let Some(idx) =
-                                        row_list_index(layout.dialogues, mouse.row, dialogue_count)
-                                    {
+                                    if let Some(idx) = row_list_index(
+                                        layout.dialogues,
+                                        mouse.row,
+                                        dialogue_count,
+                                        dialogue_state.offset(),
+                                    ) {
                                         dialogue_state.select(Some(idx));
                                         content_scrolls.clear();
                                     }
diff --git a/src/commands/browse/visual.rs b/src/commands/browse/visual.rs
index 0919ccfc..a5b04a6b 100644
--- a/src/commands/browse/visual.rs
+++ b/src/commands/browse/visual.rs
@@ -17,7 +17,7 @@ use crate::tui::workspace::{
 use super::content::workspace_picked_content;
 use super::nav::{move_workspace_cursor_down, move_workspace_cursor_up};
 
-const MOUSE_SCROLL_LINES: usize = 3;
+const MOUSE_SCROLL_LINES: usize = 1;
 #[derive(Clone, Copy)]
 pub(super) struct VisualSelectMode {
     pub(super) selection: ContentSelection,
diff --git a/src/tui/content/io.rs b/src/tui/content/io.rs
index 6f9f27bd..f7c1e49d 100644
--- a/src/tui/content/io.rs
+++ b/src/tui/content/io.rs
@@ -4,6 +4,7 @@
 //! so picker / render / help don't re-copy the same match arms.
 
 use ratatui::layout::Rect;
+use std::collections::HashSet;
 
 use crate::tui::content::view::{content_view_line_count, ContentViewMode};
 
@@ -117,6 +118,35 @@ impl ContentScrolls {
     }
 }
 
+/// Which structure blocks the user expanded, per content half. Read mode
+/// defaults every block to its `<:…:>` tag line; a block in this set shows
+/// its full payload instead. Raw mode always shows full blocks and ignores
+/// this state. A block index is the ordinal of the block's open marker line
+/// within that half's text — stable because every block shows exactly one
+/// open marker line whether collapsed or expanded.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub(crate) struct ExpandedBlocks {
+    pub(crate) input: HashSet<usize>,
+    pub(crate) output: HashSet<usize>,
+}
+
+impl ExpandedBlocks {
+    pub(crate) fn toggle(&mut self, focus: ContentIoFocus, block: usize) {
+        let set = match focus {
+            ContentIoFocus::Input => &mut self.input,
+            ContentIoFocus::Output => &mut self.output,
+        };
+        if !set.insert(block) {
+            set.remove(&block);
+        }
+    }
+
+    pub(crate) fn clear(&mut self) {
+        self.input.clear();
+        self.output.clear();
+    }
+}
+
 /// Geometry of the dual content panes.
 #[derive(Clone, Copy, Debug, Default)]
 pub(crate) struct ContentIoAreas {
diff --git a/src/tui/content/markdown.rs b/src/tui/content/markdown.rs
index 437f05ce..b271e039 100644
--- a/src/tui/content/markdown.rs
+++ b/src/tui/content/markdown.rs
@@ -814,7 +814,7 @@ fn agent_heading_style(text: &str) -> Option<Style> {
 /// structural content renders in a subdued gray, distinct from the
 /// default-foreground body.
 fn structure_marker_style(text: &str) -> Option<Style> {
-    if !text.starts_with("<:") {
+    if !crate::tui::content::text::is_structure_marker(text) {
         return None;
     }
     Some(structural_gray_style())
diff --git a/src/tui/content/text.rs b/src/tui/content/text.rs
index aeac50e7..8c4584fe 100644
--- a/src/tui/content/text.rs
+++ b/src/tui/content/text.rs
@@ -2,18 +2,30 @@
 
 use sivtr_core::record::{WorkAt, WorkRecord};
 
-use crate::tui::content::io::ContentIoTexts;
+use crate::tui::content::io::{ContentIoTexts, ExpandedBlocks};
 use crate::tui::content::view::ContentViewMode;
 use crate::tui::workspace::model::WorkspaceDialogue;
 
-pub(crate) fn content_io_from_record(record: &WorkRecord, reading: bool) -> ContentIoTexts {
+/// Read mode folds every structure part to its `<:…:>` tag; parts listed in
+/// `expanded` show their full block instead. Raw mode always shows full
+/// blocks (the expand state only affects reading).
+pub(crate) fn content_io_from_record(
+    record: &WorkRecord,
+    reading: bool,
+    expanded: &ExpandedBlocks,
+) -> ContentIoTexts {
     ContentIoTexts {
-        input: io_body_text(record, reading, true),
-        output: io_body_text(record, reading, false),
+        input: io_body_text(record, reading, true, &expanded.input),
+        output: io_body_text(record, reading, false, &expanded.output),
     }
 }
 
-fn io_body_text(record: &WorkRecord, reading: bool, input: bool) -> String {
+fn io_body_text(
+    record: &WorkRecord,
+    reading: bool,
+    input: bool,
+    expanded: &std::collections::HashSet<usize>,
+) -> String {
     let parts: Vec<&sivtr_core::record::WorkPart> = record
         .parts
         .iter()
@@ -22,33 +34,82 @@ fn io_body_text(record: &WorkRecord, reading: bool, input: bool) -> String {
     if parts.is_empty() {
         return String::new();
     }
-    if reading {
-        structured_parts_text(&parts)
-    } else {
-        raw_parts_text(&parts)
-    }
-}
-
-/// Reading: dialogue in order; each structure part collapses to its
-/// `<:…:>` open-marker tag line (same gray style as raw markers).
-fn structured_parts_text(parts: &[&sivtr_core::record::WorkPart]) -> String {
+    let mut block = 0usize;
     let mut chunks = Vec::new();
-    for part in parts {
+    let mut idx = 0usize;
+    while idx < parts.len() {
+        let part = parts[idx];
         if part.kind().is_structure() {
-            chunks.push(structure_fold_label(part));
+            // A ToolCall and its matching ToolResult fold into one block, so a
+            // tool invocation reads as a single unit: one tag when collapsed,
+            // the call and its result side by side when expanded.
+            let group_end = structure_group_end(&parts, idx);
+            let block_idx = block;
+            block += 1;
+            // Raw mode always shows full blocks; read mode folds to the tag
+            // unless the block was expanded.
+            if !reading || expanded.contains(&block_idx) {
+                let mut body = Vec::new();
+                for grouped in &parts[idx..=group_end] {
+                    body.push(sivtr_core::record::format_work_part(grouped));
+                }
+                chunks.push(body.join("\n\n"));
+            } else {
+                chunks.push(structure_fold_label(part));
+            }
+            idx = group_end + 1;
         } else {
             chunks.push(part.text().into_owned());
+            idx += 1;
         }
     }
     chunks.join("\n\n")
 }
 
-fn raw_parts_text(parts: &[&sivtr_core::record::WorkPart]) -> String {
-    parts
-        .iter()
-        .map(|part| sivtr_core::record::format_work_part(part))
-        .collect::<Vec<_>>()
-        .join("\n\n")
+/// Last part of the structure group starting at `start`: a ToolCall followed
+/// by a ToolResult of the same tool exchange is one group; anything else is a
+/// single-part group.
+fn structure_group_end(parts: &[&sivtr_core::record::WorkPart], start: usize) -> usize {
+    if !matches!(
+        parts[start].kind(),
+        sivtr_core::record::WorkPartKind::ToolCall
+    ) {
+        return start;
+    }
+    match parts.get(start + 1) {
+        Some(result)
+            if matches!(result.kind(), sivtr_core::record::WorkPartKind::ToolResult)
+                && same_tool_exchange(parts[start], result) =>
+        {
+            start + 1
+        }
+        _ => start,
+    }
+}
+
+/// Whether a ToolCall and a ToolResult provably belong to one exchange:
+/// equal non-empty call ids, or — for id-less transcripts — the same tool
+/// name. Two missing ids alone never match.
+fn same_tool_exchange(
+    call: &sivtr_core::record::WorkPart,
+    result: &sivtr_core::record::WorkPart,
+) -> bool {
+    use sivtr_core::record::WorkPartData;
+    match (&call.data, &result.data) {
+        (
+            WorkPartData::ToolCall { call_id, tool, .. },
+            WorkPartData::ToolResult {
+                call_id: result_id,
+                tool: result_tool,
+                ..
+            },
+        ) => match (call_id.as_deref(), result_id.as_deref()) {
+            (Some(call), Some(result)) => call == result,
+            (None, None) => tool.is_some() && tool == result_tool,
+            _ => false,
+        },
+        _ => false,
+    }
 }
 
 pub(crate) fn structured_part_text(part: &sivtr_core::record::WorkPart) -> String {
@@ -60,10 +121,41 @@ pub(crate) fn structured_part_text(part: &sivtr_core::record::WorkPart) -> Strin
 }
 
 fn structure_fold_label(part: &sivtr_core::record::WorkPart) -> String {
-    part.kind()
+    let marker = part
+        .kind()
         .as_agent_block_kind()
         .and_then(|kind| kind.open_marker(part.label()))
-        .unwrap_or_else(|| "<:structure:>".to_string())
+        .unwrap_or_else(|| "<:structure:>".to_string());
+    match tool_description(part) {
+        Some(description) => match marker.strip_suffix(":>") {
+            Some(base) => format!("{base}: {description}:>"),
+            None => marker,
+        },
+        None => marker,
+    }
+}
+
+/// Human description from a tool call's input (`description` field), if any,
+/// truncated to fit the tag line.
+fn tool_description(part: &sivtr_core::record::WorkPart) -> Option<String> {
+    let sivtr_core::record::WorkPartData::ToolCall { input, .. } = &part.data else {
+        return None;
+    };
+    let description = input
+        .get("description")
+        .and_then(serde_json::Value::as_str)?;
+    // Normalize internal whitespace so a multi-line description still folds
+    // to a single tag line (marker scanning assumes one line per block).
+    let description: String = description.split_whitespace().collect::<Vec<_>>().join(" ");
+    if description.is_empty() {
+        return None;
+    }
+    const MAX: usize = 40;
+    let mut truncated: String = description.chars().take(MAX).collect();
+    if description.chars().count() > MAX {
+        truncated.push('…');
+    }
+    Some(truncated)
 }
 
 pub(crate) fn workspace_content_text(
@@ -73,17 +165,25 @@ pub(crate) fn workspace_content_text(
     mode: ContentViewMode,
     target: Option<WorkAt>,
 ) -> String {
-    workspace_content_io_texts(dialogues, selected_dialogues, highlighted_idx, mode, target)
-        .join_displayed()
+    workspace_content_io_texts(
+        dialogues,
+        selected_dialogues,
+        highlighted_idx,
+        mode,
+        target,
+        &ExpandedBlocks::default(),
+    )
+    .join_displayed()
 }
 
-/// Input / Output bodies for the dual content panes.
+/// Input / Output bodies for the dual content panes with per-block expansion.
 pub(crate) fn workspace_content_io_texts(
     dialogues: &[WorkspaceDialogue],
     selected_dialogues: &[bool],
     highlighted_idx: usize,
     mode: ContentViewMode,
     target: Option<WorkAt>,
+    expanded: &ExpandedBlocks,
 ) -> ContentIoTexts {
     if dialogues.is_empty() {
         return ContentIoTexts {
@@ -101,7 +201,7 @@ pub(crate) fn workspace_content_io_texts(
     if selected.is_empty() {
         return dialogues
             .get(highlighted_idx)
-            .map(|dialogue| dialogue.content_io_texts(mode, target))
+            .map(|dialogue| dialogue.content_io_texts(mode, target, expanded))
             .unwrap_or_else(|| ContentIoTexts {
                 input: "<empty>".to_string(),
                 output: String::new(),
@@ -115,7 +215,7 @@ pub(crate) fn workspace_content_io_texts(
         let Some(dialogue) = dialogues.get(dialogue_idx) else {
             continue;
         };
-        let io = dialogue.content_io_texts(mode, None);
+        let io = dialogue.content_io_texts(mode, None, expanded);
         if !io.input.trim().is_empty() {
             input.push(io.input);
         }
@@ -136,3 +236,249 @@ pub(crate) fn workspace_content_io_texts(
         },
     }
 }
+
+/// A line that opens or closes a structure block (`<:tool:…:>`,
+/// `<:skill:…:>`, `<:thinking:>`, or the generic `<:structure:>` fallback).
+/// Validates the full marker shape, not just the `<:` prefix, so plain text
+/// that happens to start with `<:` is not treated as a marker.
+pub(crate) fn is_structure_marker(line: &str) -> bool {
+    let Some(inner) = line
+        .strip_prefix("<:")
+        .and_then(|rest| rest.strip_suffix(":>"))
+    else {
+        return false;
+    };
+    let kind = inner
+        .strip_prefix('/')
+        .unwrap_or(inner)
+        .split(':')
+        .next()
+        .unwrap_or_default();
+    matches!(kind, "tool" | "skill" | "thinking" | "structure")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::content_io_from_record;
+    use crate::tui::content::io::{ContentIoFocus, ExpandedBlocks};
+    use sivtr_core::ai::AgentProvider;
+    use sivtr_core::record::{WorkPart, WorkPartData, WorkRecord, WorkRef};
+
+    fn tool_part(seq: usize, tool: &str, input: &str) -> WorkPart {
+        WorkPart {
+            seq,
+            occurred_at: None,
+            data: WorkPartData::ToolCall {
+                call_id: None,
+                tool: Some(tool.to_string()),
+                input: serde_json::json!({ "command": input }),
+            },
+        }
+    }
+
+    fn tool_result_part(seq: usize, tool: &str, output: &str) -> WorkPart {
+        WorkPart {
+            seq,
+            occurred_at: None,
+            data: WorkPartData::ToolResult {
+                call_id: None,
+                tool: Some(tool.to_string()),
+                output: serde_json::json!({ "stdout": output }),
+            },
+        }
+    }
+
+    fn record(parts: Vec<WorkPart>) -> WorkRecord {
+        WorkRecord {
+            schema_version: 2,
+            work_ref: WorkRef::agent(AgentProvider::Codex, "session", 1),
+            kind: sivtr_core::record::WorkRecordKind::ChatTurn,
+            source: sivtr_core::record::WorkSource {
+                channel: sivtr_core::record::WorkChannel::Chat,
+                provider: Some("codex".to_string()),
+            },
+            session: sivtr_core::record::WorkSessionRef {
+                id: "session".to_string(),
+                canonical_id: None,
+                path: None,
+            },
+            cwd: None,
+            time: sivtr_core::record::WorkTime::default(),
+            status: None,
+            title: "cmd".to_string(),
+            parts,
+        }
+    }
+
+    #[test]
+    fn reading_folds_to_tags_and_expanded_blocks_show_full() {
+        let rec = record(vec![
+            tool_part(1, "Bash", "ls"),
+            tool_part(2, "Read", "file"),
+        ]);
+        let io = content_io_from_record(&rec, true, &ExpandedBlocks::default());
+        let output = &io.output;
+        assert!(output.contains("<:tool:Bash call:>"));
+        assert!(output.contains("<:tool:Read call:>"));
+        assert!(!output.contains("ls"));
+        assert!(!output.contains("file"));
+
+        let mut expanded = ExpandedBlocks::default();
+        expanded.toggle(ContentIoFocus::Output, 1);
+        let io = content_io_from_record(&rec, true, &expanded);
+        let output = &io.output;
+        assert!(output.contains("<:tool:Read call:>"));
+        assert!(output.contains("<:/tool:Read call:>"));
+        assert!(output.contains("file"));
+        assert!(!output.contains("ls"));
+    }
+
+    #[test]
+    fn raw_mode_ignores_expand_state() {
+        let rec = record(vec![tool_part(1, "Bash", "ls")]);
+        let mut expanded = ExpandedBlocks::default();
+        expanded.toggle(ContentIoFocus::Output, 0);
+        let io = content_io_from_record(&rec, false, &expanded);
+        assert!(io.output.contains("<:tool:Bash call:>"));
+        assert!(io.output.contains("ls"));
+        assert!(io.output.contains("<:/tool:Bash call:>"));
+    }
+
+    #[test]
+    fn tool_call_and_result_fold_into_one_tag() {
+        let rec = record(vec![
+            tool_part(1, "Bash", "ls"),
+            tool_result_part(2, "Bash", "ok"),
+            tool_part(3, "Read", "file"),
+        ]);
+        let io = content_io_from_record(&rec, true, &ExpandedBlocks::default());
+        let output = &io.output;
+        // Collapsed: one tag for the call+result group, then the Read tag;
+        // the result payload stays hidden.
+        assert!(output.contains("<:tool:Bash call:>"));
+        assert!(!output.contains("<:tool:Bash result:>"));
+        assert!(!output.contains("ok"));
+        assert!(output.contains("<:tool:Read call:>"));
+        let bash = output.find("<:tool:Bash call:>").expect("bash tag");
+        let read = output.find("<:tool:Read call:>").expect("read tag");
+        assert!(bash < read);
+
+        // Expanding the group reveals the result inside the same block.
+        let mut expanded = ExpandedBlocks::default();
+        expanded.toggle(ContentIoFocus::Output, 0);
+        let io = content_io_from_record(&rec, true, &expanded);
+        let output = &io.output;
+        assert!(output.contains("<:tool:Bash result:>"));
+        assert!(output.contains("ok"));
+        assert!(output.contains("<:/tool:Bash result:>"));
+        // The Read block is untouched.
+        assert!(!output.contains("file"));
+    }
+
+    #[test]
+    fn fold_label_shows_tool_description_when_present() {
+        let rec = record(vec![WorkPart {
+            seq: 1,
+            occurred_at: None,
+            data: WorkPartData::ToolCall {
+                call_id: None,
+                tool: Some("Bash".to_string()),
+                input: serde_json::json!({
+                    "command": "git diff",
+                    "description": "Review working tree",
+                }),
+            },
+        }]);
+        let io = content_io_from_record(&rec, true, &ExpandedBlocks::default());
+        assert!(io
+            .output
+            .contains("<:tool:Bash call: Review working tree:>"));
+
+        // Long descriptions are truncated to fit the tag line.
+        let rec = record(vec![WorkPart {
+            seq: 1,
+            occurred_at: None,
+            data: WorkPartData::ToolCall {
+                call_id: None,
+                tool: Some("Bash".to_string()),
+                input: serde_json::json!({
+                    "command": "git diff",
+                    "description": "Review working tree and diff size for this change, then summarize",
+                }),
+            },
+        }]);
+        let io = content_io_from_record(&rec, true, &ExpandedBlocks::default());
+        let tag = io.output.find("<:tool:Bash call: ").expect("tag");
+        let line = &io.output[tag..];
+        assert!(line.starts_with("<:tool:Bash call: Review working tree and diff size for th…:>"));
+        assert!(!line.starts_with("<:tool:Bash call: Review working tree and diff size for this"));
+
+        // No description: the plain tag stays.
+        let rec = record(vec![tool_part(1, "Bash", "ls")]);
+        let io = content_io_from_record(&rec, true, &ExpandedBlocks::default());
+        assert!(io.output.contains("<:tool:Bash call:>"));
+    }
+
+    #[test]
+    fn fold_label_normalizes_multiline_descriptions_to_one_tag_line() {
+        let rec = record(vec![WorkPart {
+            seq: 1,
+            occurred_at: None,
+            data: WorkPartData::ToolCall {
+                call_id: None,
+                tool: Some("Bash".to_string()),
+                input: serde_json::json!({
+                    "command": "git diff",
+                    "description": "line one\nline two",
+                }),
+            },
+        }]);
+        let io = content_io_from_record(&rec, true, &ExpandedBlocks::default());
+        // The tag stays a single line: internal whitespace collapses.
+        let mut lines = io.output.lines();
+        assert_eq!(lines.next(), Some("<:tool:Bash call: line one line two:>"));
+        assert_eq!(lines.next(), None);
+    }
+
+    #[test]
+    fn id_less_call_and_result_group_only_for_the_same_tool() {
+        let rec = record(vec![
+            tool_part(1, "Bash", "ls"),
+            tool_result_part(2, "Read", "ok"),
+        ]);
+        let io = content_io_from_record(&rec, true, &ExpandedBlocks::default());
+        // Different tools without call ids are separate blocks, so the
+        // result keeps its own tag instead of hiding inside the Bash block.
+        let output = &io.output;
+        assert!(output.contains("<:tool:Bash call:>"));
+        assert!(output.contains("<:tool:Read result:>"));
+    }
+
+    #[test]
+    fn distinct_call_ids_never_group() {
+        let rec = record(vec![
+            WorkPart {
+                seq: 1,
+                occurred_at: None,
+                data: WorkPartData::ToolCall {
+                    call_id: Some("a".to_string()),
+                    tool: Some("Bash".to_string()),
+                    input: serde_json::json!({ "command": "ls" }),
+                },
+            },
+            WorkPart {
+                seq: 2,
+                occurred_at: None,
+                data: WorkPartData::ToolResult {
+                    call_id: Some("b".to_string()),
+                    tool: Some("Bash".to_string()),
+                    output: serde_json::json!({ "stdout": "ok" }),
+                },
+            },
+        ]);
+        let io = content_io_from_record(&rec, true, &ExpandedBlocks::default());
+        let output = &io.output;
+        assert!(output.contains("<:tool:Bash call:>"));
+        assert!(output.contains("<:tool:Bash result:>"));
+    }
+}
diff --git a/src/tui/content/view.rs b/src/tui/content/view.rs
index 3b69b1d3..347191f9 100644
--- a/src/tui/content/view.rs
+++ b/src/tui/content/view.rs
@@ -39,6 +39,8 @@ pub(crate) struct ContentView<'a> {
     pub(crate) search_regex: Option<&'a Regex>,
     pub(crate) mode: ContentViewMode,
     pub(crate) selection: Option<ContentSelection>,
+    /// Structure block ordinal to highlight (its displayed line range), if any.
+    pub(crate) active_block: Option<usize>,
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -109,12 +111,16 @@ pub(crate) fn render_content_view(
         Paragraph::new(separator_lines(visible_height, &visible)),
         chunks[1],
     );
+    let block_highlight = view
+        .active_block
+        .and_then(|block| content_structure_block_range(area, view.text, view.mode, block));
     frame.render_widget(
         Paragraph::new(content_lines(
             visible,
             scroll,
             view.search_regex,
             view.selection,
+            block_highlight,
         )),
         chunks[2],
     );
@@ -197,6 +203,121 @@ pub(crate) fn content_position_at(
     ))
 }
 
+/// Whether a mouse row inside the content area lands on a real rendered
+/// line. [`content_position_at`] clamps rows below the last line to it, so
+/// callers that treat a hit as content (e.g. block toggling) must check the
+/// raw row against the wrapped line count first. Call after
+/// [`content_position_at`] returned `Some`, when the row is already known to
+/// be inside the content area.
+pub(crate) fn content_row_in_text(
+    area: Rect,
+    text: &str,
+    mode: ContentViewMode,
+    scroll: usize,
+    row: u16,
+) -> bool {
+    let content_area = content_text_area(area, text, mode);
+    let raw_line = scroll.saturating_add((row.saturating_sub(content_area.y)) as usize);
+    raw_line < content_view_line_count(area, text, mode)
+}
+
+/// Structure block ordinal covering `line` (a displayed line index), if any.
+/// Walks the wrapped display and maps each line onto the block whose open
+/// marker owns it: the tag line, the expanded body, and the close marker all
+/// belong to the same block, so clicking anywhere on an expanded block (or
+/// on its tag) toggles it. A merged tool group's `result:` section stays
+/// inside the same block as its `call:` section.
+pub(crate) fn content_structure_block_at(
+    area: Rect,
+    text: &str,
+    mode: ContentViewMode,
+    line: usize,
+) -> Option<usize> {
+    content_block_ownership(area, text, mode)
+        .get(line)
+        .copied()
+        .flatten()
+}
+
+/// Displayed line range (start..end, end exclusive) owned by `block`, if the
+/// block is present in the layout.
+pub(crate) fn content_structure_block_range(
+    area: Rect,
+    text: &str,
+    mode: ContentViewMode,
+    block: usize,
+) -> Option<std::ops::Range<usize>> {
+    let ownership = content_block_ownership(area, text, mode);
+    let start = ownership.iter().position(|owner| *owner == Some(block))?;
+    let end = ownership.iter().rposition(|owner| *owner == Some(block))?;
+    Some(start..end + 1)
+}
+
+fn content_block_ownership(area: Rect, text: &str, mode: ContentViewMode) -> Vec<Option<usize>> {
+    let content_area = content_text_area(area, text, mode);
+    let width = content_area.width as usize;
+    let lines = all_content_lines(text, width, mode);
+    let joined = |idx: usize| {
+        lines[idx]
+            .line
+            .spans
+            .iter()
+            .map(|span| span.content.as_ref())
+            .collect::<String>()
+    };
+
+    // Map each displayed line to the block that owns it. A block runs from
+    // its open marker to the last close marker before the next block's open;
+    // a collapsed block owns only its tag line.
+    let mut ownership = vec![None; lines.len()];
+    let mut block = 0usize;
+    let mut idx = 0usize;
+    while idx < lines.len() {
+        let text = joined(idx);
+        if !is_open_marker(&text) {
+            idx += 1;
+            continue;
+        }
+        ownership[idx] = Some(block);
+        let mut end = idx;
+        let mut scan = idx + 1;
+        while scan < lines.len() {
+            let candidate = joined(scan);
+            if is_open_marker(&candidate) && !is_result_section(&candidate) {
+                break;
+            }
+            // Close markers get the same validation as open ones: plain text
+            // that merely starts with "<:/" must not extend the block.
+            if crate::tui::content::text::is_structure_marker(&candidate)
+                && candidate.starts_with("<:/")
+            {
+                end = scan;
+            }
+            scan += 1;
+        }
+        for owned in ownership[idx + 1..=end].iter_mut() {
+            *owned = Some(block);
+        }
+        block += 1;
+        idx = end + 1;
+    }
+    ownership
+}
+
+fn is_open_marker(text: &str) -> bool {
+    crate::tui::content::text::is_structure_marker(text) && !text.starts_with("<:/")
+}
+
+/// A `result:` section marker (`<:tool:… result:>`) belongs to the preceding
+/// `call:` block, not a new block.
+fn is_result_section(text: &str) -> bool {
+    open_marker_inner(text).is_some_and(|inner| inner.ends_with(" result"))
+}
+
+fn open_marker_inner(text: &str) -> Option<&str> {
+    text.strip_prefix("<:")?.strip_suffix(":>")
+}
+
 pub(crate) fn content_position_in_text_row(
     area: Rect,
     text: &str,
@@ -414,7 +535,7 @@ fn all_content_lines(text: &str, width: usize, mode: ContentViewMode) -> Vec<Con
 /// `<:channel:…:>` structure markers use the same structural gray as
 /// read/fold summaries so the two modes stay visually consistent.
 fn raw_content_line(line: &str) -> ContentLine {
-    let style = if line.starts_with("<:") {
+    let style = if crate::tui::content::text::is_structure_marker(line) {
         Style::default().fg(crate::tui::theme::muted())
     } else {
         Style::default()
@@ -462,6 +583,7 @@ fn content_lines(
     scroll: usize,
     search_regex: Option<&Regex>,
     selection: Option<ContentSelection>,
+    block_highlight: Option<std::ops::Range<usize>>,
 ) -> Text<'static> {
     let lines = visible
         .into_iter()
@@ -469,12 +591,39 @@ fn content_lines(
         .map(|(idx, line)| {
             let line_idx = scroll.saturating_add(idx);
             let line = styled_content_line(line.line, search_regex);
-            styled_selection_line(line, selection, line_idx)
+            let line = styled_selection_line(line, selection, line_idx);
+            style_block_line(line, block_highlight.as_ref(), line_idx)
         })
         .collect::<Vec<_>>();
     Text::from(lines)
 }
 
+/// Tint every line of the active structure block, matching the row highlight
+/// used by the session/dialogue lists, so clicking a block in content reads
+/// as selecting it.
+fn style_block_line(
+    line: Line<'static>,
+    highlight: Option<&std::ops::Range<usize>>,
+    line_idx: usize,
+) -> Line<'static> {
+    let Some(range) = highlight else {
+        return line;
+    };
+    if !range.contains(&line_idx) {
+        return line;
+    }
+    let overlay = visual_selection_style();
+    Line {
+        spans: line
+            .spans
+            .into_iter()
+            .map(|span| Span::styled(span.content, span.style.patch(overlay)))
+            .collect(),
+        style: line.style.patch(overlay),
+        alignment: line.alignment,
+    }
+}
+
 fn styled_selection_line(
     line: Line<'static>,
     selection: Option<ContentSelection>,
@@ -1159,9 +1308,9 @@ fn raw_lines(text: &str) -> Vec<&str> {
 mod tests {
     use super::{
         content_lines, content_link_at, content_position_at, content_position_in_text_row,
-        line_count, line_number_width, render_content_view, selected_content_text,
-        visible_content_lines, ContentPosition, ContentSelection, ContentSelectionKind,
-        ContentView, ContentViewMode,
+        content_structure_block_at, line_count, line_number_width, render_content_view,
+        selected_content_text, visible_content_lines, ContentPosition, ContentSelection,
+        ContentSelectionKind, ContentView, ContentViewMode,
     };
     use crate::tui::pane::Panel;
     use ratatui::backend::TestBackend;
@@ -1172,6 +1321,23 @@ mod tests {
     use regex::Regex;
     use unicode_width::UnicodeWidthStr;
 
+    /// Displayed line index of the first layout line containing `needle`.
+    fn displayed_line_of(lines: &[super::ContentLine], needle: &str) -> usize {
+        lines
+            .iter()
+            .enumerate()
+            .find_map(|(idx, line)| {
+                let joined: String = line
+                    .line
+                    .spans
+                    .iter()
+                    .map(|span| span.content.as_ref())
+                    .collect();
+                joined.contains(needle).then_some(idx)
+            })
+            .expect("needle appears in layout")
+    }
+
     fn render_content_lines(
         text: &str,
         scroll: usize,
@@ -1184,6 +1350,7 @@ mod tests {
             scroll,
             search_regex,
             None,
+            None,
         )
     }
 
@@ -1282,6 +1449,7 @@ mod tests {
             0,
             None,
             None,
+            None,
         );
 
         assert_eq!(rendered.lines.len(), 2);
@@ -1300,7 +1468,7 @@ mod tests {
             16,
             ContentViewMode::Reading,
         );
-        let rendered = content_lines(visible.clone(), 0, None, None);
+        let rendered = content_lines(visible.clone(), 0, None, None, None);
 
         assert_eq!(rendered.lines.len(), 2);
         assert_eq!(rendered_line_text(&rendered, 0), "docker-compose.f");
@@ -1398,6 +1566,7 @@ mod tests {
             0,
             None,
             None,
+            None,
         );
 
         assert!(!rendered.lines.is_empty());
@@ -1500,6 +1669,7 @@ mod tests {
                 cursor: ContentPosition { line: 1, column: 3 },
                 kind: ContentSelectionKind::Block,
             }),
+            None,
         );
 
         assert_eq!(rendered.lines[0].spans[1].content.as_ref(), "bcd");
@@ -1525,6 +1695,7 @@ mod tests {
                 cursor: ContentPosition { line: 0, column: 3 },
                 kind: ContentSelectionKind::Linear,
             }),
+            None,
         );
 
         assert_eq!(rendered_line_text(&rendered, 0), "alpha");
@@ -1552,6 +1723,7 @@ mod tests {
                         search_regex: None,
                         mode: ContentViewMode::Reading,
                         selection: None,
+                        active_block: None,
                     },
                 );
             })
@@ -1562,6 +1734,44 @@ mod tests {
         assert!(backend_row(backend, 2).contains("2|beta"));
     }
 
+    #[test]
+    fn render_content_view_highlights_the_active_block() {
+        let backend = TestBackend::new(40, 8);
+        let mut terminal = Terminal::new(backend).expect("terminal from test backend");
+        terminal
+            .draw(|frame| {
+                render_content_view(
+                    frame,
+                    Rect::new(0, 0, 40, 8),
+                    Panel::new("3", "Content (read)", true),
+                    ContentView {
+                        text: "<:tool:Bash call:>\nbody\n<:/tool:Bash call:>\n<:tool:Read call:>",
+                        scroll: 0,
+                        search_regex: None,
+                        mode: ContentViewMode::Reading,
+                        selection: None,
+                        active_block: Some(0),
+                    },
+                );
+            })
+            .expect("draw content frame");
+        let buffer = terminal.backend().buffer();
+        // Block 0 spans the tag, body, and close rows; its lines use the same
+        // selected-row background as the session/dialogue lists.
+        let selected_bg = super::visual_selection_style().bg;
+        for row in 1..=3 {
+            let cell = buffer.cell((4, row)).expect("cell within buffer bounds");
+            assert_eq!(
+                cell.style().bg,
+                selected_bg,
+                "row {row} should be highlighted"
+            );
+        }
+        // The next block's tag is not part of the highlight.
+        let cell = buffer.cell((4, 4)).expect("cell within buffer bounds");
+        assert_ne!(cell.style().bg, selected_bg);
+    }
+
     #[test]
     fn content_layout_single_pass_matches_metrics_and_fits_width() {
         let text = "line one\nline two\n| a | b |\n| --- | --- |\n| 1 | 2 |\n\n```rust\nfn main() {}\n```\n";
@@ -1595,4 +1805,139 @@ mod tests {
             );
         }
     }
+
+    #[test]
+    fn structure_block_at_maps_displayed_lines_with_wrapping() {
+        let area = Rect::new(0, 0, 24, 10);
+        let long = "alpha ".repeat(20);
+        let text = format!("{long}\n<:tool:A call:>\n<:tool:B call:>");
+        let (lines, _) = super::content_layout(area, &text, ContentViewMode::Reading);
+        let tag_lines: Vec<usize> = lines
+            .iter()
+            .enumerate()
+            .filter_map(|(idx, line)| {
+                let joined: String = line
+                    .line
+                    .spans
+                    .iter()
+                    .map(|span| span.content.as_ref())
+                    .collect();
+                joined.starts_with("<:tool:").then_some(idx)
+            })
+            .collect();
+        assert_eq!(tag_lines.len(), 2);
+        // The long body wraps, so the tags' displayed lines are no longer
+        // their raw text-line indices; the block lookup must follow the
+        // display, not `text.lines()`.
+        assert_ne!(tag_lines[0], 1, "wrapped body shifts the tag line index");
+        assert_eq!(
+            content_structure_block_at(area, &text, ContentViewMode::Reading, tag_lines[0]),
+            Some(0)
+        );
+        assert_eq!(
+            content_structure_block_at(area, &text, ContentViewMode::Reading, tag_lines[1]),
+            Some(1)
+        );
+        // A body line is not an open marker.
+        assert_eq!(
+            content_structure_block_at(area, &text, ContentViewMode::Reading, 0),
+            None
+        );
+    }
+
+    #[test]
+    fn structure_block_at_owns_expanded_body_and_close_marker() {
+        let area = Rect::new(0, 0, 40, 20);
+        // Block 0 expanded (tag + body + close); block 1 collapsed (tag only).
+        let text =
+            "<:tool:Bash call:>\noutput line\n<:/tool:Bash call:>\n<:tool:Read call:>\nplain";
+        let (lines, _) = super::content_layout(area, text, ContentViewMode::Reading);
+        let tag = displayed_line_of(&lines, "<:tool:Bash call:>");
+        let body = displayed_line_of(&lines, "output line");
+        let close = displayed_line_of(&lines, "<:/tool:Bash call:>");
+        let next_tag = displayed_line_of(&lines, "<:tool:Read call:>");
+        let plain = displayed_line_of(&lines, "plain");
+        // The tag, the expanded body, and the close marker all own block 0.
+        assert_eq!(
+            content_structure_block_at(area, text, ContentViewMode::Reading, tag),
+            Some(0)
+        );
+        assert_eq!(
+            content_structure_block_at(area, text, ContentViewMode::Reading, body),
+            Some(0)
+        );
+        assert_eq!(
+            content_structure_block_at(area, text, ContentViewMode::Reading, close),
+            Some(0)
+        );
+        assert_eq!(
+            content_structure_block_at(area, text, ContentViewMode::Reading, next_tag),
+            Some(1)
+        );
+        // Plain text after a collapsed tag belongs to no block.
+        assert_eq!(
+            content_structure_block_at(area, text, ContentViewMode::Reading, plain),
+            None
+        );
+    }
+
+    #[test]
+    fn structure_block_ignores_plain_text_starting_with_close_prefix() {
+        let area = Rect::new(0, 0, 40, 20);
+        // A collapsed block followed by plain text that starts like a close
+        // marker but is not a valid structure marker.
+        let text = "<:tool:Bash call:>\n<:/ not a marker\n<:tool:Read call:>";
+        let (lines, _) = super::content_layout(area, text, ContentViewMode::Reading);
+        let bash = displayed_line_of(&lines, "<:tool:Bash call:>");
+        let fake_close = displayed_line_of(&lines, "<:/ not a marker");
+        let read = displayed_line_of(&lines, "<:tool:Read call:>");
+        // Only the real tag lines are clickable blocks; the fake close line
+        // extends nothing.
+        assert_eq!(
+            content_structure_block_at(area, text, ContentViewMode::Reading, bash),
+            Some(0)
+        );
+        assert_eq!(
+            content_structure_block_at(area, text, ContentViewMode::Reading, fake_close),
+            None
+        );
+        assert_eq!(
+            content_structure_block_at(area, text, ContentViewMode::Reading, read),
+            Some(1)
+        );
+    }
+
+    #[test]
+    fn structure_block_at_keeps_tool_result_section_inside_the_group() {
+        let area = Rect::new(0, 0, 40, 20);
+        // A merged tool group: call section + result section share one block.
+        let text = "<:tool:Bash call:>\ninput\n<:/tool:Bash call:>\n<:tool:Bash result:>\noutput\n<:/tool:Bash result:>\n<:tool:Read call:>";
+        let (lines, _) = super::content_layout(area, text, ContentViewMode::Reading);
+        let call_tag = displayed_line_of(&lines, "<:tool:Bash call:>");
+        let call_body = displayed_line_of(&lines, "input");
+        let call_close = displayed_line_of(&lines, "<:/tool:Bash call:>");
+        let result_tag = displayed_line_of(&lines, "<:tool:Bash result:>");
+        let result_body = displayed_line_of(&lines, "output");
+        let result_close = displayed_line_of(&lines, "<:/tool:Bash result:>");
+        let next_tag = displayed_line_of(&lines, "<:tool:Read call:>");
+        // Everything from the call tag through the result close is block 0.
+        for line in [
+            call_tag,
+            call_body,
+            call_close,
+            result_tag,
+            result_body,
+            result_close,
+        ] {
+            assert_eq!(
+                content_structure_block_at(area, text, ContentViewMode::Reading, line),
+                Some(0),
+                "line {line} should belong to the merged tool group"
+            );
+        }
+        assert_eq!(
+            content_structure_block_at(area, text, ContentViewMode::Reading, next_tag),
+            Some(1)
+        );
+    }
 }
diff --git a/src/tui/theme.rs b/src/tui/theme.rs
index ee0cb6a6..8bdd5f94 100644
--- a/src/tui/theme.rs
+++ b/src/tui/theme.rs
@@ -50,7 +50,6 @@ pub(crate) struct Theme {
     pub(crate) muted_text: Color,
     pub(crate) key_hint: Color,
     pub(crate) footer: Color,
-    pub(crate) text_primary: Color,
     pub(crate) failure: Color,
     pub(crate) code: Color,
     pub(crate) link: Color,
@@ -177,7 +176,6 @@ impl Theme {
             muted_text: Color::Rgb(203, 213, 225),      // slate-300
             key_hint: Color::Rgb(125, 211, 252),        // sky-300
             footer: Color::Rgb(148, 163, 184),          // slate-400
-            text_primary: Color::Rgb(226, 232, 240),    // slate-200
             failure: Color::Rgb(248, 113, 113),         // red-400
             code: Color::Rgb(148, 163, 184),            // slate-400
             link: Color::Rgb(125, 211, 252),            // sky-300
@@ -208,7 +206,6 @@ impl Theme {
             muted_text: Color::Rgb(100, 116, 139),     // slate-500
             key_hint: Color::Rgb(3, 105, 161),         // sky-700
             footer: Color::Rgb(71, 85, 105),           // slate-600
-            text_primary: Color::Rgb(30, 41, 59),      // slate-800
             failure: Color::Rgb(220, 38, 38),          // red-600
             code: Color::Rgb(71, 85, 105),             // slate-600
             link: Color::Rgb(3, 105, 161),             // sky-700
@@ -241,7 +238,6 @@ impl Theme {
             muted_text: Color::Gray,
             key_hint: Color::Cyan,
             footer: Color::Gray,
-            text_primary: Color::Gray,
             failure: Color::Red,
             code: Color::Gray,
             link: Color::Blue,
@@ -275,7 +271,6 @@ impl Theme {
             muted_text: Color::DarkGray,
             key_hint: Color::Blue,
             footer: Color::DarkGray,
-            text_primary: Color::Black,
             failure: Color::Red,
             code: Color::DarkGray,
             link: Color::Blue,
@@ -454,11 +449,6 @@ pub(crate) fn footer_style() -> Style {
     Style::default().fg(ACTIVE.get().footer)
 }
 
-/// Primary content text (session titles, …).
-pub(crate) fn text_primary() -> Color {
-    ACTIVE.get().text_primary
-}
-
 /// Help / hint descriptions.
 pub(crate) fn help_text() -> Color {
     ACTIVE.get().muted_text
@@ -560,7 +550,6 @@ mod tests {
     fn ansi_light_uses_darker_foregrounds_for_light_backgrounds() {
         let dark = Theme::ansi();
         let light = Theme::ansi_light();
-        assert_ne!(light.text_primary, dark.text_primary);
         assert_ne!(light.title_active, dark.title_active);
         // These ANSI colors can wash out against a light default background.
         let assert_dark_foreground = |name: &str, color: Color| {
@@ -583,7 +572,6 @@ mod tests {
             );
         };
         for (name, color) in [
-            ("text", light.text_primary),
             ("title", light.title_active),
             ("footer", light.footer),
             ("muted text", light.muted_text),
diff --git a/src/tui/workspace/mod.rs b/src/tui/workspace/mod.rs
index b6a1fd03..35f13abe 100644
--- a/src/tui/workspace/mod.rs
+++ b/src/tui/workspace/mod.rs
@@ -13,6 +13,7 @@ pub(crate) use render::*;
 // Dual-pane + content text surface for browse.
 pub(crate) use crate::tui::content::io::{
     search_match_half, ContentIoFocus, ContentIoFrame, ContentIoTexts, ContentScrolls,
+    ExpandedBlocks,
 };
 pub(crate) use crate::tui::content::text::{workspace_content_io_texts, workspace_content_text};
 
diff --git a/src/tui/workspace/model.rs b/src/tui/workspace/model.rs
index b1c73ebe..ebfbec5e 100644
--- a/src/tui/workspace/model.rs
+++ b/src/tui/workspace/model.rs
@@ -8,7 +8,9 @@ use std::collections::HashSet;
 use std::time::SystemTime;
 
 use crate::commands::select::CommandSelection;
-use crate::tui::content::io::{ContentIoFocus, ContentIoFrame, ContentIoTexts, ContentScrolls};
+use crate::tui::content::io::{
+    ContentIoFocus, ContentIoFrame, ContentIoTexts, ContentScrolls, ExpandedBlocks,
+};
 use crate::tui::content::text::{content_io_from_record, structured_part_text};
 use crate::tui::content::view::{ContentSelection, ContentViewMode};
 use crate::tui::search::WorkspaceSearchScope;
@@ -225,14 +227,17 @@ impl WorkspaceDialogue {
     }
 
     pub(crate) fn content_text(&self, mode: ContentViewMode, target: Option<WorkAt>) -> String {
-        self.content_io_texts(mode, target).join_displayed()
+        self.content_io_texts(mode, target, &ExpandedBlocks::default())
+            .join_displayed()
     }
 
-    /// Input / Output bodies for the dual content panes (no section headers).
+    /// Input / Output bodies for the dual content panes with per-block
+    /// expansion (read mode shows full blocks for the listed indices).
     pub(crate) fn content_io_texts(
         &self,
         mode: ContentViewMode,
         target: Option<WorkAt>,
+        expanded: &ExpandedBlocks,
     ) -> ContentIoTexts {
         if let Some(target @ WorkAt::Part(_)) = target {
             let text = match mode {
@@ -279,7 +284,7 @@ impl WorkspaceDialogue {
             };
         }
         let reading = matches!(mode, ContentViewMode::Reading);
-        content_io_from_record(record, reading)
+        content_io_from_record(record, reading, expanded)
     }
 
     pub(crate) fn content_ref(&self, target: Option<WorkAt>) -> Option<WorkRef> {
@@ -398,6 +403,8 @@ pub(crate) struct WorkspaceView<'a> {
     pub(crate) line_filter_error: Option<&'a str>,
     pub(crate) fullscreen: Option<WorkspaceFocus>,
     pub(crate) content_selection: Option<ContentSelection>,
+    /// Last clicked structure block per half, highlighted like a list row.
+    pub(crate) content_active_block: Option<(ContentIoFocus, usize)>,
     /// Dual IO layout + display texts, computed once per redraw by the picker
     /// and shared with the renderer (no per-frame duplicate layout).
     pub(crate) content_frame: &'a ContentIoFrame,
diff --git a/src/tui/workspace/render.rs b/src/tui/workspace/render.rs
index 671001be..89971998 100644
--- a/src/tui/workspace/render.rs
+++ b/src/tui/workspace/render.rs
@@ -118,6 +118,9 @@ pub(crate) fn render_workspace(frame: &mut Frame, view: WorkspaceView<'_>) {
             view.content_mode,
             content_selection_for_half(view.content_selection, view.content_io_focus, half),
             content_search,
+            view.content_active_block
+                .filter(|(focus, _)| *focus == half)
+                .map(|(_, block)| block),
         );
     }
 
@@ -361,11 +364,7 @@ fn session_row_line(
             .fg(choice.source.color())
             .add_modifier(Modifier::BOLD),
     ));
-    spans.extend(highlight_spans(
-        &title,
-        highlight,
-        Style::default().fg(theme::text_primary()),
-    ));
+    spans.extend(highlight_spans(&title, highlight, Style::default()));
     if body_failed {
         spans.push(Span::styled(" [!]", Style::default().fg(theme::failure())));
     }
@@ -795,7 +794,7 @@ fn render_dialogue_list(
                 ListItem::new(Line::from(highlight_spans(
                     &line,
                     highlight,
-                    Style::default().fg(theme::help_text()),
+                    Style::default(),
                 )))
             }
         })
@@ -856,6 +855,7 @@ fn render_content_panel(
     mode: ContentViewMode,
     selection: Option<ContentSelection>,
     search_regex: Option<&Regex>,
+    active_block: Option<usize>,
 ) {
     render_content_view(
         frame,
@@ -867,6 +867,7 @@ fn render_content_panel(
             search_regex,
             mode,
             selection,
+            active_block,
         },
     );
 }
@@ -971,4 +972,32 @@ mod tests {
         // A line wider than the box clamps the column to the right edge.
         assert_eq!(cursor_for("1\n0123456789abcdefghij"), (15, 3));
     }
+
+    #[test]
+    fn session_row_body_uses_default_foreground() {
+        use super::session_row_line;
+        use crate::tui::workspace::model::{WorkspaceSession, WorkspaceSource};
+        use ratatui::prelude::Style;
+        use sivtr_core::ai::AgentProvider;
+        use std::time::SystemTime;
+
+        let session = WorkspaceSession {
+            source: WorkspaceSource::agent(AgentProvider::Codex),
+            session_id: "abc123".to_string(),
+            modified: SystemTime::UNIX_EPOCH,
+            title: "title".to_string(),
+            search_title: "title".to_string(),
+            records: Vec::new(),
+            body_loaded: false,
+        };
+        let line = session_row_line(&session, false, true, Style::default(), None, false);
+        // Non-selected session rows paint body text with the terminal default
+        // foreground, matching dialogue rows and the content pane.
+        let title_span = line
+            .spans
+            .iter()
+            .find(|span| span.content == "title")
+            .expect("title span");
+        assert_eq!(title_span.style.fg, None);
+    }
 }
diff --git a/src/tui/workspace/tests.rs b/src/tui/workspace/tests.rs
index f9ab4db0..24730ecc 100644
--- a/src/tui/workspace/tests.rs
+++ b/src/tui/workspace/tests.rs
@@ -9,6 +9,7 @@ use super::render::{
     content_title, current_content_dialogue, current_content_ref, line_filter_prompt_text,
     search_box_body, search_box_title,
 };
+use crate::tui::content::io::ExpandedBlocks;
 use crate::tui::content::text::{workspace_content_io_texts, workspace_content_text};
 use crate::tui::content::view::ContentViewMode;
 use crate::tui::search::WorkspaceSearchScope;
@@ -90,6 +91,7 @@ fn content_preview_text_preserves_raw_text_without_line_number_prefixes() {
         0,
         ContentViewMode::Raw,
         None,
+        &ExpandedBlocks::default(),
     );
     let text = workspace_content_text(&[dialogue], &[false], 0, ContentViewMode::Raw, None);
     assert_eq!(io.input.trim(), "alpha");
@@ -198,11 +200,13 @@ fn reading_mode_folds_structure_and_raw_expands() {
         0,
         ContentViewMode::Reading,
         None,
+        &ExpandedBlocks::default(),
     );
     assert!(reading_io.input.contains("question"));
-    // Reading folds each structure part to its tag line; payloads are dropped.
+    // Reading folds each structure group to its tag line; the call+result
+    // pair collapses to one tag, so the result tag and payload are dropped.
     assert!(reading_io.output.contains("<:tool:Bash call:>"));
-    assert!(reading_io.output.contains("<:tool:Bash result:>"));
+    assert!(!reading_io.output.contains("<:tool:Bash result:>"));
     assert!(reading_io.output.contains("answer"));
     assert!(!reading.contains("cargo test"));
     assert!(!reading.contains("ok"));
@@ -217,6 +221,7 @@ fn reading_mode_folds_structure_and_raw_expands() {
         0,
         ContentViewMode::Raw,
         None,
+        &ExpandedBlocks::default(),
     );
     let raw = workspace_content_text(&[dialogue], &[false], 0, ContentViewMode::Raw, None);
     assert!(raw_io.input.contains("question"));
@@ -285,6 +290,7 @@ fn reading_mode_collapses_adjacent_structure_runs() {
         0,
         ContentViewMode::Reading,
         None,
+        &ExpandedBlocks::default(),
     );
     let reading = workspace_content_text(
         std::slice::from_ref(&dialogue),
@@ -358,6 +364,7 @@ fn reading_mode_counts_identical_structure_markers_regardless_of_order() {
         0,
         ContentViewMode::Reading,
         None,
+        &ExpandedBlocks::default(),
     );
     // Every structure part keeps its own tag line, in call order.
     assert!(reading_io.input.contains("middle note"));
@@ -421,6 +428,7 @@ fn reading_mode_keeps_structure_runs_in_call_order() {
         0,
         ContentViewMode::Reading,
         None,
+        &ExpandedBlocks::default(),
     );
     // Tags sit between the assistant chunks, matching the call order.
     let output = &reading_io.output;