From d03328d535881e4efe16c168753c9c5c1b400e19 Mon Sep 17 00:00:00 2001
From: Ariestar <1941137088@qq.com>
Date: Thu, 13 Aug 2026 15:25:23 +0800
Subject: [PATCH 01/10] feat(tui): click a structure tag to expand its block in
 read mode

Read mode folds every structure block to its <:...:> tag line; clicking
a tag expands that block to its full payload (grok-build style), and
clicking the tag again collapses it. Raw mode always shows full blocks
and ignores the expand state. Tags keep the same gray style in both
modes.

Per-half expansion state lives in the picker and resets when the shown
dialogue, target, or selection changes; line counts, scrolling, and
visual selection stay consistent because expansion is applied while the
display text is built.
---
 src/commands/browse/help.rs   |  11 +-
 src/commands/browse/panes.rs  |   8 +-
 src/commands/browse/picker.rs |  41 +++++++-
 src/tui/content/io.rs         |  30 ++++++
 src/tui/content/text.rs       | 188 +++++++++++++++++++++++++++++-----
 src/tui/workspace/mod.rs      |   5 +-
 src/tui/workspace/model.rs    |  21 +++-
 7 files changed, 260 insertions(+), 44 deletions(-)

diff --git a/src/commands/browse/help.rs b/src/commands/browse/help.rs
index d2d9a107..deaf40bb 100644
--- a/src/commands/browse/help.rs
+++ b/src/commands/browse/help.rs
@@ -8,9 +8,10 @@ use ratatui::widgets::ListState;
 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,
+    can_open_dialogue_vim, selected_index, workspace_content_io_texts_expanded,
+    workspace_content_text, 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,
@@ -246,12 +248,13 @@ pub(super) fn apply_workspace_help_action(
                 *focus,
                 *fullscreen,
             );
-            let io = workspace_content_io_texts(
+            let io = workspace_content_io_texts_expanded(
                 dialogues,
                 selected_dialogues,
                 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/panes.rs b/src/commands/browse/panes.rs
index 0c3dbf8f..e99fe06b 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_expanded, 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: ExpandedBlocks,
 }
 
 /// Tracks layout line counts for Input / Output halves separately.
@@ -438,12 +439,13 @@ impl ContentPane {
 
     /// Build texts + dynamic layout metrics for this frame.
     pub fn ensure(&mut self, ctx: ContentCtx<'_>) -> ContentIoTexts {
-        let texts = workspace_content_io_texts(
+        let texts = workspace_content_io_texts_expanded(
             ctx.dialogues,
             ctx.selected_dialogues,
             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..c8aed839 100644
--- a/src/commands/browse/picker.rs
+++ b/src/commands/browse/picker.rs
@@ -6,7 +6,7 @@ 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, ContentViewMode};
 use crate::tui::search::{
     workspace_search_fingerprint, workspace_search_has_query, workspace_search_scope,
     WorkspaceSearchIndex, WorkspaceSearchOutput,
@@ -14,9 +14,10 @@ use crate::tui::search::{
 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,
+    structure_block_index, workspace_help_entries, workspace_hit_test, workspace_layout,
+    ContentIoFocus, ContentIoFrame, ContentScrolls, ExpandedBlocks, WorkspaceDialogue,
+    WorkspaceFocus, WorkspacePickedContent, WorkspaceSearchView, WorkspaceSession, WorkspaceSource,
+    WorkspaceView,
 };
 
 use super::content::{
@@ -80,6 +81,8 @@ 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;
     let mut show_help = false;
     let mut show_search = false;
     let mut search_query = String::new();
@@ -324,6 +327,13 @@ pub(crate) fn run(
             if let Some((half, _)) = pending_half {
                 content_io_focus = half;
             }
+            // Expansion indices are per-dialogue; reset when the shown
+            // dialogue, target, or selection changes.
+            let expand_key = (dialogue_idx, active_content_at, selected_dialogues.clone());
+            if expanded_key.as_ref() != Some(&expand_key) {
+                expanded_blocks.clear();
+                expanded_key = Some(expand_key);
+            }
             content_frame = ContentIoFrame::build(
                 layout.content,
                 content_pane.ensure(ContentCtx {
@@ -334,6 +344,7 @@ pub(crate) fn run(
                     target: active_content_at,
                     area: layout.content,
                     io_focus: content_io_focus,
+                    expanded: expanded_blocks.clone(),
                 }),
                 content_mode,
                 content_io_focus,
@@ -650,6 +661,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 +775,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 +870,26 @@ 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,
+                                ) {
+                                    if let Some(block) =
+                                        structure_block_index(active.text, position.line)
+                                    {
+                                        expanded_blocks.toggle(half, block);
+                                        redraw = true;
+                                        continue;
+                                    }
+                                }
+                            }
                         }
                         if handle_content_mouse_select(
                             &mut visual_select_mode,
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/text.rs b/src/tui/content/text.rs
index aeac50e7..2fb8932b 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_expanded(
+    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,20 +34,24 @@ 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 {
+    for part in &parts {
         if part.kind().is_structure() {
-            chunks.push(structure_fold_label(part));
+            let idx = block;
+            block += 1;
+            // Raw mode always shows full blocks; read mode folds to the tag
+            // unless the block was expanded.
+            let show_full = if reading {
+                expanded.contains(&idx)
+            } else {
+                true
+            };
+            if show_full {
+                chunks.push(sivtr_core::record::format_work_part(part));
+            } else {
+                chunks.push(structure_fold_label(part));
+            }
         } else {
             chunks.push(part.text().into_owned());
         }
@@ -43,14 +59,6 @@ fn structured_parts_text(parts: &[&sivtr_core::record::WorkPart]) -> String {
     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")
-}
-
 pub(crate) fn structured_part_text(part: &sivtr_core::record::WorkPart) -> String {
     if part.kind().is_structure() {
         structure_fold_label(part)
@@ -77,13 +85,32 @@ pub(crate) fn workspace_content_text(
         .join_displayed()
 }
 
-/// Input / Output bodies for the dual content panes.
+/// Input / Output bodies for the dual content panes (default expand state).
 pub(crate) fn workspace_content_io_texts(
     dialogues: &[WorkspaceDialogue],
     selected_dialogues: &[bool],
     highlighted_idx: usize,
     mode: ContentViewMode,
     target: Option<WorkAt>,
+) -> ContentIoTexts {
+    workspace_content_io_texts_expanded(
+        dialogues,
+        selected_dialogues,
+        highlighted_idx,
+        mode,
+        target,
+        &ExpandedBlocks::default(),
+    )
+}
+
+/// Input / Output bodies for the dual content panes with per-block expansion.
+pub(crate) fn workspace_content_io_texts_expanded(
+    dialogues: &[WorkspaceDialogue],
+    selected_dialogues: &[bool],
+    highlighted_idx: usize,
+    mode: ContentViewMode,
+    target: Option<WorkAt>,
+    expanded: &ExpandedBlocks,
 ) -> ContentIoTexts {
     if dialogues.is_empty() {
         return ContentIoTexts {
@@ -101,7 +128,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_expanded(mode, target, expanded))
             .unwrap_or_else(|| ContentIoTexts {
                 input: "<empty>".to_string(),
                 output: String::new(),
@@ -115,7 +142,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_expanded(mode, None, expanded);
         if !io.input.trim().is_empty() {
             input.push(io.input);
         }
@@ -136,3 +163,108 @@ pub(crate) fn workspace_content_io_texts(
         },
     }
 }
+
+/// Index of the structure block whose open marker sits on `line` of the
+/// displayed text, if any. Every block contributes exactly one open marker
+/// line — collapsed (tag only) or expanded — so the marker ordinal is the
+/// block index.
+pub(crate) fn structure_block_index(text: &str, line: usize) -> Option<usize> {
+    let mut block = 0usize;
+    for (idx, text_line) in text.lines().enumerate() {
+        if is_structure_open_marker(text_line) {
+            if idx == line {
+                return Some(block);
+            }
+            block += 1;
+        }
+    }
+    None
+}
+
+fn is_structure_open_marker(line: &str) -> bool {
+    line.starts_with("<:") && !line.starts_with("<:/")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{content_io_from_record_expanded, structure_block_index};
+    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 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_expanded(&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_expanded(&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_expanded(&rec, false, &expanded);
+        assert!(io.output.contains("<:tool:Bash call:>"));
+        assert!(io.output.contains("ls"));
+        assert!(io.output.contains("<:/tool:Bash call:>"));
+    }
+
+    #[test]
+    fn block_index_maps_displayed_markers() {
+        let text = "<:tool:A call:>\nbody\n\n<:tool:B call:>";
+        assert_eq!(structure_block_index(text, 0), Some(0));
+        assert_eq!(structure_block_index(text, 3), Some(1));
+        assert_eq!(structure_block_index(text, 1), None);
+    }
+}
diff --git a/src/tui/workspace/mod.rs b/src/tui/workspace/mod.rs
index b6a1fd03..051425c4 100644
--- a/src/tui/workspace/mod.rs
+++ b/src/tui/workspace/mod.rs
@@ -13,8 +13,11 @@ 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::{
+    structure_block_index, workspace_content_io_texts_expanded, workspace_content_text,
 };
-pub(crate) use crate::tui::content::text::{workspace_content_io_texts, workspace_content_text};
 
 #[cfg(test)]
 mod tests;
diff --git a/src/tui/workspace/model.rs b/src/tui/workspace/model.rs
index b1c73ebe..75faf582 100644
--- a/src/tui/workspace/model.rs
+++ b/src/tui/workspace/model.rs
@@ -8,8 +8,10 @@ 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::text::{content_io_from_record, structured_part_text};
+use crate::tui::content::io::{
+    ContentIoFocus, ContentIoFrame, ContentIoTexts, ContentScrolls, ExpandedBlocks,
+};
+use crate::tui::content::text::{content_io_from_record_expanded, structured_part_text};
 use crate::tui::content::view::{ContentSelection, ContentViewMode};
 use crate::tui::search::WorkspaceSearchScope;
 use crate::tui::theme;
@@ -228,11 +230,22 @@ impl WorkspaceDialogue {
         self.content_io_texts(mode, target).join_displayed()
     }
 
-    /// Input / Output bodies for the dual content panes (no section headers).
+    /// Input / Output bodies for the dual content panes (default expand state).
     pub(crate) fn content_io_texts(
         &self,
         mode: ContentViewMode,
         target: Option<WorkAt>,
+    ) -> ContentIoTexts {
+        self.content_io_texts_expanded(mode, target, &ExpandedBlocks::default())
+    }
+
+    /// 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_expanded(
+        &self,
+        mode: ContentViewMode,
+        target: Option<WorkAt>,
+        expanded: &ExpandedBlocks,
     ) -> ContentIoTexts {
         if let Some(target @ WorkAt::Part(_)) = target {
             let text = match mode {
@@ -279,7 +292,7 @@ impl WorkspaceDialogue {
             };
         }
         let reading = matches!(mode, ContentViewMode::Reading);
-        content_io_from_record(record, reading)
+        content_io_from_record_expanded(record, reading, expanded)
     }
 
     pub(crate) fn content_ref(&self, target: Option<WorkAt>) -> Option<WorkRef> {

From 399592c3fe928e7ddd9b161c6d8e1e06934acf4d Mon Sep 17 00:00:00 2001
From: Ariestar <1941137088@qq.com>
Date: Thu, 13 Aug 2026 15:37:13 +0800
Subject: [PATCH 02/10] refactor(tui): merge _expanded wrappers into single
 io-texts functions

content_io_from_record / content_io_texts / workspace_content_io_texts now
take expanded: &ExpandedBlocks directly instead of a default-state wrapper
pair; ContentCtx borrows the expansion state per frame instead of cloning.
Shared is_structure_marker() helper replaces inline starts_with checks.
---
 src/commands/browse/help.rs   |  8 +++----
 src/commands/browse/panes.rs  | 10 ++++----
 src/commands/browse/picker.rs |  2 +-
 src/tui/content/markdown.rs   |  2 +-
 src/tui/content/text.rs       | 45 +++++++++++++----------------------
 src/tui/content/view.rs       |  2 +-
 src/tui/workspace/mod.rs      |  2 +-
 src/tui/workspace/model.rs    | 18 ++++----------
 src/tui/workspace/tests.rs    |  7 ++++++
 9 files changed, 42 insertions(+), 54 deletions(-)

diff --git a/src/commands/browse/help.rs b/src/commands/browse/help.rs
index deaf40bb..ebf5cbbe 100644
--- a/src/commands/browse/help.rs
+++ b/src/commands/browse/help.rs
@@ -8,9 +8,9 @@ use ratatui::widgets::ListState;
 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_expanded,
-    workspace_content_text, workspace_layout, ContentIoFocus, ContentIoFrame, ContentScrolls,
-    ExpandedBlocks, WorkspaceDialogue, WorkspaceFocus, WorkspaceHelpAction, WorkspacePickedContent,
+    can_open_dialogue_vim, selected_index, workspace_content_io_texts, workspace_content_text,
+    workspace_layout, ContentIoFocus, ContentIoFrame, ContentScrolls, ExpandedBlocks,
+    WorkspaceDialogue, WorkspaceFocus, WorkspaceHelpAction, WorkspacePickedContent,
     WorkspaceSession, WorkspaceSource,
 };
 use sivtr_core::record::WorkAt;
@@ -248,7 +248,7 @@ pub(super) fn apply_workspace_help_action(
                 *focus,
                 *fullscreen,
             );
-            let io = workspace_content_io_texts_expanded(
+            let io = workspace_content_io_texts(
                 dialogues,
                 selected_dialogues,
                 dialogue_idx,
diff --git a/src/commands/browse/panes.rs b/src/commands/browse/panes.rs
index e99fe06b..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_expanded, ContentIoFocus, ContentIoFrame, ContentIoTexts,
-    ExpandedBlocks, 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,7 +419,7 @@ pub struct ContentCtx<'a> {
     pub target: Option<WorkAt>,
     pub area: ratatui::layout::Rect,
     pub io_focus: ContentIoFocus,
-    pub expanded: ExpandedBlocks,
+    pub expanded: &'a ExpandedBlocks,
 }
 
 /// Tracks layout line counts for Input / Output halves separately.
@@ -439,13 +439,13 @@ impl ContentPane {
 
     /// Build texts + dynamic layout metrics for this frame.
     pub fn ensure(&mut self, ctx: ContentCtx<'_>) -> ContentIoTexts {
-        let texts = workspace_content_io_texts_expanded(
+        let texts = workspace_content_io_texts(
             ctx.dialogues,
             ctx.selected_dialogues,
             ctx.highlighted_idx,
             ctx.mode,
             ctx.target,
-            &ctx.expanded,
+            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 c8aed839..03ac463a 100644
--- a/src/commands/browse/picker.rs
+++ b/src/commands/browse/picker.rs
@@ -344,7 +344,7 @@ pub(crate) fn run(
                     target: active_content_at,
                     area: layout.content,
                     io_focus: content_io_focus,
-                    expanded: expanded_blocks.clone(),
+                    expanded: &expanded_blocks,
                 }),
                 content_mode,
                 content_io_focus,
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 2fb8932b..ee2ac371 100644
--- a/src/tui/content/text.rs
+++ b/src/tui/content/text.rs
@@ -9,7 +9,7 @@ use crate::tui::workspace::model::WorkspaceDialogue;
 /// 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_expanded(
+pub(crate) fn content_io_from_record(
     record: &WorkRecord,
     reading: bool,
     expanded: &ExpandedBlocks,
@@ -42,12 +42,7 @@ fn io_body_text(
             block += 1;
             // Raw mode always shows full blocks; read mode folds to the tag
             // unless the block was expanded.
-            let show_full = if reading {
-                expanded.contains(&idx)
-            } else {
-                true
-            };
-            if show_full {
+            if !reading || expanded.contains(&idx) {
                 chunks.push(sivtr_core::record::format_work_part(part));
             } else {
                 chunks.push(structure_fold_label(part));
@@ -81,19 +76,7 @@ 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()
-}
-
-/// Input / Output bodies for the dual content panes (default expand state).
-pub(crate) fn workspace_content_io_texts(
-    dialogues: &[WorkspaceDialogue],
-    selected_dialogues: &[bool],
-    highlighted_idx: usize,
-    mode: ContentViewMode,
-    target: Option<WorkAt>,
-) -> ContentIoTexts {
-    workspace_content_io_texts_expanded(
+    workspace_content_io_texts(
         dialogues,
         selected_dialogues,
         highlighted_idx,
@@ -101,10 +84,11 @@ pub(crate) fn workspace_content_io_texts(
         target,
         &ExpandedBlocks::default(),
     )
+    .join_displayed()
 }
 
 /// Input / Output bodies for the dual content panes with per-block expansion.
-pub(crate) fn workspace_content_io_texts_expanded(
+pub(crate) fn workspace_content_io_texts(
     dialogues: &[WorkspaceDialogue],
     selected_dialogues: &[bool],
     highlighted_idx: usize,
@@ -128,7 +112,7 @@ pub(crate) fn workspace_content_io_texts_expanded(
     if selected.is_empty() {
         return dialogues
             .get(highlighted_idx)
-            .map(|dialogue| dialogue.content_io_texts_expanded(mode, target, expanded))
+            .map(|dialogue| dialogue.content_io_texts(mode, target, expanded))
             .unwrap_or_else(|| ContentIoTexts {
                 input: "<empty>".to_string(),
                 output: String::new(),
@@ -142,7 +126,7 @@ pub(crate) fn workspace_content_io_texts_expanded(
         let Some(dialogue) = dialogues.get(dialogue_idx) else {
             continue;
         };
-        let io = dialogue.content_io_texts_expanded(mode, None, expanded);
+        let io = dialogue.content_io_texts(mode, None, expanded);
         if !io.input.trim().is_empty() {
             input.push(io.input);
         }
@@ -181,13 +165,18 @@ pub(crate) fn structure_block_index(text: &str, line: usize) -> Option<usize> {
     None
 }
 
+/// A line that opens or closes a structure block (`<:tool:…:>` / `<:/…:>`).
+pub(crate) fn is_structure_marker(line: &str) -> bool {
+    line.starts_with("<:")
+}
+
 fn is_structure_open_marker(line: &str) -> bool {
-    line.starts_with("<:") && !line.starts_with("<:/")
+    is_structure_marker(line) && !line.starts_with("<:/")
 }
 
 #[cfg(test)]
 mod tests {
-    use super::{content_io_from_record_expanded, structure_block_index};
+    use super::{content_io_from_record, structure_block_index};
     use crate::tui::content::io::{ContentIoFocus, ExpandedBlocks};
     use sivtr_core::ai::AgentProvider;
     use sivtr_core::record::{WorkPart, WorkPartData, WorkRecord, WorkRef};
@@ -232,7 +221,7 @@ mod tests {
             tool_part(1, "Bash", "ls"),
             tool_part(2, "Read", "file"),
         ]);
-        let io = content_io_from_record_expanded(&rec, true, &ExpandedBlocks::default());
+        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:>"));
@@ -241,7 +230,7 @@ mod tests {
 
         let mut expanded = ExpandedBlocks::default();
         expanded.toggle(ContentIoFocus::Output, 1);
-        let io = content_io_from_record_expanded(&rec, true, &expanded);
+        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:>"));
@@ -254,7 +243,7 @@ mod tests {
         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_expanded(&rec, false, &expanded);
+        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:>"));
diff --git a/src/tui/content/view.rs b/src/tui/content/view.rs
index 3b69b1d3..a53a33f7 100644
--- a/src/tui/content/view.rs
+++ b/src/tui/content/view.rs
@@ -414,7 +414,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()
diff --git a/src/tui/workspace/mod.rs b/src/tui/workspace/mod.rs
index 051425c4..9a052d87 100644
--- a/src/tui/workspace/mod.rs
+++ b/src/tui/workspace/mod.rs
@@ -16,7 +16,7 @@ pub(crate) use crate::tui::content::io::{
     ExpandedBlocks,
 };
 pub(crate) use crate::tui::content::text::{
-    structure_block_index, workspace_content_io_texts_expanded, workspace_content_text,
+    structure_block_index, workspace_content_io_texts, workspace_content_text,
 };
 
 #[cfg(test)]
diff --git a/src/tui/workspace/model.rs b/src/tui/workspace/model.rs
index 75faf582..552bb0f3 100644
--- a/src/tui/workspace/model.rs
+++ b/src/tui/workspace/model.rs
@@ -11,7 +11,7 @@ use crate::commands::select::CommandSelection;
 use crate::tui::content::io::{
     ContentIoFocus, ContentIoFrame, ContentIoTexts, ContentScrolls, ExpandedBlocks,
 };
-use crate::tui::content::text::{content_io_from_record_expanded, structured_part_text};
+use crate::tui::content::text::{content_io_from_record, structured_part_text};
 use crate::tui::content::view::{ContentSelection, ContentViewMode};
 use crate::tui::search::WorkspaceSearchScope;
 use crate::tui::theme;
@@ -227,21 +227,13 @@ impl WorkspaceDialogue {
     }
 
     pub(crate) fn content_text(&self, mode: ContentViewMode, target: Option<WorkAt>) -> String {
-        self.content_io_texts(mode, target).join_displayed()
-    }
-
-    /// Input / Output bodies for the dual content panes (default expand state).
-    pub(crate) fn content_io_texts(
-        &self,
-        mode: ContentViewMode,
-        target: Option<WorkAt>,
-    ) -> ContentIoTexts {
-        self.content_io_texts_expanded(mode, target, &ExpandedBlocks::default())
+        self.content_io_texts(mode, target, &ExpandedBlocks::default())
+            .join_displayed()
     }
 
     /// 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_expanded(
+    pub(crate) fn content_io_texts(
         &self,
         mode: ContentViewMode,
         target: Option<WorkAt>,
@@ -292,7 +284,7 @@ impl WorkspaceDialogue {
             };
         }
         let reading = matches!(mode, ContentViewMode::Reading);
-        content_io_from_record_expanded(record, reading, expanded)
+        content_io_from_record(record, reading, expanded)
     }
 
     pub(crate) fn content_ref(&self, target: Option<WorkAt>) -> Option<WorkRef> {
diff --git a/src/tui/workspace/tests.rs b/src/tui/workspace/tests.rs
index f9ab4db0..d3168e99 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,6 +200,7 @@ 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.
@@ -217,6 +220,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 +289,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 +363,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 +427,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;

From 455dee8ab8195c445b9f26281d549cfb2d6a72a3 Mon Sep 17 00:00:00 2001
From: Ariestar <1941137088@qq.com>
Date: Thu, 13 Aug 2026 16:14:43 +0800
Subject: [PATCH 03/10] fix(tui): unify body foreground across lists and
 content

- session row titles drop text_primary, unselected dialogue rows drop
  muted_text: both now use the terminal default foreground like the
  content pane body text
- remove the now-unused text_primary palette field
- regression test locks the session row body style to default
---
 src/tui/theme.rs            | 12 ------------
 src/tui/workspace/render.rs | 36 ++++++++++++++++++++++++++++++------
 2 files changed, 30 insertions(+), 18 deletions(-)

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/render.rs b/src/tui/workspace/render.rs
index 671001be..2c30a0f1 100644
--- a/src/tui/workspace/render.rs
+++ b/src/tui/workspace/render.rs
@@ -361,11 +361,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 +791,7 @@ fn render_dialogue_list(
                 ListItem::new(Line::from(highlight_spans(
                     &line,
                     highlight,
-                    Style::default().fg(theme::help_text()),
+                    Style::default(),
                 )))
             }
         })
@@ -971,4 +967,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);
+    }
 }

From db0809221a053ae65921e87051fc64d4a7f554fe Mon Sep 17 00:00:00 2001
From: Ariestar <1941137088@qq.com>
Date: Thu, 13 Aug 2026 16:26:05 +0800
Subject: [PATCH 04/10] fix(tui): wheel scroll and click hit-test offsets

- mouse wheel advances lists and content one line per notch instead of
  three, matching grok build's smooth view scrolling
- list clicks add the panel's scroll offset, so clicking a row in a
  scrolled panel no longer jumps the selection back to the top
- content click-to-expand walks the wrapped displayed lines instead of
  raw text lines, so scrolled/wrapped content no longer toggles the
  wrong structure block
---
 src/commands/browse/nav.rs    | 33 +++++++++++++--
 src/commands/browse/picker.rs | 39 +++++++++++-------
 src/commands/browse/visual.rs |  2 +-
 src/tui/content/text.rs       | 31 +--------------
 src/tui/content/view.rs       | 75 +++++++++++++++++++++++++++++++++--
 src/tui/workspace/mod.rs      |  4 +-
 6 files changed, 130 insertions(+), 54 deletions(-)

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/picker.rs b/src/commands/browse/picker.rs
index 03ac463a..c24867b3 100644
--- a/src/commands/browse/picker.rs
+++ b/src/commands/browse/picker.rs
@@ -6,7 +6,9 @@ use ratatui::widgets::ListState;
 use std::collections::HashSet;
 use std::path::PathBuf;
 
-use crate::tui::content::view::{content_link_at, content_position_at, ContentViewMode};
+use crate::tui::content::view::{
+    content_link_at, content_position_at, content_structure_block_at, ContentViewMode,
+};
 use crate::tui::search::{
     workspace_search_fingerprint, workspace_search_has_query, workspace_search_scope,
     WorkspaceSearchIndex, WorkspaceSearchOutput,
@@ -14,10 +16,9 @@ use crate::tui::search::{
 use crate::tui::terminal::read_interaction;
 use crate::tui::workspace::{
     help_action_for_key, panel_inner_rows, render_workspace, search_match_half, selected_index,
-    structure_block_index, workspace_help_entries, workspace_hit_test, workspace_layout,
-    ContentIoFocus, ContentIoFrame, ContentScrolls, ExpandedBlocks, WorkspaceDialogue,
-    WorkspaceFocus, WorkspacePickedContent, WorkspaceSearchView, WorkspaceSession, WorkspaceSource,
-    WorkspaceView,
+    workspace_help_entries, workspace_hit_test, workspace_layout, ContentIoFocus, ContentIoFrame,
+    ContentScrolls, ExpandedBlocks, WorkspaceDialogue, WorkspaceFocus, WorkspacePickedContent,
+    WorkspaceSearchView, WorkspaceSession, WorkspaceSource, WorkspaceView,
 };
 
 use super::content::{
@@ -881,9 +882,12 @@ pub(crate) fn run(
                                     mouse.column,
                                     mouse.row,
                                 ) {
-                                    if let Some(block) =
-                                        structure_block_index(active.text, position.line)
-                                    {
+                                    if let Some(block) = content_structure_block_at(
+                                        active.area,
+                                        active.text,
+                                        content_mode,
+                                        position.line,
+                                    ) {
                                         expanded_blocks.toggle(half, block);
                                         redraw = true;
                                         continue;
@@ -968,14 +972,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(
@@ -989,9 +997,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/text.rs b/src/tui/content/text.rs
index ee2ac371..b657b5d6 100644
--- a/src/tui/content/text.rs
+++ b/src/tui/content/text.rs
@@ -148,35 +148,14 @@ pub(crate) fn workspace_content_io_texts(
     }
 }
 
-/// Index of the structure block whose open marker sits on `line` of the
-/// displayed text, if any. Every block contributes exactly one open marker
-/// line — collapsed (tag only) or expanded — so the marker ordinal is the
-/// block index.
-pub(crate) fn structure_block_index(text: &str, line: usize) -> Option<usize> {
-    let mut block = 0usize;
-    for (idx, text_line) in text.lines().enumerate() {
-        if is_structure_open_marker(text_line) {
-            if idx == line {
-                return Some(block);
-            }
-            block += 1;
-        }
-    }
-    None
-}
-
 /// A line that opens or closes a structure block (`<:tool:…:>` / `<:/…:>`).
 pub(crate) fn is_structure_marker(line: &str) -> bool {
     line.starts_with("<:")
 }
 
-fn is_structure_open_marker(line: &str) -> bool {
-    is_structure_marker(line) && !line.starts_with("<:/")
-}
-
 #[cfg(test)]
 mod tests {
-    use super::{content_io_from_record, structure_block_index};
+    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};
@@ -248,12 +227,4 @@ mod tests {
         assert!(io.output.contains("ls"));
         assert!(io.output.contains("<:/tool:Bash call:>"));
     }
-
-    #[test]
-    fn block_index_maps_displayed_markers() {
-        let text = "<:tool:A call:>\nbody\n\n<:tool:B call:>";
-        assert_eq!(structure_block_index(text, 0), Some(0));
-        assert_eq!(structure_block_index(text, 3), Some(1));
-        assert_eq!(structure_block_index(text, 1), None);
-    }
 }
diff --git a/src/tui/content/view.rs b/src/tui/content/view.rs
index a53a33f7..a31a36ea 100644
--- a/src/tui/content/view.rs
+++ b/src/tui/content/view.rs
@@ -197,6 +197,36 @@ pub(crate) fn content_position_at(
     ))
 }
 
+/// Structure block ordinal for the open-marker line at `line` (a displayed
+/// line index), if any. Walks the wrapped display so scroll/wrap cannot
+/// shift the block mapping.
+pub(crate) fn content_structure_block_at(
+    area: Rect,
+    text: &str,
+    mode: ContentViewMode,
+    line: usize,
+) -> 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 mut block = 0usize;
+    for (idx, content_line) in lines.iter().enumerate() {
+        let joined: String = content_line
+            .line
+            .spans
+            .iter()
+            .map(|span| span.content.as_ref())
+            .collect();
+        if crate::tui::content::text::is_structure_marker(&joined) && !joined.starts_with("<:/") {
+            if idx == line {
+                return Some(block);
+            }
+            block += 1;
+        }
+    }
+    None
+}
+
 pub(crate) fn content_position_in_text_row(
     area: Rect,
     text: &str,
@@ -1159,9 +1189,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;
@@ -1595,4 +1625,43 @@ 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
+        );
+    }
 }
diff --git a/src/tui/workspace/mod.rs b/src/tui/workspace/mod.rs
index 9a052d87..35f13abe 100644
--- a/src/tui/workspace/mod.rs
+++ b/src/tui/workspace/mod.rs
@@ -15,9 +15,7 @@ pub(crate) use crate::tui::content::io::{
     search_match_half, ContentIoFocus, ContentIoFrame, ContentIoTexts, ContentScrolls,
     ExpandedBlocks,
 };
-pub(crate) use crate::tui::content::text::{
-    structure_block_index, workspace_content_io_texts, workspace_content_text,
-};
+pub(crate) use crate::tui::content::text::{workspace_content_io_texts, workspace_content_text};
 
 #[cfg(test)]
 mod tests;

From 36dadbf574d60339715670ccce86edcb3329ffd1 Mon Sep 17 00:00:00 2001
From: Ariestar <1941137088@qq.com>
Date: Thu, 13 Aug 2026 16:58:35 +0800
Subject: [PATCH 05/10] fix(tui): click any part of a structure block to
 collapse it

content_structure_block_at now maps every displayed line in a block's
extent (tag, expanded body, close marker) to that block, so clicking the
expanded text collapses it again. The picker records the block on mouse
down and toggles on release, so a drag still selects text instead of
collapsing the block.
---
 src/commands/browse/picker.rs |  27 ++++++--
 src/tui/content/view.rs       | 117 ++++++++++++++++++++++++++++++----
 2 files changed, 126 insertions(+), 18 deletions(-)

diff --git a/src/commands/browse/picker.rs b/src/commands/browse/picker.rs
index c24867b3..4675fa43 100644
--- a/src/commands/browse/picker.rs
+++ b/src/commands/browse/picker.rs
@@ -84,6 +84,9 @@ pub(crate) fn run(
     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;
     let mut show_help = false;
     let mut show_search = false;
     let mut search_query = String::new();
@@ -333,6 +336,7 @@ pub(crate) fn run(
             let expand_key = (dialogue_idx, active_content_at, selected_dialogues.clone());
             if expanded_key.as_ref() != Some(&expand_key) {
                 expanded_blocks.clear();
+                pending_block_toggle = None;
                 expanded_key = Some(expand_key);
             }
             content_frame = ContentIoFrame::build(
@@ -882,19 +886,23 @@ pub(crate) fn run(
                                     mouse.column,
                                     mouse.row,
                                 ) {
-                                    if let Some(block) = content_structure_block_at(
+                                    // 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,
-                                    ) {
-                                        expanded_blocks.toggle(half, block);
-                                        redraw = true;
-                                        continue;
-                                    }
+                                    )
+                                    .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,
                             mouse.kind,
@@ -912,6 +920,13 @@ 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.
+                            if matches!(mouse.kind, MouseEventKind::Up(MouseButton::Left)) {
+                                if let Some((half, block)) = pending_block_toggle.take() {
+                                    expanded_blocks.toggle(half, block);
+                                    redraw = true;
+                                }
+                            }
                             continue;
                         }
                     } else if visual_select_mode.is_some() {
diff --git a/src/tui/content/view.rs b/src/tui/content/view.rs
index a31a36ea..6400dc7e 100644
--- a/src/tui/content/view.rs
+++ b/src/tui/content/view.rs
@@ -197,9 +197,11 @@ pub(crate) fn content_position_at(
     ))
 }
 
-/// Structure block ordinal for the open-marker line at `line` (a displayed
-/// line index), if any. Walks the wrapped display so scroll/wrap cannot
-/// shift the block mapping.
+/// 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.
 pub(crate) fn content_structure_block_at(
     area: Rect,
     text: &str,
@@ -209,22 +211,62 @@ pub(crate) fn content_structure_block_at(
     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 mut block = 0usize;
-    for (idx, content_line) in lines.iter().enumerate() {
-        let joined: String = content_line
+    let joined = |idx: usize| {
+        lines[idx]
             .line
             .spans
             .iter()
             .map(|span| span.content.as_ref())
-            .collect();
-        if crate::tui::content::text::is_structure_marker(&joined) && !joined.starts_with("<:/") {
-            if idx == line {
-                return Some(block);
+            .collect::<String>()
+    };
+
+    // Map each displayed line to the block that owns it. Collapsed blocks own
+    // only their tag line; expanded blocks own the tag, body, and close marker.
+    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);
+        // An expanded block ends at its matching close marker (before the next
+        // open marker); a collapsed block is just the tag line.
+        let inner = open_marker_inner(&text);
+        let mut end = idx;
+        let mut scan = idx + 1;
+        while scan < lines.len() {
+            let candidate = joined(scan);
+            if is_open_marker(&candidate) {
+                break;
+            }
+            if close_marker_inner(&candidate) == inner {
+                end = scan;
+                break;
             }
-            block += 1;
+            scan += 1;
         }
+        for owned in ownership[idx + 1..=end].iter_mut() {
+            *owned = Some(block);
+        }
+        block += 1;
+        idx = end + 1;
     }
-    None
+    ownership.get(line).copied().flatten()
+}
+
+fn is_open_marker(text: &str) -> bool {
+    crate::tui::content::text::is_structure_marker(text) && !text.starts_with("<:/")
+}
+
+fn open_marker_inner(text: &str) -> Option<&str> {
+    text.strip_prefix("<:")?.strip_suffix(":>")
+}
+
+fn close_marker_inner(text: &str) -> Option<&str> {
+    text.strip_prefix("<:/")?.strip_suffix(":>")
 }
 
 pub(crate) fn content_position_in_text_row(
@@ -1664,4 +1706,55 @@ mod tests {
             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 displayed_of = |needle: &str| {
+            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)
+                })
+                .unwrap()
+        };
+        let tag = displayed_of("<:tool:Bash call:>");
+        let body = displayed_of("output line");
+        let close = displayed_of("<:/tool:Bash call:>");
+        let next_tag = displayed_of("<:tool:Read call:>");
+        let plain = displayed_of("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
+        );
+    }
 }

From a7a6f04a7fb2338eb721ce8e84a8c26158845d5f Mon Sep 17 00:00:00 2001
From: Ariestar <1941137088@qq.com>
Date: Thu, 13 Aug 2026 17:11:12 +0800
Subject: [PATCH 06/10] feat(tui): group tool calls with results and show
 descriptions

- a ToolCall and its matching ToolResult now fold into one block: one tag
  when collapsed, the call and its result side by side when expanded,
  matching grok build's per-invocation entries
- collapsed tags show the tool input's description field when present
  (truncated), falling back to the plain tag
- content_structure_block_at keeps the result section inside the same
  group, so clicking anywhere in the expanded invocation collapses it
---
 src/tui/content/text.rs    | 169 +++++++++++++++++++++++++++++++++++--
 src/tui/content/view.rs    |  75 +++++++++++++---
 src/tui/workspace/tests.rs |   5 +-
 3 files changed, 228 insertions(+), 21 deletions(-)

diff --git a/src/tui/content/text.rs b/src/tui/content/text.rs
index b657b5d6..276c3c0e 100644
--- a/src/tui/content/text.rs
+++ b/src/tui/content/text.rs
@@ -36,24 +36,65 @@ fn io_body_text(
     }
     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() {
-            let idx = block;
+            // 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(&idx) {
-                chunks.push(sivtr_core::record::format_work_part(part));
+            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")
 }
 
+/// Last part of the structure group starting at `start`: a ToolCall followed
+/// by a ToolResult with the same call id 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)
+                && part_call_id(result) == part_call_id(parts[start]) =>
+        {
+            start + 1
+        }
+        _ => start,
+    }
+}
+
+fn part_call_id(part: &sivtr_core::record::WorkPart) -> Option<&str> {
+    match &part.data {
+        sivtr_core::record::WorkPartData::ToolCall { call_id, .. }
+        | sivtr_core::record::WorkPartData::ToolResult { call_id, .. } => call_id.as_deref(),
+        _ => None,
+    }
+}
+
 pub(crate) fn structured_part_text(part: &sivtr_core::record::WorkPart) -> String {
     if part.kind().is_structure() {
         structure_fold_label(part)
@@ -63,10 +104,39 @@ 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)?;
+    let description = description.trim();
+    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(
@@ -172,6 +242,18 @@ mod tests {
         }
     }
 
+    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,
@@ -227,4 +309,79 @@ mod tests {
         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:>"));
+    }
 }
diff --git a/src/tui/content/view.rs b/src/tui/content/view.rs
index 6400dc7e..57a4d5f4 100644
--- a/src/tui/content/view.rs
+++ b/src/tui/content/view.rs
@@ -201,7 +201,8 @@ pub(crate) fn content_position_at(
 /// 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.
+/// 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,
@@ -220,8 +221,9 @@ pub(crate) fn content_structure_block_at(
             .collect::<String>()
     };
 
-    // Map each displayed line to the block that owns it. Collapsed blocks own
-    // only their tag line; expanded blocks own the tag, body, and close marker.
+    // 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;
@@ -232,19 +234,15 @@ pub(crate) fn content_structure_block_at(
             continue;
         }
         ownership[idx] = Some(block);
-        // An expanded block ends at its matching close marker (before the next
-        // open marker); a collapsed block is just the tag line.
-        let inner = open_marker_inner(&text);
         let mut end = idx;
         let mut scan = idx + 1;
         while scan < lines.len() {
             let candidate = joined(scan);
-            if is_open_marker(&candidate) {
+            if is_open_marker(&candidate) && !is_result_section(&candidate) {
                 break;
             }
-            if close_marker_inner(&candidate) == inner {
+            if candidate.starts_with("<:/") {
                 end = scan;
-                break;
             }
             scan += 1;
         }
@@ -261,12 +259,14 @@ fn is_open_marker(text: &str) -> bool {
     crate::tui::content::text::is_structure_marker(text) && !text.starts_with("<:/")
 }
 
-fn open_marker_inner(text: &str) -> Option<&str> {
-    text.strip_prefix("<:")?.strip_suffix(":>")
+/// 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 close_marker_inner(text: &str) -> Option<&str> {
-    text.strip_prefix("<:/")?.strip_suffix(":>")
+fn open_marker_inner(text: &str) -> Option<&str> {
+    text.strip_prefix("<:")?.strip_suffix(":>")
 }
 
 pub(crate) fn content_position_in_text_row(
@@ -1757,4 +1757,53 @@ mod tests {
             None
         );
     }
+
+    #[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 displayed_of = |needle: &str| {
+            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)
+                })
+                .unwrap()
+        };
+        let call_tag = displayed_of("<:tool:Bash call:>");
+        let call_body = displayed_of("input");
+        let call_close = displayed_of("<:/tool:Bash call:>");
+        let result_tag = displayed_of("<:tool:Bash result:>");
+        let result_body = displayed_of("output");
+        let result_close = displayed_of("<:/tool:Bash result:>");
+        let next_tag = displayed_of("<: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/workspace/tests.rs b/src/tui/workspace/tests.rs
index d3168e99..24730ecc 100644
--- a/src/tui/workspace/tests.rs
+++ b/src/tui/workspace/tests.rs
@@ -203,9 +203,10 @@ fn reading_mode_folds_structure_and_raw_expands() {
         &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"));

From e72ca934a938489186de582c4ba9170558ae7b9a Mon Sep 17 00:00:00 2001
From: Ariestar <1941137088@qq.com>
Date: Thu, 13 Aug 2026 17:35:01 +0800
Subject: [PATCH 07/10] feat(tui): highlight the clicked structure block in
 content
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

clicking a structure block in the content pane now marks it as the active
block, tinting its tag, body, and close rows with the same selected-row
background the session/dialogue lists use — the three panels now share
one click-to-highlight interaction. The highlight follows the block's
displayed line range (computed by content_structure_block_range), so a
merged tool group highlights as one unit.
---
 src/commands/browse/picker.rs |   8 ++-
 src/tui/content/view.rs       | 104 +++++++++++++++++++++++++++++++++-
 src/tui/workspace/model.rs    |   2 +
 src/tui/workspace/render.rs   |   5 ++
 4 files changed, 115 insertions(+), 4 deletions(-)

diff --git a/src/commands/browse/picker.rs b/src/commands/browse/picker.rs
index 4675fa43..ed3e907b 100644
--- a/src/commands/browse/picker.rs
+++ b/src/commands/browse/picker.rs
@@ -87,6 +87,8 @@ pub(crate) fn run(
     // 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();
@@ -337,6 +339,7 @@ pub(crate) fn run(
             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(
@@ -419,6 +422,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,
                     },
                 )
@@ -920,9 +924,11 @@ 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.
+                            // 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;
                                 }
diff --git a/src/tui/content/view.rs b/src/tui/content/view.rs
index 57a4d5f4..24f1da51 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],
     );
@@ -209,6 +215,27 @@ pub(crate) fn content_structure_block_at(
     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);
@@ -252,7 +279,7 @@ pub(crate) fn content_structure_block_at(
         block += 1;
         idx = end + 1;
     }
-    ownership.get(line).copied().flatten()
+    ownership
 }
 
 fn is_open_marker(text: &str) -> bool {
@@ -534,6 +561,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()
@@ -541,12 +569,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>,
@@ -1256,6 +1311,7 @@ mod tests {
             scroll,
             search_regex,
             None,
+            None,
         )
     }
 
@@ -1354,6 +1410,7 @@ mod tests {
             0,
             None,
             None,
+            None,
         );
 
         assert_eq!(rendered.lines.len(), 2);
@@ -1372,7 +1429,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");
@@ -1470,6 +1527,7 @@ mod tests {
             0,
             None,
             None,
+            None,
         );
 
         assert!(!rendered.lines.is_empty());
@@ -1572,6 +1630,7 @@ mod tests {
                 cursor: ContentPosition { line: 1, column: 3 },
                 kind: ContentSelectionKind::Block,
             }),
+            None,
         );
 
         assert_eq!(rendered.lines[0].spans[1].content.as_ref(), "bcd");
@@ -1597,6 +1656,7 @@ mod tests {
                 cursor: ContentPosition { line: 0, column: 3 },
                 kind: ContentSelectionKind::Linear,
             }),
+            None,
         );
 
         assert_eq!(rendered_line_text(&rendered, 0), "alpha");
@@ -1624,6 +1684,7 @@ mod tests {
                         search_regex: None,
                         mode: ContentViewMode::Reading,
                         selection: None,
+                        active_block: None,
                     },
                 );
             })
@@ -1634,6 +1695,43 @@ 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).unwrap();
+        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),
+                    },
+                );
+            })
+            .unwrap();
+        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)).unwrap();
+            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)).unwrap();
+        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";
diff --git a/src/tui/workspace/model.rs b/src/tui/workspace/model.rs
index 552bb0f3..ebfbec5e 100644
--- a/src/tui/workspace/model.rs
+++ b/src/tui/workspace/model.rs
@@ -403,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 2c30a0f1..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),
         );
     }
 
@@ -852,6 +855,7 @@ fn render_content_panel(
     mode: ContentViewMode,
     selection: Option<ContentSelection>,
     search_regex: Option<&Regex>,
+    active_block: Option<usize>,
 ) {
     render_content_view(
         frame,
@@ -863,6 +867,7 @@ fn render_content_panel(
             search_regex,
             mode,
             selection,
+            active_block,
         },
     );
 }

From 381ddefa50efbfee587fb81f5d810fc1c9f50920 Mon Sep 17 00:00:00 2001
From: Ariestar <1941137088@qq.com>
Date: Sat, 15 Aug 2026 20:30:03 +0800
Subject: [PATCH 08/10] style: apply rustfmt

---
 src/tui/content/view.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/tui/content/view.rs b/src/tui/content/view.rs
index 24f1da51..c791145d 100644
--- a/src/tui/content/view.rs
+++ b/src/tui/content/view.rs
@@ -1723,7 +1723,8 @@ mod tests {
         for row in 1..=3 {
             let cell = buffer.cell((4, row)).unwrap();
             assert_eq!(
-                cell.style().bg, selected_bg,
+                cell.style().bg,
+                selected_bg,
                 "row {row} should be highlighted"
             );
         }

From 7629f079d94a11ec93250e31159ab9ff369b334a Mon Sep 17 00:00:00 2001
From: Ariestar <1941137088@qq.com>
Date: Sun, 16 Aug 2026 14:36:57 +0800
Subject: [PATCH 09/10] fix(tui): tighten structure markers and block folding
 edges
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Review feedback on the click-to-expand interaction:

- structure markers validate the full `<:kind:…:>` shape instead of the
  `<:` prefix, so plain text starting with `<:/` no longer extends a
  block's click/highlight range
- id-less tool calls and results group only when they share the same
  tool name; distinct call ids never merge
- multi-line tool descriptions normalize to one tag line
- clicks below the last rendered line no longer toggle the final block
- the expansion reset key includes the shown dialogue's identity, so a
  session switch reuses no stale block indices
- tests use expect("reason") and share one displayed-line lookup helper
- changelog: 0.5.0 entry for the reading-mode block folding interaction
---
 CHANGELOG.md                  |   1 +
 changelogs/0.5.0.md           |  27 +++++++
 src/commands/browse/picker.rs |  27 ++++++-
 src/tui/content/text.rs       | 117 +++++++++++++++++++++++++++---
 src/tui/content/view.rs       | 129 +++++++++++++++++++++-------------
 5 files changed, 241 insertions(+), 60 deletions(-)
 create mode 100644 changelogs/0.5.0.md

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2b346f0f..ffd1f66a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,7 @@ Detailed release notes live in [`changelogs/`](changelogs/).
 
 ## Releases
 
+- [0.5.0 - unreleased](changelogs/0.5.0.md)
 - [0.4.1 - 2026-08-05](changelogs/0.4.1.md)
 - [0.4.0 - 2026-08-04](changelogs/0.4.0.md)
 - [0.3.0 - 2026-07-21](changelogs/0.3.0.md)
diff --git a/changelogs/0.5.0.md b/changelogs/0.5.0.md
new file mode 100644
index 00000000..1023e17f
--- /dev/null
+++ b/changelogs/0.5.0.md
@@ -0,0 +1,27 @@
+# 0.5.0 - unreleased
+
+## English
+
+### Added
+
+- Reading mode: structure blocks (tool calls, results, skills, thinking) fold to `<:…:>` tags, and clicking a tag expands/collapses its block — merged tool call+result groups fold as one unit, and the clicked block is highlighted like a list row.
+
+### Fixed
+
+- Id-less tool calls and results group only when they share the same tool name; distinct call ids never merge.
+- Multi-line tool descriptions normalize to a single tag line.
+- Plain text starting with `<:/` is no longer treated as a structure close marker.
+- Clicking below the last content line no longer toggles the final block.
+
+## 中文
+
+### 新增
+
+- 阅读模式：结构块（工具调用、结果、skill、thinking）折叠为 `<:…:>` 标签，点击标签可展开/折叠对应块——合并的工具调用+结果组折叠为一个单元，被点击的块以列表行样式高亮。
+
+### 修复
+
+- 无 call id 的工具调用与结果仅在工具名相同时合并；不同的 call id 永不合并。
+- 多行工具描述规范化为单行标签。
+- 以 `<:/` 开头的普通文本不再被当作结构结束标记。
+- 点击最后一行内容以下的空白不再触发最后一个块的折叠。
diff --git a/src/commands/browse/picker.rs b/src/commands/browse/picker.rs
index ed3e907b..43966150 100644
--- a/src/commands/browse/picker.rs
+++ b/src/commands/browse/picker.rs
@@ -7,7 +7,8 @@ use std::collections::HashSet;
 use std::path::PathBuf;
 
 use crate::tui::content::view::{
-    content_link_at, content_position_at, content_structure_block_at, ContentViewMode,
+    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,
@@ -334,8 +335,16 @@ pub(crate) fn run(
                 content_io_focus = half;
             }
             // Expansion indices are per-dialogue; reset when the shown
-            // dialogue, target, or selection changes.
-            let expand_key = (dialogue_idx, active_content_at, selected_dialogues.clone());
+            // 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;
@@ -890,6 +899,18 @@ pub(crate) fn run(
                                     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.
diff --git a/src/tui/content/text.rs b/src/tui/content/text.rs
index 276c3c0e..8c4584fe 100644
--- a/src/tui/content/text.rs
+++ b/src/tui/content/text.rs
@@ -67,7 +67,7 @@ fn io_body_text(
 }
 
 /// Last part of the structure group starting at `start`: a ToolCall followed
-/// by a ToolResult with the same call id is one group; anything else is a
+/// 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!(
@@ -79,7 +79,7 @@ fn structure_group_end(parts: &[&sivtr_core::record::WorkPart], start: usize) ->
     match parts.get(start + 1) {
         Some(result)
             if matches!(result.kind(), sivtr_core::record::WorkPartKind::ToolResult)
-                && part_call_id(result) == part_call_id(parts[start]) =>
+                && same_tool_exchange(parts[start], result) =>
         {
             start + 1
         }
@@ -87,11 +87,28 @@ fn structure_group_end(parts: &[&sivtr_core::record::WorkPart], start: usize) ->
     }
 }
 
-fn part_call_id(part: &sivtr_core::record::WorkPart) -> Option<&str> {
-    match &part.data {
-        sivtr_core::record::WorkPartData::ToolCall { call_id, .. }
-        | sivtr_core::record::WorkPartData::ToolResult { call_id, .. } => call_id.as_deref(),
-        _ => None,
+/// 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,
     }
 }
 
@@ -127,7 +144,9 @@ fn tool_description(part: &sivtr_core::record::WorkPart) -> Option<String> {
     let description = input
         .get("description")
         .and_then(serde_json::Value::as_str)?;
-    let description = description.trim();
+    // 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;
     }
@@ -218,9 +237,24 @@ pub(crate) fn workspace_content_io_texts(
     }
 }
 
-/// A line that opens or closes a structure block (`<:tool:…:>` / `<:/…:>`).
+/// 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 {
-    line.starts_with("<:")
+    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)]
@@ -384,4 +418,67 @@ mod tests {
         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 c791145d..347191f9 100644
--- a/src/tui/content/view.rs
+++ b/src/tui/content/view.rs
@@ -203,6 +203,24 @@ 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
@@ -268,7 +286,11 @@ fn content_block_ownership(area: Rect, text: &str, mode: ContentViewMode) -> Vec
             if is_open_marker(&candidate) && !is_result_section(&candidate) {
                 break;
             }
-            if candidate.starts_with("<:/") {
+            // 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;
@@ -1299,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,
@@ -1698,7 +1737,7 @@ mod tests {
     #[test]
     fn render_content_view_highlights_the_active_block() {
         let backend = TestBackend::new(40, 8);
-        let mut terminal = Terminal::new(backend).unwrap();
+        let mut terminal = Terminal::new(backend).expect("terminal from test backend");
         terminal
             .draw(|frame| {
                 render_content_view(
@@ -1715,13 +1754,13 @@ mod tests {
                     },
                 );
             })
-            .unwrap();
+            .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)).unwrap();
+            let cell = buffer.cell((4, row)).expect("cell within buffer bounds");
             assert_eq!(
                 cell.style().bg,
                 selected_bg,
@@ -1729,7 +1768,7 @@ mod tests {
             );
         }
         // The next block's tag is not part of the highlight.
-        let cell = buffer.cell((4, 4)).unwrap();
+        let cell = buffer.cell((4, 4)).expect("cell within buffer bounds");
         assert_ne!(cell.style().bg, selected_bg);
     }
 
@@ -1813,26 +1852,11 @@ mod tests {
         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 displayed_of = |needle: &str| {
-            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)
-                })
-                .unwrap()
-        };
-        let tag = displayed_of("<:tool:Bash call:>");
-        let body = displayed_of("output line");
-        let close = displayed_of("<:/tool:Bash call:>");
-        let next_tag = displayed_of("<:tool:Read call:>");
-        let plain = displayed_of("plain");
+        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),
@@ -1857,34 +1881,45 @@ mod tests {
         );
     }
 
+    #[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 displayed_of = |needle: &str| {
-            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)
-                })
-                .unwrap()
-        };
-        let call_tag = displayed_of("<:tool:Bash call:>");
-        let call_body = displayed_of("input");
-        let call_close = displayed_of("<:/tool:Bash call:>");
-        let result_tag = displayed_of("<:tool:Bash result:>");
-        let result_body = displayed_of("output");
-        let result_close = displayed_of("<:/tool:Bash result:>");
-        let next_tag = displayed_of("<:tool:Read call:>");
+        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,

From 5a90dcec32938f21dcb91eacf0c3a2afc5788181 Mon Sep 17 00:00:00 2001
From: Ariestar <1941137088@qq.com>
Date: Sun, 16 Aug 2026 17:23:33 +0800
Subject: [PATCH 10/10] docs: defer the changelog entry to release time

The repo policy derives release notes from `git log` at release time;
revert the per-PR 0.5.0 entry to avoid stacked-branch changelog conflicts.
---
 CHANGELOG.md        |  1 -
 changelogs/0.5.0.md | 27 ---------------------------
 2 files changed, 28 deletions(-)
 delete mode 100644 changelogs/0.5.0.md

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ffd1f66a..2b346f0f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,7 +6,6 @@ Detailed release notes live in [`changelogs/`](changelogs/).
 
 ## Releases
 
-- [0.5.0 - unreleased](changelogs/0.5.0.md)
 - [0.4.1 - 2026-08-05](changelogs/0.4.1.md)
 - [0.4.0 - 2026-08-04](changelogs/0.4.0.md)
 - [0.3.0 - 2026-07-21](changelogs/0.3.0.md)
diff --git a/changelogs/0.5.0.md b/changelogs/0.5.0.md
deleted file mode 100644
index 1023e17f..00000000
--- a/changelogs/0.5.0.md
+++ /dev/null
@@ -1,27 +0,0 @@
-# 0.5.0 - unreleased
-
-## English
-
-### Added
-
-- Reading mode: structure blocks (tool calls, results, skills, thinking) fold to `<:…:>` tags, and clicking a tag expands/collapses its block — merged tool call+result groups fold as one unit, and the clicked block is highlighted like a list row.
-
-### Fixed
-
-- Id-less tool calls and results group only when they share the same tool name; distinct call ids never merge.
-- Multi-line tool descriptions normalize to a single tag line.
-- Plain text starting with `<:/` is no longer treated as a structure close marker.
-- Clicking below the last content line no longer toggles the final block.
-
-## 中文
-
-### 新增
-
-- 阅读模式：结构块（工具调用、结果、skill、thinking）折叠为 `<:…:>` 标签，点击标签可展开/折叠对应块——合并的工具调用+结果组折叠为一个单元，被点击的块以列表行样式高亮。
-
-### 修复
-
-- 无 call id 的工具调用与结果仅在工具名相同时合并；不同的 call id 永不合并。
-- 多行工具描述规范化为单行标签。
-- 以 `<:/` 开头的普通文本不再被当作结构结束标记。
-- 点击最后一行内容以下的空白不再触发最后一个块的折叠。