diff --git a/codex-rs/config/src/types.rs b/codex-rs/config/src/types.rs
index 15f74c9e71..2a2ad0b07d 100644
--- a/codex-rs/config/src/types.rs
+++ b/codex-rs/config/src/types.rs
@@ -777,14 +777,14 @@ pub enum RightClickPaste {
     Off,
 }
 
-/// When transcript mouse selections are copied on release.
+/// When mouse selections are copied on release.
 #[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq, JsonSchema, Default)]
 #[serde(rename_all = "lowercase")]
 pub enum CopyOnSelect {
     /// Use the terminal-specific default.
     #[default]
     Auto,
-    /// Copy every nonempty transcript mouse selection on release.
+    /// Copy every nonempty transcript or footer mouse selection on release.
     Always,
     /// Require an explicit copy action.
     Never,
@@ -889,7 +889,7 @@ pub struct Tui {
     #[schemars(schema_with = "crate::tui_mouse_scroll::schema")]
     pub mouse_scroll_speed: Option<f64>,
 
-    /// Copy selected transcript text when the mouse button is released.
+    /// Copy selected transcript or footer text when the mouse button is released.
     /// Defaults to `auto`: enabled except in direct terminals known to forward their native
     /// copy shortcut (Ghostty 1.2+, Kitty on macOS, Windows Terminal, and VS Code on Windows).
     /// Unknown terminals, Ghostty without a recognized version, and tmux/Zellij default to copying.
diff --git a/codex-rs/core/config.schema.json b/codex-rs/core/config.schema.json
index 2bd4fda300..80c955ba49 100644
--- a/codex-rs/core/config.schema.json
+++ b/codex-rs/core/config.schema.json
@@ -1382,7 +1382,7 @@
       "type": "object"
     },
     "CopyOnSelect": {
-      "description": "When transcript mouse selections are copied on release.",
+      "description": "When mouse selections are copied on release.",
       "oneOf": [
         {
           "description": "Use the terminal-specific default.",
@@ -1392,7 +1392,7 @@
           "type": "string"
         },
         {
-          "description": "Copy every nonempty transcript mouse selection on release.",
+          "description": "Copy every nonempty transcript or footer mouse selection on release.",
           "enum": [
             "always"
           ],
@@ -4611,7 +4611,7 @@
             }
           ],
           "default": "auto",
-          "description": "Copy selected transcript text when the mouse button is released. Defaults to `auto`: enabled except in direct terminals known to forward their native copy shortcut (Ghostty 1.2+, Kitty on macOS, Windows Terminal, and VS Code on Windows). Unknown terminals, Ghostty without a recognized version, and tmux/Zellij default to copying."
+          "description": "Copy selected transcript or footer text when the mouse button is released. Defaults to `auto`: enabled except in direct terminals known to forward their native copy shortcut (Ghostty 1.2+, Kitty on macOS, Windows Terminal, and VS Code on Windows). Unknown terminals, Ghostty without a recognized version, and tmux/Zellij default to copying."
         },
         "disable_paste_burst": {
           "description": "When true, disables burst-paste detection for typed input entirely. All characters are inserted as they are received, and no buffering or placeholder replacement will occur for fast keypress bursts. Overrides the legacy top-level `disable_paste_burst` setting. Defaults to `false`.",
diff --git a/codex-rs/tui/src/app.rs b/codex-rs/tui/src/app.rs
index 5dfc3ad7b2..92ba41a3ce 100644
--- a/codex-rs/tui/src/app.rs
+++ b/codex-rs/tui/src/app.rs
@@ -238,6 +238,7 @@ mod new_session;
 mod turn_tips;
 pub(crate) use new_session::has_launch_setting;
 mod clipboard;
+mod footer_selection;
 mod native_history;
 mod owned_transcript;
 mod pending_interactive_replay;
@@ -855,6 +856,9 @@ impl App {
         self.finish_clipboard(tui, &event);
         let event = self.finish_right_click_paste(tui, event);
         let idle_draw = matches!(event, TuiEvent::Draw);
+        if self.handle_rendered_selection_event(tui, &event)? {
+            return Ok(AppRunControl::Continue);
+        }
         if matches!(&event, TuiEvent::Key(_))
             && self.handle_composer_copy_event(tui, &event, |tui, text| {
                 tui.copy_transcript_selection(text, crate::clipboard_copy::CopyFormat::PlainText)
diff --git a/codex-rs/tui/src/app/clipboard.rs b/codex-rs/tui/src/app/clipboard.rs
index 0ecad1d8b2..1c742bfd5f 100644
--- a/codex-rs/tui/src/app/clipboard.rs
+++ b/codex-rs/tui/src/app/clipboard.rs
@@ -39,6 +39,12 @@ impl App {
                 self.transcript_view
                     .show_copy_feedback(&completion.1, characters);
             }
+            {
+                let mut selection = self.chat_widget.rendered_selection.borrow_mut();
+                let crate::rendered_selection::RenderedSelection { view, cells, .. } =
+                    &mut *selection;
+                view.finish_copy(cells, completion, current);
+            }
             let follow =
                 self.transcript_view
                     .finish_copy(&self.transcript_cells, completion, current);
diff --git a/codex-rs/tui/src/app/footer_selection.rs b/codex-rs/tui/src/app/footer_selection.rs
new file mode 100644
index 0000000000..436300bb22
--- /dev/null
+++ b/codex-rs/tui/src/app/footer_selection.rs
@@ -0,0 +1,67 @@
+//! Route registered read-only selections before copy, interrupt, clicks, and paste shortcuts.
+//! A stationary click is replayed to the existing widget handler after selection releases it.
+
+use super::*;
+use crate::clipboard_copy::CopyFormat;
+use crate::rendered_selection::RegionAction;
+use crate::rendered_selection::RenderedSelection;
+use crate::transcript_view::ViewAction;
+
+impl App {
+    pub(super) fn handle_rendered_selection_event(
+        &mut self,
+        tui: &mut tui::Tui,
+        event: &TuiEvent,
+    ) -> Result<bool> {
+        if !tui.is_owned_screen()
+            || self.overlay.is_some()
+            || !self.chat_widget.no_modal_or_popup_active()
+            || self.chat_widget.is_external_writer_view()
+        {
+            *self.chat_widget.rendered_selection.borrow_mut() = RenderedSelection::default();
+            return Ok(false);
+        }
+        let refresh = matches!(event, TuiEvent::Mouse(mouse)
+            if self.chat_widget.rendered_selection.borrow().needs_refresh(*mouse));
+        if refresh {
+            let size = tui.prepare_draw_size()?;
+            self.render_owned_transcript(tui, size)?;
+        }
+        let action = {
+            let mut selection = self.chat_widget.rendered_selection.borrow_mut();
+            selection.view.copy_on_select = self
+                .local_settings
+                .copy_on_select(&codex_terminal_detection::terminal_info());
+            selection.view.primary_selection = self.right_click_paste_environment.primary;
+            selection.handle_event(event, tui.terminal.previous_buffer())
+        };
+        let Some(action) = action else {
+            return Ok(false);
+        };
+        self.cancel_pending_key_chord();
+        match action {
+            RegionAction::Click(mouse) => {
+                self.chat_widget
+                    .handle_warning_event(&TuiEvent::Mouse(mouse), &self.transcript_cells);
+            }
+            RegionAction::Selection(action) => {
+                self.transcript_view.end_selection(&self.transcript_cells);
+                self.transcript_view.cancel_search();
+                self.transcript_view.clear_activity_focus();
+                self.chat_widget.clear_composer_selection();
+                let copied = {
+                    let mut selection = self.chat_widget.rendered_selection.borrow_mut();
+                    let RenderedSelection { view, cells, .. } = &mut *selection;
+                    view.copy_action(tui, cells, &action, CopyFormat::PlainText)
+                };
+                if let Some((characters, result)) = copied {
+                    self.transcript_view.show_copy_feedback(&result, characters);
+                } else if let ViewAction::OpenLink(url) = action {
+                    self.open_url_in_browser(url);
+                }
+            }
+        }
+        tui.frame_requester().schedule_frame();
+        Ok(true)
+    }
+}
diff --git a/codex-rs/tui/src/app/history_ui.rs b/codex-rs/tui/src/app/history_ui.rs
index dcacf8da01..ca29929c13 100644
--- a/codex-rs/tui/src/app/history_ui.rs
+++ b/codex-rs/tui/src/app/history_ui.rs
@@ -398,6 +398,7 @@ impl App {
         self.native_history = Default::default();
         self.cancel_pending_key_chord();
         self.transcript_view = Default::default();
+        *self.chat_widget.rendered_selection.borrow_mut() = Default::default();
         self.last_rendered_history_tail = None;
         self.last_thread_usage_status_cell = None;
         self.pending_thread_usage_history_refresh = false;
diff --git a/codex-rs/tui/src/app/owned_transcript.rs b/codex-rs/tui/src/app/owned_transcript.rs
index 3fcd0cd23c..7d51b3d686 100644
--- a/codex-rs/tui/src/app/owned_transcript.rs
+++ b/codex-rs/tui/src/app/owned_transcript.rs
@@ -87,7 +87,21 @@ impl App {
         };
         self.sync_owned_transcript(screen_size.width);
         let transcript_width = self.chat_widget.history_wrap_width(screen_size.width);
-        let composer_hint = self.composer_hint(transcript_width);
+        let composer_hint = if self
+            .chat_widget
+            .rendered_selection
+            .borrow()
+            .view
+            .has_active_interaction()
+        {
+            Some(
+                ratatui::text::Line::from("Selecting footer · esc cancel")
+                    .dim()
+                    .into(),
+            )
+        } else {
+            self.composer_hint(transcript_width)
+        };
         let now = Instant::now();
         let turn_tip = self.turn_tip(transcript_width, now, &tui.frame_requester());
         let working_tip = turn_tip
@@ -160,6 +174,7 @@ impl App {
         let mut blossom_tick = None;
         let mut transcript_bottom = available.saturating_sub(u16::from(composer_gap.is_none()));
         tui.draw(screen_size.height, |frame| {
+            chat_widget.rendered_selection.borrow_mut().areas.clear();
             ratatui::widgets::Clear.render(
                 Rect::new(/*x*/ 0, /*y*/ 0, screen_size.width, available),
                 frame.buffer,
@@ -270,6 +285,10 @@ impl App {
             .filter(|_| chat_widget.no_modal_or_popup_active());
             feedback_tick =
                 view.render_composer_gap(follow_area, composer_hint.as_ref(), frame.buffer, now);
+            chat_widget
+                .rendered_selection
+                .borrow_mut()
+                .render(frame.buffer);
             chat_widget.note_rendered_width(screen_size.width);
             let dialog = chat_widget.centered_dialog();
             let (foreground, foreground_area): (&dyn Renderable, Rect) =
@@ -576,27 +595,15 @@ impl App {
             }
             return self.handle_owned_backtrack_event(tui, event);
         };
-        let resume_following = matches!(action, ViewAction::CopyAndFollow(_));
-        let copy_on_select = matches!(action, ViewAction::CopyOnSelect(_));
-        match action {
-            ViewAction::Changed => {}
-            ViewAction::PrimarySelection(text) => self.transcript_view.publish_primary(tui, &text),
-            ViewAction::Copy(text)
-            | ViewAction::CopyOnSelect(text)
-            | ViewAction::CopyAndFollow(text) => {
-                let result = self.transcript_view.copy_selected_text(
-                    tui,
-                    &self.transcript_cells,
-                    &text,
-                    !copy_on_select,
-                );
-                if resume_following
-                    && matches!(result, Ok(crate::clipboard_copy::CopyStatus::Pending(_)))
-                {
-                    self.transcript_view.follow_pending_copy();
-                }
-            }
-            ViewAction::OpenLink(url) => self.open_url_in_browser(url),
+        if let Some((characters, result)) = self.transcript_view.copy_action(
+            tui,
+            &self.transcript_cells,
+            &action,
+            crate::clipboard_copy::CopyFormat::Markdown,
+        ) {
+            self.transcript_view.show_copy_feedback(&result, characters);
+        } else if let ViewAction::OpenLink(url) = action {
+            self.open_url_in_browser(url);
         }
         self.request_owned_history(tui, app_server);
         tui.frame_requester().schedule_frame();
diff --git a/codex-rs/tui/src/app/owned_transcript_tests.rs b/codex-rs/tui/src/app/owned_transcript_tests.rs
index 026fe11eac..ff6e0201bb 100644
--- a/codex-rs/tui/src/app/owned_transcript_tests.rs
+++ b/codex-rs/tui/src/app/owned_transcript_tests.rs
@@ -1780,6 +1780,72 @@ async fn fullscreen_composer_remote_images_leave_an_editable_prompt_row() -> Res
         "fullscreen_prompt_remote_images",
         normalize_snapshot_paths(frames.join("\n\n"))
     );
+
+    tui.set_owned_screen(/*owned*/ false)?;
+    Ok(())
+}
+
+#[tokio::test]
+async fn footer_selection_defers_warning_clicks_and_preserves_the_draft() -> Result<()> {
+    let mut app = crate::app::test_support::make_test_app().await;
+    app.local_settings.tui.copy_on_select = CopyOnSelect::Never;
+    let mut tui = crate::tui::test_support::make_test_tui()?;
+    tui.set_owned_screen(/*owned*/ true)?;
+    let size = tui.terminal.size()?;
+    app.chat_widget
+        .apply_external_edit("draft stays here".into());
+    app.insert_history_cell(
+        &mut tui,
+        Box::new(history_cell::new_warning_event("Example warning".into())),
+    );
+    app.render_owned_transcript(&mut tui, size)?;
+    let draft = app.chat_widget.capture_thread_input_state();
+    let cursor = tui.terminal.last_known_cursor_pos;
+    let buffer = crate::custom_terminal::test_support::last_rendered_buffer(&tui.terminal);
+    let badge = buffer
+        .area
+        .positions()
+        .find(|position| buffer[*position].symbol() == "⚠")
+        .unwrap();
+    for event in [
+        mouse(Down(Left), badge.x, badge.y),
+        mouse(Drag(Left), badge.x + 11, badge.y),
+        mouse(Up(Left), badge.x + 11, badge.y),
+    ] {
+        assert!(app.handle_rendered_selection_event(&mut tui, &event)?);
+        assert!(!app.chat_widget.keymap_contexts().is_warnings());
+    }
+    app.render_owned_transcript(&mut tui, size)?;
+    assert_eq!(
+        (
+            app.chat_widget.capture_thread_input_state(),
+            tui.terminal.last_known_cursor_pos
+        ),
+        (draft, cursor)
+    );
+    {
+        let mut selection = app.chat_widget.rendered_selection.borrow_mut();
+        let crate::rendered_selection::RenderedSelection { view, cells, .. } = &mut *selection;
+        assert!(view.selected_text(cells).unwrap().contains("warning"));
+    }
+    insta::assert_snapshot!(
+        "fullscreen_footer_selection",
+        normalize_snapshot_paths(buffer_text(
+            crate::custom_terminal::test_support::last_rendered_buffer(&tui.terminal)
+        ))
+    );
+    assert!(app.handle_rendered_selection_event(
+        &mut tui,
+        &TuiEvent::Key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE))
+    )?);
+    // Dismissal consumes the first Escape, and a stationary click still opens the warning viewer.
+    for event in [
+        mouse(Down(Left), badge.x + 2, badge.y),
+        mouse(Up(Left), badge.x + 2, badge.y),
+    ] {
+        assert!(app.handle_rendered_selection_event(&mut tui, &event)?);
+    }
+    assert!(app.chat_widget.keymap_contexts().is_warnings());
     tui.set_owned_screen(/*owned*/ false)?;
     Ok(())
 }
diff --git a/codex-rs/tui/src/app/right_click_paste.rs b/codex-rs/tui/src/app/right_click_paste.rs
index 53361e8684..4b912ec841 100644
--- a/codex-rs/tui/src/app/right_click_paste.rs
+++ b/codex-rs/tui/src/app/right_click_paste.rs
@@ -59,6 +59,12 @@ impl App {
         let allowed = match source {
             PasteSource::Clipboard => {
                 !self.transcript_view.has_selection_range()
+                    && !self
+                        .chat_widget
+                        .rendered_selection
+                        .borrow()
+                        .view
+                        .has_selection_range()
                     && self
                         .right_click_paste_environment
                         .allows(self.local_settings.tui.right_click_paste)
diff --git a/codex-rs/tui/src/app/snapshots/codex_tui__app__owned_transcript__tests__fullscreen_footer_selection.snap b/codex-rs/tui/src/app/snapshots/codex_tui__app__owned_transcript__tests__fullscreen_footer_selection.snap
new file mode 100644
index 0000000000..c609b9ff9d
--- /dev/null
+++ b/codex-rs/tui/src/app/snapshots/codex_tui__app__owned_transcript__tests__fullscreen_footer_selection.snap
@@ -0,0 +1,29 @@
+---
+source: tui/src/app/owned_transcript_tests.rs
+assertion_line: 1545
+expression: "normalize_snapshot_paths(buffer_text(crate::custom_terminal::test_support::last_rendered_buffer(&tui.terminal)))"
+---
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+                                                  Selecting footer · esc cancel
+
+› draft stays here
+
+  GPT-5.6-Sol default · /tmp/project
+                                                       ⚠ 1 warning · f2 to view
diff --git a/codex-rs/tui/src/bottom_pane/chat_composer.rs b/codex-rs/tui/src/bottom_pane/chat_composer.rs
index 7a36cd9959..56beebc795 100644
--- a/codex-rs/tui/src/bottom_pane/chat_composer.rs
+++ b/codex-rs/tui/src/bottom_pane/chat_composer.rs
@@ -248,7 +248,8 @@
 //! Submission flushes expired characters and buffers before classifying Enter, independent of
 //! UI flush ticks. `disable_paste_burst` bypasses detection; setting it flushes and clears in-flight state.
 //! Mouse edits flush pending typing; selection and copy behavior lives in [`mouse`]. Confirmed
-//! copies clear the selection while preserving the draft and cursor.
+//! copies clear the selection while preserving the draft and cursor. Footer text uses a separate
+//! read-only selection owner over its final rendered cells.
 //!
 //! See `codex-rs/tui/src/bottom_pane/paste_burst.rs` for the detailed state machine.
 //!
@@ -752,6 +753,7 @@ impl ChatComposer {
                 external_editor_key: default_keymap
                     .primary_hint(KeymapContext::Global, "open_external_editor"),
                 warning_notice_area: std::cell::Cell::default(),
+                selection_revision: std::cell::Cell::default(),
                 show_warnings_key: default_keymap
                     .primary_hint(KeymapContext::Global, "open_warnings"),
                 show_transcript_key: default_keymap
@@ -4800,6 +4802,16 @@ impl ChatComposer {
         if let Some((warning_area, line)) = warning_notice {
             line.render(warning_area, buf);
         }
+        if let Some(selection) = options.rendered_selection
+            && !self.popup_active()
+            && options.footer.is_none_or(|footer| !footer.is_interactive)
+        {
+            let revision = (options.warning_count, self.footer_props().is_task_running);
+            let changed = self.footer.selection_revision.replace(revision) != revision;
+            let mut selection = selection.borrow_mut();
+            selection.register(status.intersection(buf.area), changed);
+            selection.register(footer_rect.intersection(buf.area), changed);
+        }
         let style = user_message_style();
         Block::default().style(style).render(composer_rect, buf);
         if !remote_images_rect.is_empty() {
diff --git a/codex-rs/tui/src/bottom_pane/chat_composer/footer_state.rs b/codex-rs/tui/src/bottom_pane/chat_composer/footer_state.rs
index 5b8784a4fa..bcc92a3ed5 100644
--- a/codex-rs/tui/src/bottom_pane/chat_composer/footer_state.rs
+++ b/codex-rs/tui/src/bottom_pane/chat_composer/footer_state.rs
@@ -70,6 +70,8 @@ pub(crate) enum CommandPopupPlacement {
 pub(crate) struct ComposerRenderOptions<'a> {
     /// Fullscreen limits the composer independently of activity and modal views.
     pub(crate) max_height: Option<u16>,
+    pub(crate) rendered_selection:
+        Option<&'a std::cell::RefCell<crate::rendered_selection::RenderedSelection>>,
     /// Reserve a shared hint row independently of whether it currently contains a notice.
     pub(crate) composer_gap: Option<&'a crate::bottom_pane::ComposerGap>,
     pub(crate) working_tip: Option<&'a crate::turn_tip::TurnTip>,
@@ -365,6 +367,7 @@ pub(super) struct FooterState {
     pub(super) show_transcript_key: Option<ShortcutHint>,
     pub(super) show_warnings_key: Option<ShortcutHint>,
     pub(super) warning_notice_area: std::cell::Cell<Option<Rect>>,
+    pub(super) selection_revision: std::cell::Cell<(usize, bool)>,
     pub(super) find_transcript_key: Option<ShortcutHint>,
     pub(super) focus_activity_key: Option<ShortcutHint>,
     pub(super) insert_newline_key: Option<ShortcutHint>,
diff --git a/codex-rs/tui/src/bottom_pane/chat_composer/mouse.rs b/codex-rs/tui/src/bottom_pane/chat_composer/mouse.rs
index ec95356ef5..b20b533b5c 100644
--- a/codex-rs/tui/src/bottom_pane/chat_composer/mouse.rs
+++ b/codex-rs/tui/src/bottom_pane/chat_composer/mouse.rs
@@ -62,6 +62,10 @@ impl ChatComposer {
         Some((char_count, result))
     }
 
+    pub(crate) fn clear_mouse_selection(&mut self) {
+        self.draft.textarea.set_cursor(self.draft.textarea.cursor());
+    }
+
     pub(crate) fn end_mouse_drag(&mut self) {
         self.draft.textarea.end_mouse_drag();
     }
diff --git a/codex-rs/tui/src/bottom_pane/mod.rs b/codex-rs/tui/src/bottom_pane/mod.rs
index bc8e6ce08d..630df124e9 100644
--- a/codex-rs/tui/src/bottom_pane/mod.rs
+++ b/codex-rs/tui/src/bottom_pane/mod.rs
@@ -1802,6 +1802,10 @@ impl BottomPane {
         self.can_launch_external_editor()
     }
 
+    pub(crate) fn clear_composer_selection(&mut self) {
+        self.composer.clear_mouse_selection();
+    }
+
     pub(crate) fn end_composer_drag(&mut self) {
         self.composer.end_mouse_drag();
     }
diff --git a/codex-rs/tui/src/chatwidget.rs b/codex-rs/tui/src/chatwidget.rs
index 8c77689ba2..16b13efb89 100644
--- a/codex-rs/tui/src/chatwidget.rs
+++ b/codex-rs/tui/src/chatwidget.rs
@@ -585,6 +585,7 @@ pub(crate) struct ChatWidget {
     // Remember the account's Reserve entry notice across chats and transient banner refreshes.
     luna_reserve_notice_account_id: Option<String>,
     pub(crate) warning_display_state: WarningDisplayState,
+    pub(crate) rendered_selection: std::cell::RefCell<crate::rendered_selection::RenderedSelection>,
     rate_limit_switch_prompt: RateLimitSwitchPromptState,
     add_credits_nudge_email_in_flight: Option<rate_limits::PendingCreditsNudge>,
     adaptive_chunking: AdaptiveChunkingPolicy,
diff --git a/codex-rs/tui/src/chatwidget/constructor.rs b/codex-rs/tui/src/chatwidget/constructor.rs
index dc5adf7b73..9af84e80a7 100644
--- a/codex-rs/tui/src/chatwidget/constructor.rs
+++ b/codex-rs/tui/src/chatwidget/constructor.rs
@@ -172,6 +172,7 @@ impl ChatWidget {
             backend_banner_notice_model: None,
             luna_reserve_notice_account_id: None,
             warning_display_state: WarningDisplayState::default(),
+            rendered_selection: Default::default(),
             rate_limit_switch_prompt: RateLimitSwitchPromptState::default(),
             add_credits_nudge_email_in_flight: None,
             adaptive_chunking: AdaptiveChunkingPolicy::default(),
diff --git a/codex-rs/tui/src/chatwidget/interaction.rs b/codex-rs/tui/src/chatwidget/interaction.rs
index ddabe0e3e2..5a8897ab91 100644
--- a/codex-rs/tui/src/chatwidget/interaction.rs
+++ b/codex-rs/tui/src/chatwidget/interaction.rs
@@ -15,6 +15,10 @@ pub(crate) enum KeyEventAction {
 }
 
 impl ChatWidget {
+    pub(crate) fn clear_composer_selection(&mut self) {
+        self.bottom_pane.clear_composer_selection();
+    }
+
     pub(crate) fn end_composer_drag(&mut self) {
         self.bottom_pane.end_composer_drag();
     }
diff --git a/codex-rs/tui/src/chatwidget/rendering.rs b/codex-rs/tui/src/chatwidget/rendering.rs
index adfe1cee5c..eee242df2e 100644
--- a/codex-rs/tui/src/chatwidget/rendering.rs
+++ b/codex-rs/tui/src/chatwidget/rendering.rs
@@ -252,6 +252,7 @@ impl ChatWidget {
             } else {
                 self.ambient_pet_wrap_reserved_cols()
             };
+            options.rendered_selection = Some(&self.rendered_selection);
             options.warning_count = self.warning_display_state.count;
             options.textarea_right_reserve = right_reserve;
             options.separate_status_line = options.command_popup_placement
diff --git a/codex-rs/tui/src/footer_selection_tests.rs b/codex-rs/tui/src/footer_selection_tests.rs
new file mode 100644
index 0000000000..18937c0679
--- /dev/null
+++ b/codex-rs/tui/src/footer_selection_tests.rs
@@ -0,0 +1,168 @@
+//! Exercise the rendered-cell adapter; gesture and clipboard state machines have shared tests.
+
+use super::*;
+use crossterm::event::KeyCode;
+use crossterm::event::KeyEvent;
+use crossterm::event::KeyModifiers;
+use crossterm::event::MouseButton::Left;
+use crossterm::event::MouseEventKind::Down;
+use crossterm::event::MouseEventKind::Drag;
+use crossterm::event::MouseEventKind::Up;
+use pretty_assertions::assert_eq;
+use ratatui::style::Stylize;
+use ratatui::widgets::Widget;
+
+fn mouse(kind: MouseEventKind, column: u16, row: u16) -> TuiEvent {
+    TuiEvent::Mouse(MouseEvent {
+        kind,
+        column,
+        row,
+        modifiers: KeyModifiers::NONE,
+    })
+}
+
+#[test]
+fn rendered_selection_preserves_unicode_links_and_the_selected_revision() {
+    let area = Rect::new(
+        /*x*/ 0, /*y*/ 2, /*width*/ 30, /*height*/ 1,
+    );
+    let mut buffer = Buffer::empty(area);
+    Line::from(vec![
+        "  ".into(),
+        "café 界 👩‍💻".cyan().underlined(),
+        "  ·  20%…".dim(),
+    ])
+    .render(area, &mut buffer);
+    crate::terminal_hyperlinks::mark_underlined_hyperlink(&mut buffer, area, "https://example.com");
+    let original = buffer.clone();
+    let mut selection = RenderedSelection::default();
+    selection.areas.clear();
+    selection.register(area, /*invalidate*/ false);
+    selection.render(&mut buffer);
+    for event in [
+        mouse(Down(Left), /*column*/ 2, /*row*/ 2),
+        mouse(Drag(Left), /*column*/ 12, /*row*/ 2),
+        mouse(Up(Left), /*column*/ 12, /*row*/ 2),
+    ] {
+        selection.handle_event(&event, &buffer);
+    }
+    assert_eq!(
+        selection.view.selected_text(&selection.cells).as_deref(),
+        Some("café 界 👩‍💻")
+    );
+    buffer.reset();
+    Line::from("  changed · 40%").render(area, &mut buffer);
+    selection.areas.clear();
+    selection.register(area, /*invalidate*/ false);
+    selection.render(&mut buffer);
+    for position in area.positions() {
+        assert_eq!(buffer[position].symbol(), original[position].symbol());
+    }
+    insta::assert_snapshot!(format!("{buffer:?}"));
+    // A new warning must replace the held revision even while the turn keeps running.
+    selection.register(area, /*invalidate*/ true);
+    assert!(!selection.view.has_selection_range());
+}
+
+#[test]
+fn release_copy_and_cross_surface_drags_use_only_visible_text() {
+    let status = Rect::new(
+        /*x*/ 0, /*y*/ 0, /*width*/ 7, /*height*/ 1,
+    );
+    let footer = Rect { y: 1, ..status };
+    let mut buffer = Buffer::empty(status.union(footer));
+    "branch…".render(status, &mut buffer);
+    "? shortcuts".render(footer, &mut buffer);
+    let mut selection = RenderedSelection::default();
+    selection.view.copy_on_select = true;
+    selection.register(status, /*invalidate*/ false);
+    selection.register(footer, /*invalidate*/ false);
+    // Registration retains geometry only: select the final painted cells, not earlier content.
+    "commit…".render(status, &mut buffer);
+    selection.handle_event(&mouse(Down(Left), /*column*/ 0, /*row*/ 0), &buffer);
+    selection.handle_event(&mouse(Drag(Left), /*column*/ 19, /*row*/ 1), &buffer);
+    let Some(RegionAction::Selection(ViewAction::CopyOnSelect(text))) =
+        selection.handle_event(&mouse(Up(Left), /*column*/ 19, /*row*/ 1), &buffer)
+    else {
+        panic!("release must copy the selected status row");
+    };
+    assert_eq!(text, "commit…");
+    assert!(selection.view.has_selection_range());
+    // Collapsing the range keeps keyboard ownership, including Enter, with the footer.
+    for _ in text.chars() {
+        selection.handle_event(&TuiEvent::Key(KeyCode::Left.into()), &buffer);
+    }
+    assert!(!selection.view.has_selection_range());
+    assert!(matches!(
+        selection.handle_event(&TuiEvent::Key(KeyCode::Enter.into()), &buffer),
+        Some(RegionAction::Selection(ViewAction::Changed))
+    ));
+    selection.handle_event(&TuiEvent::Key(KeyCode::Right.into()), &buffer);
+    assert_eq!(
+        selection.view.selected_text(&selection.cells).as_deref(),
+        Some("c")
+    );
+    // Invalidating another visible region must not release this selection.
+    selection.register(footer, /*invalidate*/ true);
+    assert!(selection.view.has_active_interaction());
+    // Find belongs to the app, not a hidden search inside the footer.
+    assert!(
+        selection
+            .handle_event(
+                &TuiEvent::Key(KeyEvent::new(KeyCode::Char('f'), KeyModifiers::CONTROL)),
+                &buffer
+            )
+            .is_none()
+    );
+    assert!(!selection.view.has_active_interaction());
+    // Resize invalidates both the highlight and its pointer anchor.
+    selection.handle_event(&mouse(Down(Left), /*column*/ 0, /*row*/ 1), &buffer);
+    selection.handle_event(&mouse(Drag(Left), /*column*/ 3, /*row*/ 1), &buffer);
+    selection.handle_event(
+        &TuiEvent::Resize(ratatui::layout::Size::new(
+            /*width*/ 10, /*height*/ 2,
+        )),
+        &buffer,
+    );
+    assert!(!selection.view.has_active_interaction());
+}
+
+#[test]
+fn stationary_clicks_are_deferred_but_dragging_back_does_not_activate() {
+    let area = Rect::new(
+        /*x*/ 0, /*y*/ 0, /*width*/ 20, /*height*/ 1,
+    );
+    let mut buffer = Buffer::empty(area);
+    "⚠ 2 warnings".render(area, &mut buffer);
+    let mut selection = RenderedSelection::default();
+    selection.register(area, /*invalidate*/ false);
+    assert!(matches!(
+        selection.handle_event(&mouse(Down(Left), /*column*/ 2, /*row*/ 0), &buffer),
+        Some(RegionAction::Selection(_))
+    ));
+    assert!(matches!(
+        selection.handle_event(&mouse(Up(Left), /*column*/ 2, /*row*/ 0), &buffer),
+        Some(RegionAction::Click(_))
+    ));
+    selection.handle_event(&mouse(Down(Left), /*column*/ 5, /*row*/ 0), &buffer);
+    selection.handle_event(&mouse(Drag(Left), /*column*/ 7, /*row*/ 0), &buffer);
+    assert!(!matches!(
+        selection.handle_event(&mouse(Up(Left), /*column*/ 5, /*row*/ 0), &buffer),
+        Some(RegionAction::Click(_))
+    ));
+    // A stationary click after a selection releases the frozen revision.
+    for event in [
+        mouse(Down(Left), /*column*/ 0, /*row*/ 0),
+        mouse(Drag(Left), /*column*/ 3, /*row*/ 0),
+        mouse(Up(Left), /*column*/ 3, /*row*/ 0),
+    ] {
+        selection.handle_event(&event, &buffer);
+    }
+    assert!(selection.view.has_selection_range());
+    selection.handle_event(&mouse(Down(Left), /*column*/ 10, /*row*/ 0), &buffer);
+    assert!(matches!(
+        selection.handle_event(&mouse(Up(Left), /*column*/ 10, /*row*/ 0), &buffer),
+        Some(RegionAction::Click(_))
+    ));
+    assert!(!selection.view.has_active_interaction());
+}
diff --git a/codex-rs/tui/src/lib.rs b/codex-rs/tui/src/lib.rs
index a30587b3cb..4f7c5fa050 100644
--- a/codex-rs/tui/src/lib.rs
+++ b/codex-rs/tui/src/lib.rs
@@ -173,6 +173,7 @@ mod keymap_setup;
 mod line_truncation;
 pub(crate) mod live_wrap;
 mod local_settings;
+mod rendered_selection;
 pub use live_wrap::RowBuilder;
 mod local_chatgpt_auth;
 mod managed_new_thread_defaults;
diff --git a/codex-rs/tui/src/pager_overlay/transcript.rs b/codex-rs/tui/src/pager_overlay/transcript.rs
index 508d5c34f4..4aaae519b6 100644
--- a/codex-rs/tui/src/pager_overlay/transcript.rs
+++ b/codex-rs/tui/src/pager_overlay/transcript.rs
@@ -452,32 +452,20 @@ impl TranscriptOverlay {
 
     fn apply_action(&mut self, tui: &mut tui::Tui, action: ViewAction) {
         self.notice = None;
-        let resume_following = matches!(action, ViewAction::CopyAndFollow(_));
-        let copy_on_select = matches!(action, ViewAction::CopyOnSelect(_));
-        match action {
-            ViewAction::Changed => {}
-            ViewAction::PrimarySelection(text) => self.view.publish_primary(tui, &text),
-            ViewAction::Copy(text)
-            | ViewAction::CopyOnSelect(text)
-            | ViewAction::CopyAndFollow(text) => {
-                let result = self
-                    .view
-                    .copy_selected_text(tui, &self.cells, &text, !copy_on_select);
-                if resume_following
-                    && matches!(result, Ok(crate::clipboard_copy::CopyStatus::Pending(_)))
-                {
-                    self.view.follow_pending_copy();
-                }
-                self.notice = Some(match result {
-                    Ok(status) => status.message("selection"),
-                    Err(error) => error,
-                });
-            }
-            ViewAction::OpenLink(url) => {
-                if let Err(error) = webbrowser::open(&url) {
-                    self.notice = Some(format!("Could not open link: {error}"));
-                }
-            }
+        if let Some((_, result)) = self.view.copy_action(
+            tui,
+            &self.cells,
+            &action,
+            crate::clipboard_copy::CopyFormat::Markdown,
+        ) {
+            self.notice = Some(match result {
+                Ok(status) => status.message("selection"),
+                Err(error) => error,
+            });
+        } else if let ViewAction::OpenLink(url) = action
+            && let Err(error) = webbrowser::open(&url)
+        {
+            self.notice = Some(format!("Could not open link: {error}"));
         }
     }
 
diff --git a/codex-rs/tui/src/rendered_selection.rs b/codex-rs/tui/src/rendered_selection.rs
new file mode 100644
index 0000000000..4b076a2378
--- /dev/null
+++ b/codex-rs/tui/src/rendered_selection.rs
@@ -0,0 +1,193 @@
+//! Read-only selection for regions registered by the last owned-screen render.
+//! Widgets register painted rectangles, and may invalidate their own region when its meaning
+//! changes. Only the clicked rectangle is captured from the completed terminal frame; other
+//! regions remain live. Gestures, keyboard selection and clipboard tickets use TranscriptView.
+
+use crate::history_cell::HistoryCell;
+use crate::history_cell::PlainHistoryCell;
+use crate::transcript_view::TranscriptView;
+use crate::transcript_view::ViewAction;
+use crate::tui::TuiEvent;
+use crossterm::event::KeyEventKind;
+use crossterm::event::MouseButton;
+use crossterm::event::MouseEvent;
+use crossterm::event::MouseEventKind;
+use ratatui::buffer::Buffer;
+use ratatui::buffer::CellWidth;
+use ratatui::layout::Position;
+use ratatui::layout::Rect;
+use ratatui::text::Line;
+use ratatui::text::Span;
+use std::sync::Arc;
+
+#[derive(Default)]
+pub(crate) struct RenderedSelection {
+    pub(crate) view: TranscriptView,
+    pub(crate) cells: Vec<Arc<dyn HistoryCell>>,
+    pub(crate) areas: Vec<Rect>,
+    snapshot: Option<Buffer>,
+    pressed: Option<MouseEvent>,
+}
+
+pub(crate) enum RegionAction {
+    Selection(ViewAction),
+    // Replay clickable decorations only after a stationary release.
+    Click(MouseEvent),
+}
+
+impl RenderedSelection {
+    fn clear(&mut self) {
+        self.view.jump_to_latest();
+        self.snapshot = None;
+        self.pressed = None;
+    }
+
+    /// Register a painted, passive region. Invalidation affects only a selection in this region.
+    pub(crate) fn register(&mut self, area: Rect, invalidate: bool) {
+        if invalidate
+            && self
+                .snapshot
+                .as_ref()
+                .is_some_and(|snapshot| snapshot.area == area)
+        {
+            self.clear();
+        }
+        if !area.is_empty() {
+            self.areas.push(area);
+        }
+    }
+
+    pub(crate) fn render(&mut self, buffer: &mut Buffer) {
+        if self
+            .snapshot
+            .as_ref()
+            .is_some_and(|snapshot| !self.areas.contains(&snapshot.area))
+        {
+            self.clear();
+        }
+        if !self.view.has_active_interaction() {
+            self.snapshot = None;
+        }
+        if let Some(snapshot) = &self.snapshot {
+            self.view.render(snapshot.area, buffer, &self.cells);
+            // Keep native hyperlinks and forced glyph widths from the original cells.
+            for position in snapshot.area.positions() {
+                buffer[position].set_symbol(snapshot[position].symbol());
+                buffer[position].diff_option = snapshot[position].diff_option;
+            }
+        }
+    }
+
+    pub(crate) fn needs_refresh(&self, event: MouseEvent) -> bool {
+        event.kind != MouseEventKind::Moved
+            && self
+                .areas
+                .iter()
+                .any(|area| area.contains(Position::new(event.column, event.row)))
+    }
+
+    pub(crate) fn handle_event(
+        &mut self,
+        event: &TuiEvent,
+        completed: &Buffer,
+    ) -> Option<RegionAction> {
+        match event {
+            TuiEvent::Mouse(mouse) => return self.handle_mouse(*mouse, completed),
+            TuiEvent::Key(key) if key.kind == KeyEventKind::Release => return None,
+            TuiEvent::Key(key) if self.view.has_active_interaction() => {
+                if let Some(action) = self.view.handle_selection_key(*key, &self.cells) {
+                    return Some(RegionAction::Selection(action));
+                }
+            }
+            TuiEvent::Key(_)
+            | TuiEvent::Paste(_)
+            | TuiEvent::Resize(_)
+            | TuiEvent::FocusLost
+            | TuiEvent::Resume => {}
+            TuiEvent::Draw | TuiEvent::FocusGained => return None,
+        }
+        self.clear();
+        None
+    }
+
+    fn handle_mouse(&mut self, mut event: MouseEvent, completed: &Buffer) -> Option<RegionAction> {
+        match event.kind {
+            MouseEventKind::Down(MouseButton::Left) => {
+                let position = Position::new(event.column, event.row);
+                let Some(area) = self
+                    .areas
+                    .iter()
+                    .copied()
+                    .find(|area| area.contains(position))
+                else {
+                    self.clear();
+                    return None;
+                };
+                if self
+                    .snapshot
+                    .as_ref()
+                    .is_none_or(|snapshot| snapshot.area != area)
+                {
+                    self.view.jump_to_latest();
+                    let area = area.intersection(completed.area);
+                    let mut surface = Buffer::empty(area);
+                    for position in area.positions() {
+                        surface[position] = completed[position].clone();
+                    }
+                    self.cells = vec![Arc::new(PlainHistoryCell::new(surface_lines(&surface)))];
+                    self.view.render(area, &mut surface.clone(), &self.cells);
+                    self.snapshot = Some(surface);
+                }
+                self.pressed = Some(event);
+            }
+            MouseEventKind::Drag(MouseButton::Left) => self.pressed = None,
+            MouseEventKind::Up(MouseButton::Left) => {
+                if let Some(pressed) = self.pressed.take()
+                    && (pressed.column, pressed.row) == (event.column, event.row)
+                    && !self.view.has_selection_range()
+                {
+                    self.view.end_selection(&self.cells);
+                    return Some(RegionAction::Click(pressed));
+                }
+            }
+            MouseEventKind::ScrollUp | MouseEventKind::ScrollDown => {
+                self.clear();
+                return None;
+            }
+            _ => {}
+        }
+        let snapshot = self.snapshot.as_ref()?;
+        if matches!(event.kind, MouseEventKind::Drag(_) | MouseEventKind::Up(_)) {
+            event.column = event.column.clamp(snapshot.area.x, snapshot.area.right());
+            event.row = event.row.clamp(snapshot.area.y, snapshot.area.bottom() - 1);
+        }
+        self.view
+            .handle_mouse(event, &self.cells)
+            .map(RegionAction::Selection)
+    }
+}
+
+fn surface_lines(surface: &Buffer) -> Vec<Line<'static>> {
+    (surface.area.y..surface.area.bottom())
+        .map(|row| {
+            let mut spans = Vec::new();
+            let mut column = surface.area.x;
+            while column < surface.area.right() {
+                let cell = &surface[(column, row)];
+                spans.push(Span::styled(
+                    codex_ansi_escape::ansi_escape_line(cell.symbol()).to_string(),
+                    cell.style(),
+                ));
+                column += cell.cell_width().max(/*other*/ 1);
+            }
+            while spans.last().is_some_and(|span| span.content == " ") {
+                spans.pop();
+            }
+            Line::from(spans)
+        })
+        .collect()
+}
+
+#[cfg(test)]
+#[path = "footer_selection_tests.rs"]
+mod tests;
diff --git a/codex-rs/tui/src/snapshots/codex_tui__rendered_selection__tests__rendered_selection_preserves_unicode_links_and_the_selected_revision.snap b/codex-rs/tui/src/snapshots/codex_tui__rendered_selection__tests__rendered_selection_preserves_unicode_links_and_the_selected_revision.snap
new file mode 100644
index 0000000000..cb5dcda8f8
--- /dev/null
+++ b/codex-rs/tui/src/snapshots/codex_tui__rendered_selection__tests__rendered_selection_preserves_unicode_links_and_the_selected_revision.snap
@@ -0,0 +1,20 @@
+---
+source: tui/src/footer_selection_tests.rs
+assertion_line: 38
+expression: "format!(\"{buffer:?}\")"
+---
+Buffer {
+    area: Rect { x: 0, y: 2, width: 30, height: 1 },
+    content: [
+        "  ]8;;https://example.comc]8;;]8;;https://example.coma]8;;]8;;https://example.comf]8;;]8;;https://example.comé]8;; ]8;;https://example.com界]8;; ]8;;https://example.com👩‍💻]8;;  ·  20%…         ", // hidden by multi-width symbols: [(8, " "), (11, " ")]
+    ],
+    styles: [
+        x: 0, y: 0, fg: Reset, bg: Reset, underline: Reset, modifier: NONE,
+        x: 2, y: 0, fg: Cyan, bg: Reset, underline: Reset, modifier: UNDERLINED | REVERSED,
+        x: 8, y: 0, fg: Reset, bg: Reset, underline: Reset, modifier: REVERSED,
+        x: 9, y: 0, fg: Cyan, bg: Reset, underline: Reset, modifier: UNDERLINED | REVERSED,
+        x: 11, y: 0, fg: Reset, bg: Reset, underline: Reset, modifier: REVERSED,
+        x: 12, y: 0, fg: Reset, bg: Reset, underline: Reset, modifier: DIM,
+        x: 21, y: 0, fg: Reset, bg: Reset, underline: Reset, modifier: NONE,
+    ]
+}
diff --git a/codex-rs/tui/src/transcript_view/input.rs b/codex-rs/tui/src/transcript_view/input.rs
index ced88a72b0..8b1c759a25 100644
--- a/codex-rs/tui/src/transcript_view/input.rs
+++ b/codex-rs/tui/src/transcript_view/input.rs
@@ -345,7 +345,7 @@ impl TranscriptView {
         Some(ViewAction::Changed)
     }
 
-    fn handle_selection_key(
+    pub(crate) fn handle_selection_key(
         &mut self,
         key: KeyEvent,
         cells: &[Arc<dyn HistoryCell>],
diff --git a/codex-rs/tui/src/transcript_view/selection.rs b/codex-rs/tui/src/transcript_view/selection.rs
index 8e62595d3a..f62b427fb2 100644
--- a/codex-rs/tui/src/transcript_view/selection.rs
+++ b/codex-rs/tui/src/transcript_view/selection.rs
@@ -284,38 +284,6 @@ impl TranscriptView {
         }
     }
 
-    /// Both transcript surfaces honor the same automatic-copy and plaintext PRIMARY semantics.
-    pub(crate) fn copy_selected_text(
-        &mut self,
-        tui: &mut Tui,
-        cells: &[Arc<dyn HistoryCell>],
-        text: &str,
-        clear_selection: bool,
-    ) -> CopyResult {
-        let publish_primary = !clear_selection && self.primary_selection;
-        let mut primary_owner = None;
-        let result =
-            self.copy_selected_text_with(cells, text, clear_selection, |copy_text, format| {
-                if publish_primary {
-                    let (result, owner) = tui.clipboard.select(
-                        copy_text.into(),
-                        format,
-                        CopyDestination::ClipboardAndPrimary(text.into()),
-                        tui.frame_requester(),
-                    );
-                    primary_owner = Some(owner);
-                    result
-                } else {
-                    tui.clipboard
-                        .copy(copy_text.into(), format, tui.frame_requester())
-                }
-            });
-        if publish_primary && let Some(selection) = &mut self.selection {
-            selection.primary_owner = primary_owner;
-        }
-        result
-    }
-
     /// Hide or cancel deferred publication without relinquishing the existing X11 selection.
     pub(crate) fn cancel_primary(&mut self) {
         if let Some(selection) = &mut self.selection {
@@ -405,6 +373,66 @@ impl TranscriptView {
         result
     }
 
+    /// Apply selection copy keys consistently in owned, overlay and rendered-region views.
+    /// Plain UI regions keep their visible text; transcript copies retain Markdown metadata.
+    /// PRIMARY is always plaintext, and automatic copies update both X11 selections.
+    pub(crate) fn copy_action(
+        &mut self,
+        tui: &mut Tui,
+        cells: &[Arc<dyn HistoryCell>],
+        action: &ViewAction,
+        format: crate::clipboard_copy::CopyFormat,
+    ) -> Option<(usize, CopyResult)> {
+        use crate::clipboard_copy::CopyFormat;
+        use crate::clipboard_copy::CopyStatus;
+
+        let text = match action {
+            ViewAction::Copy(text)
+            | ViewAction::CopyOnSelect(text)
+            | ViewAction::CopyAndFollow(text) => text.as_str(),
+            ViewAction::PrimarySelection(text) => {
+                self.publish_primary(tui, text);
+                return None;
+            }
+            ViewAction::Changed | ViewAction::OpenLink(_) => return None,
+        };
+        let clear_selection = !matches!(action, ViewAction::CopyOnSelect(_));
+        let publish_primary = !clear_selection && self.primary_selection;
+        let mut primary_owner = None;
+        let result =
+            self.copy_selected_text_with(cells, text, clear_selection, |rich, rich_format| {
+                let (copy_text, format) = match format {
+                    CopyFormat::PlainText => (text, CopyFormat::PlainText),
+                    CopyFormat::Markdown => (rich, rich_format),
+                    CopyFormat::MarkdownSelection(source) => {
+                        (text, CopyFormat::MarkdownSelection(source))
+                    }
+                };
+                if publish_primary {
+                    let (result, owner) = tui.clipboard.select(
+                        copy_text.into(),
+                        format,
+                        CopyDestination::ClipboardAndPrimary(text.into()),
+                        tui.frame_requester(),
+                    );
+                    primary_owner = Some(owner);
+                    result
+                } else {
+                    tui.clipboard
+                        .copy(copy_text.into(), format, tui.frame_requester())
+                }
+            });
+        if publish_primary && let Some(selection) = &mut self.selection {
+            selection.primary_owner = primary_owner;
+        }
+        if matches!(action, ViewAction::CopyAndFollow(_))
+            && matches!(result, Ok(CopyStatus::Pending(_)))
+        {
+            self.follow_pending_copy();
+        }
+        Some((text.chars().count(), result))
+    }
+
     pub(crate) fn follow_pending_copy(&mut self) {
         if let Some(pending) = self
             .selection