Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Add keyboard copy selection to the owned transcript (#50434)

Benjamin Carlssonc536ffcb1827
diff --git a/codex-rs/tui/src/app/agent_message_consolidation.rs b/codex-rs/tui/src/app/agent_message_consolidation.rs
index 4b8120185d..bf1627c998 100644
--- a/codex-rs/tui/src/app/agent_message_consolidation.rs
+++ b/codex-rs/tui/src/app/agent_message_consolidation.rs
@@ -8,7 +8,6 @@
//! resize re-renders. The retained view preserves its displayed revision before that
//! replacement, then repaints without replaying terminal scrollback.
-use std::path::PathBuf;
use std::sync::Arc;
use color_eyre::eyre::Result;
@@ -18,7 +17,6 @@ use super::resize_reflow::trailing_run_start;
use crate::app_event::ConsolidationScrollbackReflow;
use crate::history_cell;
use crate::history_cell::HistoryCell;
-use crate::inline_visualization::InlineVisualizationContext;
use crate::pager_overlay::Overlay;
use crate::tui;
@@ -26,9 +24,7 @@ impl App {
pub(super) fn handle_consolidate_agent_message(
&mut self,
tui: &mut tui::Tui,
- source: String,
- cwd: PathBuf,
- inline_visualization_context: Option<InlineVisualizationContext>,
+ source: history_cell::AgentMarkdownCell,
scrollback_reflow: ConsolidationScrollbackReflow,
deferred_history_cell: Option<Box<dyn HistoryCell>>,
) -> Result<()> {
@@ -51,20 +47,14 @@ impl App {
let end = self.transcript_cells.len();
tracing::debug!(
"ConsolidateAgentMessage: transcript_cells.len()={end}, source_len={}",
- source.len()
+ source.copy_source().map_or(/*default*/ 0, str::len)
);
let start = trailing_run_start::<history_cell::AgentMessageCell>(&self.transcript_cells);
if start < end {
tracing::debug!(
"ConsolidateAgentMessage: replacing cells [{start}..{end}] with AgentMarkdownCell"
);
- let consolidated: Arc<dyn HistoryCell> = Arc::new(
- history_cell::AgentMarkdownCell::new_with_inline_visualizations(
- source,
- &cwd,
- inline_visualization_context,
- ),
- );
+ let consolidated: Arc<dyn HistoryCell> = Arc::new(source);
self.native_history
.consolidate(&self.transcript_cells[start..end], &consolidated);
if tui.is_owned_screen() {
diff --git a/codex-rs/tui/src/app/event_dispatch.rs b/codex-rs/tui/src/app/event_dispatch.rs
index f59717f3de..97d06f9268 100644
--- a/codex-rs/tui/src/app/event_dispatch.rs
+++ b/codex-rs/tui/src/app/event_dispatch.rs
@@ -56,6 +56,8 @@ impl App {
| AppEvent::CopyWarning(_)
| AppEvent::UpdateWarnings { .. }
| AppEvent::CopySelection { .. }
+ | AppEvent::SelectTranscriptCopy { .. }
+ | AppEvent::TranscriptCopyClosed
| AppEvent::ConfirmDaemonUpdate(_)
| AppEvent::RunDaemonUpdate(_)
| AppEvent::InsertHistoryCell(_)
@@ -391,6 +393,17 @@ impl App {
self.chat_widget.maybe_send_next_queued_input();
}
}
+ AppEvent::TranscriptCopyClosed => {
+ self.chat_widget.maybe_send_next_queued_input();
+ }
+ AppEvent::SelectTranscriptCopy { guard } => {
+ let size = tui.prepare_draw_size()?;
+ self.render_owned_transcript(tui, size)?;
+ if !self.transcript_view.begin_copy_mode(&self.transcript_cells, Some(guard)) {
+ self.chat_widget.add_info_message("Nothing to copy".into(), /*hint*/ None);
+ }
+ tui.frame_requester().schedule_frame();
+ }
AppEvent::CopySelection { text, label, format } => {
let result = tui.clipboard.copy(text, format, tui.frame_requester());
self.chat_widget.show_copy_result(&label, result);
@@ -879,6 +892,7 @@ impl App {
}
AppEvent::ConsolidateAgentMessage {
source,
+ copy_source,
cwd,
inline_visualization_context,
scrollback_reflow,
@@ -886,9 +900,7 @@ impl App {
} => {
self.handle_consolidate_agent_message(
tui,
- source,
- cwd,
- inline_visualization_context,
+ history_cell::AgentMarkdownCell::new_with_inline_visualizations(source, &cwd, inline_visualization_context).with_copy_source(copy_source),
scrollback_reflow,
deferred_history_cell,
)?;
diff --git a/codex-rs/tui/src/app/owned_transcript.rs b/codex-rs/tui/src/app/owned_transcript.rs
index 26a570b4e0..1db2c4b80d 100644
--- a/codex-rs/tui/src/app/owned_transcript.rs
+++ b/codex-rs/tui/src/app/owned_transcript.rs
@@ -568,8 +568,6 @@ impl App {
&text,
!copy_on_select,
);
- self.transcript_view
- .show_copy_feedback(&result, text.chars().count());
if resume_following
&& matches!(result, Ok(crate::clipboard_copy::CopyStatus::Pending(_)))
{
diff --git a/codex-rs/tui/src/app/owned_transcript_tests.rs b/codex-rs/tui/src/app/owned_transcript_tests.rs
index 009b47fdc7..38f1954692 100644
--- a/codex-rs/tui/src/app/owned_transcript_tests.rs
+++ b/codex-rs/tui/src/app/owned_transcript_tests.rs
@@ -178,9 +178,10 @@ async fn list_spacing_completion_preserves_the_scrolled_reader() -> Result<()> {
assert!(buffer_text(&before).contains("• c"));
app.handle_consolidate_agent_message(
&mut tui,
- "- First item wraps onto a second row\n- b\n- c".into(),
- app.config.cwd.to_path_buf(),
- /*inline_visualization_context*/ None,
+ crate::history_cell::AgentMarkdownCell::new(
+ "- First item wraps onto a second row\n- b\n- c".into(),
+ &app.config.cwd,
+ ),
ConsolidationScrollbackReflow::Required,
/*deferred_history_cell*/ None,
)?;
diff --git a/codex-rs/tui/src/app/tests.rs b/codex-rs/tui/src/app/tests.rs
index 2c900b72fd..4c68189bd9 100644
--- a/codex-rs/tui/src/app/tests.rs
+++ b/codex-rs/tui/src/app/tests.rs
@@ -1,5 +1,7 @@
//! App-level orchestration tests for the TUI.
+#[path = "tests/copy_mode_tests.rs"]
+mod copy_mode_tests;
#[path = "tests/mcp_login_tests.rs"]
mod mcp_login_tests;
@@ -6868,6 +6870,8 @@ async fn closing_fullscreen_inline_overlay_restores_history_once() -> Result<()>
#[tokio::test]
async fn copy_picker_opening_preserves_terminal_scrollback_without_reflow() {
let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await;
+ app.chat_widget.local_settings.transcript_mode =
+ crate::transcript_mode::TranscriptMode::Terminal;
let response = "Existing response\n\n```rust\nkeep_scrollback();\n```";
app.chat_widget.handle_server_notification(
ServerNotification::ItemCompleted(codex_app_server_protocol::ItemCompletedNotification {
@@ -7066,9 +7070,7 @@ async fn directive_only_completion_removes_streamed_directive() -> Result<()> {
let mut tui = crate::tui::test_support::make_test_tui()?;
app.handle_consolidate_agent_message(
&mut tui,
- String::new(),
- PathBuf::from("/tmp"),
- /*inline_visualization_context*/ None,
+ AgentMarkdownCell::new(String::new(), Path::new("/tmp")),
ConsolidationScrollbackReflow::Required,
/*deferred_history_cell*/ None,
)?;
@@ -7111,10 +7113,11 @@ async fn required_stream_reflow_during_capped_initial_replay_survives_transcript
let mut tui = crate::tui::test_support::make_test_tui()?;
app.handle_consolidate_agent_message(
&mut tui,
- "Final answer:\n\n| Pattern | Outcome |\n| --- | --- |\n| Table tail | Preserved |"
- .to_string(),
- PathBuf::from("/tmp"),
- /*inline_visualization_context*/ None,
+ AgentMarkdownCell::new(
+ "Final answer:\n\n| Pattern | Outcome |\n| --- | --- |\n| Table tail | Preserved |"
+ .into(),
+ Path::new("/tmp"),
+ ),
ConsolidationScrollbackReflow::Required,
/*deferred_history_cell*/ None,
)?;
diff --git a/codex-rs/tui/src/app/tests/copy_mode_tests.rs b/codex-rs/tui/src/app/tests/copy_mode_tests.rs
new file mode 100644
index 0000000000..ff360f0043
--- /dev/null
+++ b/codex-rs/tui/src/app/tests/copy_mode_tests.rs
@@ -0,0 +1,30 @@
+//! Exercise copy entry through the app dispatcher, including an empty transcript.
+
+use super::*;
+
+#[tokio::test]
+async fn empty_owned_copy_reports_feedback() -> Result<()> {
+ let (mut app, mut rx, _op_rx) = make_test_app_with_channels().await;
+ let mut app_server = start_config_write_test_app_server(&app).await?;
+ let mut tui = crate::tui::test_support::make_test_tui()?;
+ let guard = Arc::new(crate::copy_input_guard::CopyInputGuard(
+ app.app_event_tx.clone(),
+ ));
+ app.handle_event(
+ &mut tui,
+ &mut app_server,
+ AppEvent::SelectTranscriptCopy { guard },
+ )
+ .await?;
+ let lines = std::iter::from_fn(|| rx.try_recv().ok())
+ .filter_map(|event| match event {
+ AppEvent::InsertHistoryCell(cell) => Some(cell.display_lines(/*width*/ 80)),
+ _ => None,
+ })
+ .flatten()
+ .map(|line| line.to_string())
+ .collect::<Vec<_>>()
+ .join("\n");
+ insta::assert_snapshot!(lines, @"• Nothing to copy");
+ Ok(())
+}
diff --git a/codex-rs/tui/src/app/tests/user_verification_routes_tests.rs b/codex-rs/tui/src/app/tests/user_verification_routes_tests.rs
index 6fcd5a22b5..9af0abbc93 100644
--- a/codex-rs/tui/src/app/tests/user_verification_routes_tests.rs
+++ b/codex-rs/tui/src/app/tests/user_verification_routes_tests.rs
@@ -268,6 +268,7 @@ async fn inactive_thread_user_verification_preserves_foreground_stream() -> Resu
AppEvent::InsertHistoryCell(cell) => app.insert_history_cell(&mut tui, cell),
AppEvent::ConsolidateAgentMessage {
source,
+ copy_source,
cwd,
inline_visualization_context,
scrollback_reflow,
@@ -276,9 +277,12 @@ async fn inactive_thread_user_verification_preserves_foreground_stream() -> Resu
completed_messages.push(source.clone());
app.handle_consolidate_agent_message(
&mut tui,
- source,
- cwd,
- inline_visualization_context,
+ history_cell::AgentMarkdownCell::new_with_inline_visualizations(
+ source,
+ &cwd,
+ inline_visualization_context,
+ )
+ .with_copy_source(copy_source),
scrollback_reflow,
deferred_history_cell,
)?;
diff --git a/codex-rs/tui/src/app_event.rs b/codex-rs/tui/src/app_event.rs
index 88a8a74514..910d203646 100644
--- a/codex-rs/tui/src/app_event.rs
+++ b/codex-rs/tui/src/app_event.rs
@@ -474,6 +474,14 @@ pub(crate) enum AppEvent {
destination: TranscriptExportDestination,
},
+ /// Select a response or block directly in the owned transcript.
+ SelectTranscriptCopy {
+ guard: Arc<crate::copy_input_guard::CopyInputGuard>,
+ },
+
+ /// Retry queued input after the transcript copy owner is released.
+ TranscriptCopyClosed,
+
/// Copy text through the session clipboard worker.
CopySelection {
text: Arc<str>,
@@ -1166,6 +1174,7 @@ pub(crate) enum AppEvent {
/// transcript without first writing its provisional render to scrollback.
ConsolidateAgentMessage {
source: String,
+ copy_source: Option<String>,
cwd: PathBuf,
inline_visualization_context: Option<InlineVisualizationContext>,
scrollback_reflow: ConsolidationScrollbackReflow,
diff --git a/codex-rs/tui/src/chatwidget/copy_picker.rs b/codex-rs/tui/src/chatwidget/copy_picker.rs
index f67f88dcbf..c41d40b26e 100644
--- a/codex-rs/tui/src/chatwidget/copy_picker.rs
+++ b/codex-rs/tui/src/chatwidget/copy_picker.rs
@@ -8,6 +8,17 @@ use crate::text_formatting::truncate_text;
impl ChatWidget {
pub(super) fn show_copy_picker(&mut self) {
+ if self.local_settings.transcript_mode.is_owned()
+ && self.transcript.last_status_copy_targets.is_none()
+ {
+ let guard = Arc::new(crate::copy_input_guard::CopyInputGuard(
+ self.app_event_tx.clone(),
+ ));
+ self.input_queue.transcript_copy = Arc::downgrade(&guard);
+ self.app_event_tx
+ .send(AppEvent::SelectTranscriptCopy { guard });
+ return;
+ }
let mut choices = Vec::new();
if let Some(status_targets) = &self.transcript.last_status_copy_targets {
choices.push((
diff --git a/codex-rs/tui/src/chatwidget/input_flow.rs b/codex-rs/tui/src/chatwidget/input_flow.rs
index 7b841baf64..6ee018ed4c 100644
--- a/codex-rs/tui/src/chatwidget/input_flow.rs
+++ b/codex-rs/tui/src/chatwidget/input_flow.rs
@@ -60,7 +60,7 @@ impl ChatWidget {
self.app_event_tx.send(AppEvent::FollowTranscript);
let should_submit_now = self.is_session_configured()
&& !self.is_plan_streaming_in_tui()
- && !self.input_queue.suppress_queue_autosend
+ && !self.input_queue.submissions_paused()
&& !self.input_queue.rate_limit_recovery_pending
&& (!self.input_queue.user_turn_pending_start
|| self.turn_lifecycle.agent_turn_running);
@@ -170,7 +170,7 @@ impl ChatWidget {
}
let should_run_now = self.is_session_configured()
&& !self.is_user_turn_pending_or_running()
- && !self.input_queue.suppress_queue_autosend
+ && !self.input_queue.submissions_paused()
&& !self.input_queue.rate_limit_recovery_pending;
if action != QueuedInputAction::ParseSlash {
self.empty_state_animation.borrow_mut().dismiss();
@@ -237,7 +237,7 @@ impl ChatWidget {
if !self.is_session_configured()
|| self.fork_in_progress
|| self.has_misalignment_policy_violation()
- || self.input_queue.suppress_queue_autosend
+ || self.input_queue.submissions_paused()
|| self.input_queue.rate_limit_recovery_pending
|| self.input_queue.recovered_queue
|| self.input_queue.has_unconfirmed_messages()
diff --git a/codex-rs/tui/src/chatwidget/input_queue.rs b/codex-rs/tui/src/chatwidget/input_queue.rs
index 13600b2d86..bdaedab6ca 100644
--- a/codex-rs/tui/src/chatwidget/input_queue.rs
+++ b/codex-rs/tui/src/chatwidget/input_queue.rs
@@ -49,6 +49,7 @@ pub(super) struct InputQueueState {
/// fresh user turn instead of restoring them into the composer.
pub(super) submit_pending_steers_after_interrupt: bool,
pub(super) suppress_queue_autosend: bool,
+ pub(super) transcript_copy: std::sync::Weak<crate::copy_input_guard::CopyInputGuard>,
/// Hold submissions while a usage failure or backend-directed model fallback is resolved.
pub(super) rate_limit_recovery_pending: bool,
/// Pause for user recovery (for example an image or permission failure), independent of delivery.
@@ -56,6 +57,10 @@ pub(super) struct InputQueueState {
}
impl InputQueueState {
+ pub(super) fn submissions_paused(&self) -> bool {
+ self.suppress_queue_autosend || self.transcript_copy.strong_count() > 0
+ }
+
pub(super) fn has_unconfirmed_messages(&self) -> bool {
self.queued_user_messages
.iter()
diff --git a/codex-rs/tui/src/chatwidget/questions.rs b/codex-rs/tui/src/chatwidget/questions.rs
index 37e32211dd..83884b3228 100644
--- a/codex-rs/tui/src/chatwidget/questions.rs
+++ b/codex-rs/tui/src/chatwidget/questions.rs
@@ -133,7 +133,7 @@ impl ChatWidget {
}
let main = self.bottom_pane.composer_draft_snapshot();
let accepted = if queued
- || self.input_queue.suppress_queue_autosend
+ || self.input_queue.submissions_paused()
|| self.is_plan_streaming_in_tui()
|| self.input_queue.user_turn_pending_start
&& !self.turn_lifecycle.agent_turn_running
diff --git a/codex-rs/tui/src/chatwidget/startup_submission.rs b/codex-rs/tui/src/chatwidget/startup_submission.rs
index 6d9deb7856..7c2f0cab79 100644
--- a/codex-rs/tui/src/chatwidget/startup_submission.rs
+++ b/codex-rs/tui/src/chatwidget/startup_submission.rs
@@ -51,7 +51,7 @@ impl ChatWidget {
|| self.startup_submission_has_protected_input()
|| self.is_plan_streaming_in_tui()
|| self.is_user_turn_pending_or_running()
- || self.input_queue.suppress_queue_autosend
+ || self.input_queue.submissions_paused()
|| self.input_queue.rate_limit_recovery_pending
|| self.input_queue.recovered_queue
|| self.input_queue.has_unconfirmed_messages()
diff --git a/codex-rs/tui/src/chatwidget/streaming.rs b/codex-rs/tui/src/chatwidget/streaming.rs
index 02491ee761..3fb130d563 100644
--- a/codex-rs/tui/src/chatwidget/streaming.rs
+++ b/codex-rs/tui/src/chatwidget/streaming.rs
@@ -89,7 +89,10 @@ impl ChatWidget {
let needs_scrollback_reflow = controller.needs_scrollback_reflow();
self.clear_active_stream_tail();
let (cell, streamed_source) = controller.finalize();
- let completed_message_differs = completed_message.is_some_and(|completed| {
+ let completed_display = completed_message.map(|source| {
+ parse_assistant_markdown(source, self.config.cwd.as_path()).visible_markdown
+ });
+ let completed_message_differs = completed_display.as_deref().is_some_and(|completed| {
let Some(streamed) = streamed_source.as_deref() else {
return true;
};
@@ -117,10 +120,9 @@ impl ChatWidget {
};
// Consolidate the run of streaming AgentMessageCells into a single AgentMarkdownCell
// that can re-render from source on resize.
- let source = completed_message.map(str::to_owned).or_else(|| {
- streamed_source.map(|source| {
- parse_assistant_markdown(&source, self.config.cwd.as_path()).visible_markdown
- })
+ let copy_source = completed_message.map(str::to_owned).or(streamed_source);
+ let source = copy_source.as_deref().map(|source| {
+ parse_assistant_markdown(source, self.config.cwd.as_path()).visible_markdown
});
if let Some(source) = source {
let inline_visualization_context = self.thread_id.and_then(|thread_id| {
@@ -132,6 +134,7 @@ impl ChatWidget {
self.note_stream_consolidation_queued();
self.app_event_tx.send(AppEvent::ConsolidateAgentMessage {
source,
+ copy_source,
cwd: self.config.cwd.to_path_buf(),
inline_visualization_context,
scrollback_reflow,
@@ -189,7 +192,9 @@ impl ChatWidget {
&& let Some(message) = message
&& !message.is_empty()
{
- self.handle_streaming_delta(message.to_string());
+ let displayed =
+ parse_assistant_markdown(message, self.config.cwd.as_path()).visible_markdown;
+ self.handle_streaming_delta(displayed);
}
// Item completion is authoritative. Use it for consolidation so any
// deltas dropped by a saturated transport cannot truncate the transcript.
@@ -439,12 +444,13 @@ impl ChatWidget {
parsed.visible_markdown.clone(),
self.config.cwd.as_path(),
context,
- ),
+ )
+ .with_copy_source(Some(message.clone())),
);
self.handle_stream_finished();
self.request_redraw();
} else {
- self.finalize_completed_assistant_message(Some(parsed.visible_markdown.as_str()));
+ self.finalize_completed_assistant_message(Some(&message));
}
if !parsed.visible_markdown.is_empty() {
self.transcript
diff --git a/codex-rs/tui/src/chatwidget/tests/copy_export_picker_tests.rs b/codex-rs/tui/src/chatwidget/tests/copy_export_picker_tests.rs
index ad9631c072..4c2cab5b58 100644
--- a/codex-rs/tui/src/chatwidget/tests/copy_export_picker_tests.rs
+++ b/codex-rs/tui/src/chatwidget/tests/copy_export_picker_tests.rs
@@ -8,6 +8,7 @@ use pretty_assertions::assert_eq;
#[tokio::test]
async fn whole_response_copy_uses_followup_labels() {
let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.local_settings.transcript_mode = crate::transcript_mode::TranscriptMode::Terminal;
let directive = r#":codex-followup[**Inspect items[0]**]{prompt="private"}"#;
let literal =
format!("\n\n`{directive}`\n\n```text\n{directive}\n```\n\n:codex-followup[unfinished");
@@ -37,6 +38,7 @@ async fn whole_response_copy_uses_followup_labels() {
#[tokio::test]
async fn completed_response_copy_preserves_markdown_line_endings() {
let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.local_settings.transcript_mode = crate::transcript_mode::TranscriptMode::Terminal;
let markdown = "Hard break: \nstarts a new line.\n\n```text\ncode with trailing spaces \n```";
replay_agent_message(
&mut chat,
@@ -59,6 +61,7 @@ async fn completed_response_copy_preserves_markdown_line_endings() {
#[tokio::test]
async fn copy_export_picker_custom_keys_preserve_payloads_and_composer_draft() {
let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.local_settings.transcript_mode = crate::transcript_mode::TranscriptMode::Terminal;
let mut keymap = crate::keymap::RuntimeKeymap::defaults();
keymap.list.accept = vec![key_hint::plain(KeyCode::F(/*n*/ 3))];
keymap.list.cancel = vec![key_hint::plain(KeyCode::F(/*n*/ 2))];
@@ -127,3 +130,41 @@ async fn copy_export_picker_custom_keys_preserve_payloads_and_composer_draft() {
assert!(chat.no_modal_or_popup_active());
assert_eq!(chat.bottom_pane.composer_text(), "Keep this draft");
}
+
+#[tokio::test]
+async fn owned_copy_opens_transcript_selection() {
+ let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.local_settings.transcript_mode = crate::transcript_mode::TranscriptMode::Owned;
+ let markdown = "Latest **response**\n\n```sh\necho hello \n```";
+ chat.transcript.last_agent_markdown = Some(markdown.into());
+ chat.show_copy_picker();
+ assert!(
+ std::iter::from_fn(|| rx.try_recv().ok())
+ .any(|event| matches!(event, AppEvent::SelectTranscriptCopy { .. }))
+ );
+ assert!(chat.no_modal_or_popup_active());
+}
+
+#[tokio::test]
+async fn completed_copy_source_survives_replay_and_stream_consolidation() {
+ let source = "Intro\r\n\r\n```sh\r\necho x \r\n```\r\n";
+ for replay in [false, true] {
+ let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ if replay {
+ replay_agent_message(&mut chat, "source", source, ReplayKind::ThreadSnapshot);
+ } else {
+ complete_assistant_message(
+ &mut chat,
+ "source",
+ source,
+ Some(MessagePhase::FinalAnswer),
+ );
+ }
+ let retained = std::iter::from_fn(|| rx.try_recv().ok()).find_map(|event| match event {
+ AppEvent::InsertHistoryCell(cell) => cell.copy_source().map(str::to_owned),
+ AppEvent::ConsolidateAgentMessage { copy_source, .. } => copy_source,
+ _ => None,
+ });
+ assert_eq!(retained.as_deref(), Some(source));
+ }
+}
diff --git a/codex-rs/tui/src/chatwidget/tests/slash_commands.rs b/codex-rs/tui/src/chatwidget/tests/slash_commands.rs
index e5e20e2db9..bc1ba4e4fe 100644
--- a/codex-rs/tui/src/chatwidget/tests/slash_commands.rs
+++ b/codex-rs/tui/src/chatwidget/tests/slash_commands.rs
@@ -1562,6 +1562,7 @@ async fn slash_copy_state_tracks_turn_complete_final_reply() {
#[tokio::test]
async fn slash_copy_picker_uses_completed_commentary_during_active_turn() {
let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.local_settings.transcript_mode = crate::transcript_mode::TranscriptMode::Terminal;
complete_turn_with_message(&mut chat, "turn-1", Some("Previous final response"));
handle_turn_started(&mut chat, "active");
let commentary = "Here is the command:\n\n```sh\necho current\n```";
@@ -1596,6 +1597,7 @@ async fn slash_copy_picker_uses_completed_commentary_during_active_turn() {
#[tokio::test]
async fn slash_copy_state_tracks_plan_item_completion() {
let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.local_settings.transcript_mode = crate::transcript_mode::TranscriptMode::Terminal;
complete_turn_with_message(&mut chat, "previous", Some("```rust\nstale();\n```"));
let plan_text = "## Plan\n\n1. Build it\n2. Test it\n\n```sh\r\njust test \r\n```".to_string();
@@ -1653,6 +1655,7 @@ async fn slash_copy_state_tracks_plan_item_completion() {
#[tokio::test]
async fn slash_copy_picker_preserves_completed_source_whitespace_and_hides_directives() {
let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.local_settings.transcript_mode = crate::transcript_mode::TranscriptMode::Terminal;
let source = concat!(
"Intro ::git-push{cwd=\"/repo\"}\r\n\r\n",
"```powershell\r\nWrite-Output value \r\nWrite-Output done\t\r\n```\r\n\r\n",
@@ -1709,6 +1712,7 @@ async fn slash_copy_picker_defers_queued_input_until_selection_or_cancellation_s
for close_key in [KeyCode::Enter, KeyCode::Esc] {
let (mut chat, mut rx, mut op_rx) =
make_chatwidget_manual(/*model_override*/ None).await;
+ chat.local_settings.transcript_mode = crate::transcript_mode::TranscriptMode::Terminal;
chat.thread_id = Some(ThreadId::new());
complete_turn_with_message(&mut chat, "previous", Some("Previous response"));
handle_turn_started(&mut chat, "active");
@@ -1762,6 +1766,7 @@ async fn slash_copy_picker_defers_queued_input_until_selection_or_cancellation_s
#[tokio::test]
async fn slash_copy_picker_previews_whole_response_code_blocks_and_blockquotes() {
let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.local_settings.transcript_mode = crate::transcript_mode::TranscriptMode::Terminal;
chat.transcript.last_agent_markdown = Some(
"Overview\n\n```python\nprint('first')\nprint('second')\n```\n\n> Important quote\n\n```sh\necho done\n```"
.to_string(),
@@ -1881,6 +1886,7 @@ async fn slash_copy_status_yields_to_later_turns_and_commands_even_after_refresh
NextTurn::ShellCommand,
] {
let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(Some("gpt-5.4")).await;
+ chat.local_settings.transcript_mode = crate::transcript_mode::TranscriptMode::Terminal;
chat.thread_id = Some(ThreadId::new());
complete_turn_with_message(&mut chat, "turn-1", Some("Original reply"));
set_chatgpt_auth(&mut chat);
@@ -1929,6 +1935,7 @@ async fn slash_copy_status_yields_to_later_turns_and_commands_even_after_refresh
async fn slash_copy_status_yields_to_queued_commands_after_queued_status() {
for command in ["/rename Queued rename", "!echo hello"] {
let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.local_settings.transcript_mode = crate::transcript_mode::TranscriptMode::Terminal;
chat.thread_id = Some(ThreadId::new());
handle_turn_started(&mut chat, "turn-1");
queue_composer_text_with_tab(&mut chat, "/status");
@@ -1955,6 +1962,7 @@ async fn slash_copy_status_yields_to_queued_commands_after_queued_status() {
async fn slash_copy_picker_waits_for_submission_after_typing_or_autocomplete() {
for select_from_autocomplete in [false, true] {
let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.local_settings.transcript_mode = crate::transcript_mode::TranscriptMode::Terminal;
chat.transcript.last_agent_markdown = Some("Ready to copy".to_string());
chat.bottom_pane
.set_composer_text("/cop".to_string(), Vec::new(), Vec::new());
@@ -1990,6 +1998,7 @@ async fn slash_copy_picker_waits_for_submission_after_typing_or_autocomplete() {
#[tokio::test]
async fn slash_copy_picker_waits_for_submission_after_paste() {
let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.local_settings.transcript_mode = crate::transcript_mode::TranscriptMode::Terminal;
chat.transcript.last_agent_markdown = Some("Ready to copy".to_string());
chat.handle_paste("/copy".to_string());
@@ -2009,6 +2018,7 @@ async fn slash_copy_picker_waits_for_submission_after_paste() {
#[tokio::test]
async fn slash_copy_picker_numeric_shortcuts_copy_whole_response_and_exact_code() {
let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.local_settings.transcript_mode = crate::transcript_mode::TranscriptMode::Terminal;
let markdown = "Intro\n\n```rust\nfn main() {\n run();\n}\n```";
chat.transcript.last_agent_markdown = Some(markdown.to_string());
@@ -2035,6 +2045,7 @@ async fn slash_copy_picker_renders_only_whole_responses_as_markdown() {
use crate::clipboard_copy::CopyFormat;
let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.local_settings.transcript_mode = crate::transcript_mode::TranscriptMode::Terminal;
let markdown = "**Intro**\n\n```text\n# literal *code*\n```\n\n> **Quote**\n";
chat.transcript.last_agent_markdown = Some(markdown.to_string());
for (key, expected) in [
@@ -2064,6 +2075,7 @@ async fn slash_copy_picker_renders_only_whole_responses_as_markdown() {
#[tokio::test]
async fn slash_copy_picker_preserves_nested_blockquote_markdown_and_code() {
let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.local_settings.transcript_mode = crate::transcript_mode::TranscriptMode::Terminal;
chat.transcript.last_agent_markdown =
Some("> **outer**\n> > _nested_\n> ```sh\n> nested()\n> ```\n".to_string());
@@ -2088,6 +2100,7 @@ async fn slash_copy_picker_preserves_nested_blockquote_markdown_and_code() {
#[tokio::test]
async fn slash_copy_picker_supports_arrow_navigation_enter_and_scrolling() {
let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.local_settings.transcript_mode = crate::transcript_mode::TranscriptMode::Terminal;
chat.transcript.last_agent_markdown = Some(
(1..=11)
.map(|index| format!("```sh\nexample_{index}()\n```\n"))
@@ -2114,6 +2127,7 @@ async fn slash_copy_picker_supports_arrow_navigation_enter_and_scrolling() {
#[tokio::test]
async fn slash_copy_picker_escape_dismisses_without_copying() {
let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.local_settings.transcript_mode = crate::transcript_mode::TranscriptMode::Terminal;
chat.transcript.last_agent_markdown = Some("Nothing copied".to_string());
chat.dispatch_command(SlashCommand::Copy);
@@ -2128,6 +2142,7 @@ async fn slash_copy_picker_escape_dismisses_without_copying() {
#[tokio::test]
async fn slash_copy_picker_remains_available_from_parent_owned_threads() {
let (mut chat, mut rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.local_settings.transcript_mode = crate::transcript_mode::TranscriptMode::Terminal;
chat.transcript.last_agent_markdown = Some("Safe local copy".to_string());
chat.set_parent_owned_thread();
chat.bottom_pane
@@ -2240,6 +2255,7 @@ async fn slash_daybreak_offers_an_application_when_unavailable() {
#[tokio::test]
async fn slash_copy_reports_when_no_agent_response_exists() {
let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.local_settings.transcript_mode = crate::transcript_mode::TranscriptMode::Terminal;
chat.dispatch_command(SlashCommand::Copy);
@@ -3732,3 +3748,35 @@ async fn transcript_copy_feedback_stays_in_the_footer_without_history_or_interru
render_bottom_popup(&chat, /*width*/ 80)
);
}
+
+#[tokio::test]
+async fn owned_copy_guard_defers_queued_input_until_released() {
+ for queued in ["/new", "/clear", "follow-up prompt"] {
+ let (mut chat, mut rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.local_settings.transcript_mode = crate::transcript_mode::TranscriptMode::Owned;
+ chat.thread_id = Some(ThreadId::new());
+ complete_turn_with_message(&mut chat, "previous", Some("Previous response"));
+ handle_turn_started(&mut chat, "active");
+ queue_composer_text_with_tab(&mut chat, queued);
+ chat.dispatch_command(SlashCommand::Copy);
+ let guard = std::iter::from_fn(|| rx.try_recv().ok())
+ .find_map(|event| match event {
+ AppEvent::SelectTranscriptCopy { guard, .. } => Some(guard),
+ _ => None,
+ })
+ .unwrap();
+ complete_turn_with_message(&mut chat, "active", Some("New response"));
+ assert_eq!(chat.input_queue.queued_user_messages.len(), 1);
+ assert_matches!(op_rx.try_recv(), Err(TryRecvError::Empty));
+ while let Ok(event) = rx.try_recv() {
+ assert!(!matches!(
+ event,
+ AppEvent::NewSession { .. } | AppEvent::ClearUi { .. }
+ ));
+ }
+ drop(guard);
+ assert_matches!(rx.try_recv(), Ok(AppEvent::TranscriptCopyClosed));
+ chat.maybe_send_next_queued_input();
+ assert!(chat.input_queue.queued_user_messages.is_empty());
+ }
+}
diff --git a/codex-rs/tui/src/copy_input_guard.rs b/codex-rs/tui/src/copy_input_guard.rs
new file mode 100644
index 0000000000..be59888e4d
--- /dev/null
+++ b/codex-rs/tui/src/copy_input_guard.rs
@@ -0,0 +1,13 @@
+//! Keep queued submissions paused until the transcript selector releases its owner.
+
+use crate::app_event::AppEvent;
+use crate::app_event_sender::AppEventSender;
+
+#[derive(Debug)]
+pub(crate) struct CopyInputGuard(pub(crate) AppEventSender);
+
+impl Drop for CopyInputGuard {
+ fn drop(&mut self) {
+ self.0.send(AppEvent::TranscriptCopyClosed);
+ }
+}
diff --git a/codex-rs/tui/src/history_cell/messages.rs b/codex-rs/tui/src/history_cell/messages.rs
index f80f311c75..1cd4a356c5 100644
--- a/codex-rs/tui/src/history_cell/messages.rs
+++ b/codex-rs/tui/src/history_cell/messages.rs
@@ -502,6 +502,7 @@ impl HistoryCell for AgentMessageCell {
#[derive(Debug)]
pub(crate) struct AgentMarkdownCell {
markdown_source: String,
+ copy_source: Option<String>,
cwd: PathBuf,
inline_visualization_context: Option<crate::inline_visualization::InlineVisualizationContext>,
rendered_lines: Option<MarkdownRenderCache>,
@@ -509,6 +510,11 @@ pub(crate) struct AgentMarkdownCell {
}
impl AgentMarkdownCell {
+ pub(crate) fn with_copy_source(mut self, source: Option<String>) -> Self {
+ self.copy_source = source;
+ self
+ }
+
/// Create a finalized source-backed assistant message cell.
///
/// `markdown_source` must be the raw source accumulated by the stream controller, not already
@@ -535,6 +541,7 @@ impl AgentMarkdownCell {
.then(MarkdownRenderCache::default);
Self {
markdown_source,
+ copy_source: None,
cwd: cwd.to_path_buf(),
inline_visualization_context,
rendered_lines,
@@ -621,6 +628,10 @@ impl AgentMarkdownCell {
}
impl HistoryCell for AgentMarkdownCell {
+ fn copy_source(&self) -> Option<&str> {
+ Some(self.copy_source.as_deref().unwrap_or(&self.markdown_source))
+ }
+
fn display_lines(&self, width: u16) -> Vec<Line<'static>> {
visible_lines(self.display_hyperlink_lines(width))
}
diff --git a/codex-rs/tui/src/history_cell/mod.rs b/codex-rs/tui/src/history_cell/mod.rs
index bbb05987b4..ac39aef420 100644
--- a/codex-rs/tui/src/history_cell/mod.rs
+++ b/codex-rs/tui/src/history_cell/mod.rs
@@ -213,6 +213,11 @@ pub(crate) trait HistoryCell: std::fmt::Debug + Send + Sync + Any {
Vec::new()
}
+ /// Original Markdown for semantic copy targets, independent of presentation.
+ fn copy_source(&self) -> Option<&str> {
+ None
+ }
+
/// Returns the logical lines for the main chat viewport.
fn display_lines(&self, width: u16) -> Vec<Line<'static>>;
diff --git a/codex-rs/tui/src/history_cell/plans.rs b/codex-rs/tui/src/history_cell/plans.rs
index f790bff8ed..d8d55194fa 100644
--- a/codex-rs/tui/src/history_cell/plans.rs
+++ b/codex-rs/tui/src/history_cell/plans.rs
@@ -148,6 +148,10 @@ impl ProposedPlanCell {
}
impl HistoryCell for ProposedPlanCell {
+ fn copy_source(&self) -> Option<&str> {
+ Some(&self.plan_markdown)
+ }
+
fn display_lines(&self, width: u16) -> Vec<Line<'static>> {
visible_lines(self.display_hyperlink_lines(width))
}
diff --git a/codex-rs/tui/src/lib.rs b/codex-rs/tui/src/lib.rs
index c865affb22..001c3aac68 100644
--- a/codex-rs/tui/src/lib.rs
+++ b/codex-rs/tui/src/lib.rs
@@ -125,6 +125,7 @@ mod clock_format;
mod collaboration_modes;
mod color;
mod config_update;
+mod copy_input_guard;
pub(crate) mod custom_terminal;
mod daybreak;
mod experimental_features;
diff --git a/codex-rs/tui/src/markdown.rs b/codex-rs/tui/src/markdown.rs
index 2d4db67f55..d2e2a9b04e 100644
--- a/codex-rs/tui/src/markdown.rs
+++ b/codex-rs/tui/src/markdown.rs
@@ -97,17 +97,23 @@ pub(crate) fn render_markdown_agent_with_list_spacing(
list_spacing: ListSpacing,
) -> Vec<HyperlinkLine> {
let rewritten = rewrite_inline_visualizations(markdown_source, inline_visualization_context);
- let normalized = normalize_markdown_for_rendering(&rewritten.markdown);
+ let mut code_sources = Vec::new();
+ let normalized = if crate::markdown_render::preferences::current().tables {
+ unwrap_markdown_fences_with_sources(&rewritten.markdown, &mut code_sources)
+ } else {
+ Cow::Borrowed(rewritten.markdown.as_ref())
+ };
let is_hidden_link_destination = |destination: &str| {
rewritten.trusted_file_links.contains_key(destination)
|| crate::markdown_render::hide_web_link_destination(destination)
};
- let mut lines = crate::markdown_render::render_streaming_markdown_lines_with_width_and_cwd(
+ let mut lines = crate::markdown_render::render_with_copy_sources(
&normalized,
width,
cwd,
&is_hidden_link_destination,
list_spacing,
+ code_sources,
)
.lines;
for hyperlink in lines.iter_mut().flat_map(|line| &mut line.hyperlinks) {
@@ -266,7 +272,14 @@ pub(crate) fn normalize_markdown_for_rendering(markdown_source: &str) -> Cow<'_,
/// The fence unwrapping is intentionally conservative: it buffers the entire fence body before
/// deciding, and an unclosed fence at end-of-input is re-emitted with its opening line so partial
/// streams degrade to code display.
-pub(crate) fn unwrap_markdown_fences<'a>(markdown_source: &'a str) -> Cow<'a, str> {
+pub(crate) fn unwrap_markdown_fences(markdown_source: &str) -> Cow<'_, str> {
+ unwrap_markdown_fences_with_sources(markdown_source, &mut Vec::new())
+}
+
+fn unwrap_markdown_fences_with_sources<'a>(
+ markdown_source: &'a str,
+ sources: &mut Vec<crate::markdown_copy::SourceBlock>,
+) -> Cow<'a, str> {
// Zero-copy fast path: most messages contain no fences at all.
if !markdown_source.contains("```") && !markdown_source.contains("~~~") {
return Cow::Borrowed(markdown_source);
@@ -396,7 +409,7 @@ pub(crate) fn unwrap_markdown_fences<'a>(markdown_source: &'a str) -> Cow<'a, st
let mut active_fence: Option<ActiveFence> = None;
let mut source_offset = 0usize;
- let mut push_source_range = |range: Range<usize>| {
+ let push_source_range = |out: &mut String, range: Range<usize>| {
if !range.is_empty() {
out.push_str(&markdown_source[range]);
}
@@ -410,7 +423,7 @@ pub(crate) fn unwrap_markdown_fences<'a>(markdown_source: &'a str) -> Cow<'a, st
if let Some(active) = active_fence.take() {
match active {
ActiveFence::Passthrough(fence) => {
- push_source_range(line_range);
+ push_source_range(&mut out, line_range);
if !is_close_fence(line, fence) {
active_fence = Some(ActiveFence::Passthrough(fence));
}
@@ -421,15 +434,27 @@ pub(crate) fn unwrap_markdown_fences<'a>(markdown_source: &'a str) -> Cow<'a, st
&content_from_ranges(markdown_source, &data.content_ranges),
data.fence.is_blockquoted,
) {
+ let start = out.len();
for range in data.content_ranges {
- push_source_range(range);
+ push_source_range(&mut out, range);
+ }
+ let fenced = &markdown_source[data.opening_range.start..line_range.end];
+ if let Some(CopyTarget::Code { content, .. }) =
+ extract_copy_targets(fenced)
+ .into_iter()
+ .find(|target| matches!(target, CopyTarget::Code { .. }))
+ {
+ sources.push(crate::markdown_copy::SourceBlock {
+ range: start..out.len(),
+ content,
+ });
}
} else {
- push_source_range(data.opening_range);
+ push_source_range(&mut out, data.opening_range);
for range in data.content_ranges {
- push_source_range(range);
+ push_source_range(&mut out, range);
}
- push_source_range(line_range);
+ push_source_range(&mut out, line_range);
}
} else {
data.content_ranges.push(line_range);
@@ -450,22 +475,22 @@ pub(crate) fn unwrap_markdown_fences<'a>(markdown_source: &'a str) -> Cow<'a, st
},
)));
} else {
- push_source_range(line_range);
+ push_source_range(&mut out, line_range);
active_fence = Some(ActiveFence::Passthrough(fence));
}
continue;
}
- push_source_range(line_range);
+ push_source_range(&mut out, line_range);
}
if let Some(active) = active_fence {
match active {
ActiveFence::Passthrough(_) => {}
ActiveFence::MarkdownCandidate(data) => {
- push_source_range(data.opening_range);
+ push_source_range(&mut out, data.opening_range);
for range in data.content_ranges {
- push_source_range(range);
+ push_source_range(&mut out, range);
}
}
}
diff --git a/codex-rs/tui/src/markdown_copy.rs b/codex-rs/tui/src/markdown_copy.rs
index ebc933a76b..7a9b9d2235 100644
--- a/codex-rs/tui/src/markdown_copy.rs
+++ b/codex-rs/tui/src/markdown_copy.rs
@@ -16,6 +16,24 @@ use crate::terminal_hyperlinks::LogicalLineSource;
pub(crate) mod table;
+/// A transformed fenced block and its coordinates in the renderer input.
+#[derive(Clone)]
+pub(crate) struct SourceBlock {
+ pub(crate) range: Range<usize>,
+ pub(crate) content: Arc<str>,
+}
+
+pub(crate) fn quote_content(source: &str) -> String {
+ source
+ .split_inclusive('\n')
+ .map(|line| {
+ line.trim_start_matches(' ')
+ .strip_prefix('>')
+ .map_or(line, |line| line.strip_prefix(' ').unwrap_or(line))
+ })
+ .collect()
+}
+
// Bound retained inline stacks and container prefixes independently of parser nesting.
pub(crate) const MAX_COPY_DEPTH: usize = 64;
@@ -60,6 +78,10 @@ pub(crate) struct CopyLine {
/// Restore the containing item when a multiline selection starts in its later paragraph.
pub(crate) item_prefix: String,
pub(crate) code: bool,
+ /// Source shared by rows when rendering replaces code with a diagram or table.
+ pub(crate) code_source: Option<Arc<str>>,
+ /// Outer quote source, retained even when it contains only code.
+ pub(crate) quote_source: Option<Arc<str>>,
pub(crate) table: Option<table::TableLine>,
table_cell: bool,
pub(crate) rule: bool,
diff --git a/codex-rs/tui/src/markdown_render.rs b/codex-rs/tui/src/markdown_render.rs
index e07cb56868..614c091487 100644
--- a/codex-rs/tui/src/markdown_render.rs
+++ b/codex-rs/tui/src/markdown_render.rs
@@ -81,6 +81,7 @@ mod mermaid;
pub(crate) mod preferences;
mod source_tables;
mod streaming;
+pub(crate) use streaming::render_with_copy_sources;
mod table_key_value;
mod task_lists;
mod web_links;
@@ -447,6 +448,9 @@ struct Writer<'a, 'policy> {
inline_styles: Vec<Style>,
copy_inline: Vec<crate::markdown_copy::Inline>,
copy_line: crate::markdown_copy::CopyLine,
+ quote_sources: Vec<std::sync::Arc<str>>,
+ code_sources: Vec<crate::markdown_copy::SourceBlock>,
+ transformed_code_source: Option<std::sync::Arc<str>>,
indent_stack: Vec<IndentContext>,
list_indices: Vec<Option<u64>>,
list_needs_blank_before_next_item: Vec<bool>,
@@ -489,6 +493,9 @@ impl<'a, 'policy> Writer<'a, 'policy> {
inline_styles: Vec::new(),
copy_inline: Vec::new(),
copy_line: Default::default(),
+ quote_sources: Vec::new(),
+ code_sources: Vec::new(),
+ transformed_code_source: None,
indent_stack: Vec::new(),
list_indices: Vec::new(),
list_needs_blank_before_next_item: Vec::new(),
@@ -532,6 +539,20 @@ impl<'a, 'policy> Writer<'a, 'policy> {
where
I: Iterator<Item = (Event<'a>, Range<usize>)>,
{
+ let source = self
+ .code_sources
+ .iter()
+ .find(|source| source.range.contains(&range.start))
+ .map(|source| std::sync::Arc::clone(&source.content));
+ let same_source = match (&source, &self.transformed_code_source) {
+ (Some(source), Some(current)) => std::sync::Arc::ptr_eq(source, current),
+ (None, None) => true,
+ _ => false,
+ };
+ if !same_source {
+ self.flush_current_line();
+ self.transformed_code_source = source;
+ }
self.prepare_for_event(&event);
let copy_inline = crate::markdown_copy::Inline::from_event(&event);
if let Some(inline) = &copy_inline {
@@ -608,7 +629,13 @@ impl<'a, 'policy> Writer<'a, 'policy> {
match tag {
Tag::Paragraph => self.start_paragraph(),
Tag::Heading { level, .. } => self.start_heading(level),
- Tag::BlockQuote => self.start_blockquote(),
+ Tag::BlockQuote => {
+ self.start_blockquote();
+ let source = self.quote_sources.first().cloned().unwrap_or_else(|| {
+ crate::markdown_copy::quote_content(&self.input[range]).into()
+ });
+ self.quote_sources.push(source);
+ }
Tag::CodeBlock(kind) => {
self.code_block_content_end = range.end;
let indent = match kind {
@@ -692,7 +719,11 @@ impl<'a, 'policy> Writer<'a, 'policy> {
self.end_paragraph();
}
TagEnd::Heading(_) => self.end_heading(),
- TagEnd::BlockQuote => self.end_blockquote(),
+ TagEnd::BlockQuote => {
+ self.flush_current_line();
+ self.end_blockquote();
+ self.quote_sources.pop();
+ }
TagEnd::CodeBlock => self.end_codeblock(range),
TagEnd::List(_) => self.end_list(),
TagEnd::Item => {
@@ -1116,8 +1147,10 @@ impl<'a, 'policy> Writer<'a, 'policy> {
Some(diagram) => diagram,
None => highlight_code_to_lines(&code, &lang),
};
+ let source: std::sync::Arc<str> = code.into();
for hl_line in highlighted {
self.push_line(Line::default());
+ self.copy_line.code_source = Some(std::sync::Arc::clone(&source));
for span in hl_line.spans {
self.push_span(span);
}
@@ -2347,6 +2380,8 @@ impl<'a, 'policy> Writer<'a, 'policy> {
.and_then(|source| source.copy.as_deref())
.cloned()
.unwrap_or_default();
+ copy.code_source = self.transformed_code_source.clone();
+ copy.quote_source = self.quote_sources.first().cloned();
copy.prefix = self.copy_prefix(pending_marker_line);
copy.continuation = self.copy_prefix(/*pending_marker_line*/ false);
copy.item_prefix = self.copy_prefix(/*pending_marker_line*/ true);
@@ -2381,6 +2416,8 @@ impl<'a, 'policy> Writer<'a, 'policy> {
self.copy_line.continuation = self.copy_prefix(/*pending_marker_line*/ false);
self.copy_line.item_prefix = self.copy_prefix(/*pending_marker_line*/ true);
self.copy_line.code = self.in_code_block;
+ self.copy_line.code_source = self.transformed_code_source.clone();
+ self.copy_line.quote_source = self.quote_sources.first().cloned();
// Heading markers are already visible; retain them as Markdown syntax.
self.copy_line
.push(line.spans.iter().map(|span| span.content.len()).sum(), &[]);
diff --git a/codex-rs/tui/src/markdown_render/streaming.rs b/codex-rs/tui/src/markdown_render/streaming.rs
index 9a5641a784..a79bf912a8 100644
--- a/codex-rs/tui/src/markdown_render/streaming.rs
+++ b/codex-rs/tui/src/markdown_render/streaming.rs
@@ -42,6 +42,24 @@ pub(crate) fn render_streaming_markdown_lines_with_width_and_cwd(
cwd: Option<&Path>,
is_hidden_link_destination: &dyn Fn(&str) -> bool,
list_spacing: ListSpacing,
+) -> StreamingMarkdownRender {
+ render_with_copy_sources(
+ input,
+ width,
+ cwd,
+ is_hidden_link_destination,
+ list_spacing,
+ Vec::new(),
+ )
+}
+
+pub(crate) fn render_with_copy_sources(
+ input: &str,
+ width: Option<usize>,
+ cwd: Option<&Path>,
+ is_hidden_link_destination: &dyn Fn(&str) -> bool,
+ list_spacing: ListSpacing,
+ code_sources: Vec<crate::markdown_copy::SourceBlock>,
) -> StreamingMarkdownRender {
let mut options = Options::empty();
options.insert(Options::ENABLE_STRIKETHROUGH);
@@ -69,6 +87,7 @@ pub(crate) fn render_streaming_markdown_lines_with_width_and_cwd(
// Drop the consumed parser before the rendering state, including on unwind.
let mut parser = parser;
writer.list_spacing = list_spacing;
+ writer.code_sources = code_sources;
writer.run(&mut parser);
StreamingMarkdownRender {
lines: writer.text,
diff --git a/codex-rs/tui/src/transcript_view.rs b/codex-rs/tui/src/transcript_view.rs
index 9f04f3114a..31ebfec5ee 100644
--- a/codex-rs/tui/src/transcript_view.rs
+++ b/codex-rs/tui/src/transcript_view.rs
@@ -8,6 +8,7 @@
mod activity;
mod bookmark;
mod composer_gap;
+mod copy_mode;
mod disclosure;
mod follow_control;
mod footer;
@@ -103,6 +104,7 @@ pub(crate) struct TranscriptView {
suppressed_prompt_header: Option<prompt_header::SuppressedHeader>,
visible: Vec<VisibleRow>,
selection: Option<Selection>,
+ copy_mode: Option<copy_mode::CopyMode>,
held_reading: Option<ViewSnapshot>,
search: Search,
detailed: bool,
@@ -138,6 +140,7 @@ impl Default for TranscriptView {
suppressed_prompt_header: None,
visible: Vec::new(),
selection: None,
+ copy_mode: None,
held_reading: None,
search: Search::default(),
detailed: false,
@@ -177,15 +180,21 @@ impl TranscriptView {
let cells = snapshot.as_deref().unwrap_or(cells);
let suppressed_prompt_header = self.suppressed_prompt_header.take();
Clear.render(area, buf);
+ let previous_height = self.area.height;
+ let resized = self.area.width != area.width || self.area.bottom() != area.bottom();
self.prepare_width(area.width);
self.area = area;
self.normalize_selection(cells);
+ if resized {
+ self.reveal_copy_context(cells);
+ }
self.visible.clear();
if area.is_empty() {
self.tail_visible = false;
return;
}
let initial_start = self.start(cells);
+ let initial_position = self.position;
let mut start = initial_start;
let mut body = area;
let header_position = prompt_header::SuppressedHeader {
@@ -200,7 +209,12 @@ impl TranscriptView {
self.suppressed_prompt_header = Some(header_position);
} else if area.height >= 4 && prompt_header::line(cells, start.0, area.width).is_some() {
body = Rect::new(area.x, area.y + 1, area.width, area.height - 1);
+ let resized = resized || previous_height != body.height;
self.area = body;
+ // Copy targets must also leave context after the prompt reserves its row.
+ if resized {
+ self.reveal_copy_context(cells);
+ }
// Following may advance into the next turn after reserving the header row.
start = self.start(cells);
if let Some(header) = prompt_header::line(cells, start.0, area.width) {
@@ -209,6 +223,9 @@ impl TranscriptView {
body = area;
self.area = area;
start = initial_start;
+ if resized && self.copy_mode.is_some() {
+ self.position = initial_position;
+ }
self.suppressed_prompt_header = Some(header_position);
}
}
@@ -336,6 +353,7 @@ impl TranscriptView {
return;
}
self.selection = None;
+ self.copy_mode = None;
self.release_live_reading();
self.cache.clear();
self.suppressed_prompt_header = None;
@@ -381,6 +399,7 @@ impl TranscriptView {
self.cancel_beginning();
self.position = Position::Latest;
self.selection = None;
+ self.copy_mode = None;
self.release_live_reading();
self.unseen_activity = false;
self.disclosure.focused = None;
diff --git a/codex-rs/tui/src/transcript_view/copy_mode.rs b/codex-rs/tui/src/transcript_view/copy_mode.rs
new file mode 100644
index 0000000000..6cbc2f1e92
--- /dev/null
+++ b/codex-rs/tui/src/transcript_view/copy_mode.rs
@@ -0,0 +1,381 @@
+//! Semantic copy navigation over the selection's frozen transcript revision.
+//! Targets retain their original payloads and leave surrounding context when revealed.
+
+use super::*;
+use crate::history_cell::AgentMarkdownCell;
+use crate::history_cell::ProposedPlanCell;
+use crate::history_cell::UserHistoryCell;
+use crossterm::event::KeyCode;
+use crossterm::event::KeyEvent;
+use crossterm::event::KeyModifiers;
+use std::ops::Range;
+
+pub(super) struct CopyMode {
+ _guard: Option<Arc<crate::copy_input_guard::CopyInputGuard>>,
+ pub(super) response: Option<(EntryKey, Arc<str>)>,
+ pub(super) whole: bool,
+ pub(super) source: Option<String>,
+ pub(super) label: &'static str,
+}
+
+impl TranscriptView {
+ pub(crate) fn begin_copy_mode(
+ &mut self,
+ cells: &[Arc<dyn HistoryCell>],
+ guard: Option<Arc<crate::copy_input_guard::CopyInputGuard>>,
+ ) -> bool {
+ self.jump_to_latest();
+ self.hold_position();
+ let latest = cells.iter().rposition(is_response);
+ self.copy_mode = Some(CopyMode {
+ _guard: guard,
+ response: latest.and_then(|index| {
+ let cell = &cells[index];
+ let text = if cell.as_any().is::<AgentMarkdownCell>() {
+ // Raw lines retain this cell's visible Markdown after hidden directives
+ // were removed during consolidation, independently of the latest cache.
+ let markdown = cell
+ .raw_lines()
+ .iter()
+ .map(ToString::to_string)
+ .collect::<Vec<_>>()
+ .join("\n");
+ crate::markdown_render::followup_labels(&markdown).into_owned()
+ } else {
+ cell.copy_source()?.to_owned()
+ };
+ Some((EntryKey::cell(cell), Arc::from(text)))
+ }),
+ whole: true,
+ source: None,
+ label: "Whole response",
+ });
+ if !self.select_copy_response(cells) {
+ self.move_copy_target(cells, KeyCode::Up);
+ }
+ if self.selection.is_none() {
+ self.jump_to_latest();
+ }
+ self.copy_mode.is_some()
+ }
+
+ pub(super) fn handle_copy_mode_key(
+ &mut self,
+ key: KeyEvent,
+ cells: &[Arc<dyn HistoryCell>],
+ ) -> Option<ViewAction> {
+ self.copy_mode.as_ref()?;
+ let code = match crate::key_hint::normalize_key_parts(key.code, key.modifiers) {
+ (KeyCode::Char('k'), KeyModifiers::NONE) => KeyCode::Up,
+ (KeyCode::Char('j'), KeyModifiers::NONE) => KeyCode::Down,
+ (KeyCode::Char('g'), KeyModifiers::NONE) => KeyCode::Home,
+ (KeyCode::Char('g'), KeyModifiers::SHIFT) => KeyCode::End,
+ _ => key.code,
+ };
+ match code {
+ KeyCode::Up | KeyCode::Down | KeyCode::Home | KeyCode::End => {
+ self.move_copy_target(cells, code)
+ }
+ KeyCode::Esc => self.jump_to_latest(),
+ _ if key.code == KeyCode::Enter || crate::text_selection::is_copy_key(key) => {
+ return Some(ViewAction::CopyAndFollow(
+ self.selected_text(cells).unwrap_or_default(),
+ ));
+ }
+ KeyCode::PageUp | KeyCode::PageDown => return self.handle_scroll_key(key, cells),
+ _ => return Some(ViewAction::Changed),
+ }
+ Some(ViewAction::Changed)
+ }
+
+ fn move_copy_target(&mut self, cells: &[Arc<dyn HistoryCell>], direction: KeyCode) {
+ let snapshot = self.snapshot_cells();
+ let cells = snapshot.as_deref().unwrap_or(cells);
+ self.normalize_selection(cells);
+ if direction == KeyCode::End && self.select_copy_response(cells) {
+ return;
+ }
+ let Some(mode) = &self.copy_mode else { return };
+ let label = mode.label;
+ let edge = matches!(direction, KeyCode::Home | KeyCode::End);
+ let older = matches!(direction, KeyCode::Up | KeyCode::End);
+ if mode.whole && !older && !edge {
+ return;
+ }
+ let current = self
+ .selection
+ .as_ref()
+ .filter(|_| !mode.whole && !edge)
+ .map(|s| (s.start.index, s.start.offset..s.end.offset));
+ let indices: Box<dyn Iterator<Item = usize>> = if older {
+ Box::new((0..current.as_ref().map_or(cells.len(), |(index, _)| index + 1)).rev())
+ } else {
+ Box::new(current.as_ref().map_or(0, |(index, _)| *index)..cells.len())
+ };
+ for index in indices {
+ let user = cells[index].as_any().downcast_ref::<UserHistoryCell>();
+ if user.is_none() && !is_response(&cells[index]) {
+ continue;
+ }
+ let Some(layout) = self.layout(cells, index) else {
+ continue;
+ };
+ let mut ranges = if let Some(user) = user {
+ user_ranges(layout.text(), &user.message)
+ } else if self.mode == crate::history_cell::HistoryRenderMode::Raw {
+ user_ranges(layout.text(), "")
+ .into_iter()
+ .filter(|(_, label, _)| *label != "User message")
+ .collect()
+ } else {
+ layout.copy_block_ranges()
+ };
+ ranges.sort_by_key(|(range, _, _)| (range.start, std::cmp::Reverse(range.end)));
+ if let Some(source) = user
+ .map(|user| user.message.as_str())
+ .or_else(|| cells[index].copy_source())
+ {
+ let targets = crate::markdown::extract_copy_targets(source);
+ let mut codes = targets
+ .iter()
+ .filter_map(|target| match target {
+ crate::markdown::CopyTarget::Code { content, .. } => Some(content),
+ crate::markdown::CopyTarget::Quote(_) => None,
+ })
+ .collect::<Vec<_>>();
+ let mut depth = 0;
+ let mut quotes = Vec::new();
+ for (event, span) in pulldown_cmark::Parser::new(source).into_offset_iter() {
+ match event {
+ pulldown_cmark::Event::Start(pulldown_cmark::Tag::BlockQuote) => {
+ if depth == 0 {
+ quotes.push(crate::markdown_copy::quote_content(&source[span]));
+ }
+ depth += 1;
+ }
+ pulldown_cmark::Event::End(pulldown_cmark::TagEnd::BlockQuote) => {
+ depth -= 1
+ }
+ _ => {}
+ }
+ }
+ let normalized = |text: &str| {
+ crate::markdown::normalize_markdown_for_rendering(text)
+ .lines()
+ .map(str::trim_end)
+ .collect::<Vec<_>>()
+ .join("\n")
+ .trim()
+ .to_owned()
+ };
+ for (range, label, payload) in &mut ranges {
+ if *label == "Code block" {
+ // Match rendered text, not ordinal position: indented code and
+ // source-preserving tables need not have a fenced counterpart.
+ let displayed = payload.as_deref().unwrap_or(&layout.text()[range.clone()]);
+ if let Some(at) = codes
+ .iter()
+ .position(|code| normalized(code) == normalized(displayed))
+ {
+ *payload = Some(codes.remove(at).to_string());
+ }
+ } else if user.is_none()
+ && *label == "Blockquote"
+ && let Some(displayed) = payload.as_deref()
+ && let Some(at) = quotes.iter().position(|quote| {
+ let visible = quote
+ .split_inclusive('\n')
+ .map(|line| {
+ crate::git_action_directives::strip_line_directives(line).0
+ })
+ .collect::<String>();
+ normalized(&visible) == normalized(displayed)
+ || normalized(quote) == normalized(displayed)
+ })
+ {
+ *payload = Some(
+ quotes
+ .remove(at)
+ .split_inclusive('\n')
+ .map(|line| {
+ crate::git_action_directives::strip_line_directives(line).0
+ })
+ .collect(),
+ );
+ }
+ }
+ }
+ let boundary =
+ current
+ .as_ref()
+ .filter(|(at, _)| *at == index)
+ .and_then(|(_, range)| {
+ ranges.iter().position(|(candidate, candidate_label, _)| {
+ candidate == range && *candidate_label == label
+ })
+ });
+ let target = if older {
+ ranges[..boundary.unwrap_or(ranges.len())].last()
+ } else {
+ ranges.get(boundary.map_or(0, |at| at + 1))
+ };
+ if let Some((range, label, source)) = target {
+ let range = range.clone();
+ if let Some(mode) = &mut self.copy_mode {
+ mode.whole = false;
+ mode.label = label;
+ mode.source = source.clone();
+ }
+ self.select_copy_range(cells, index, range);
+ return;
+ }
+ }
+ if !older {
+ self.select_copy_response(cells);
+ } else if self.history.has_unloaded_history() {
+ self.jump_to_entry(cells, /*index*/ 0);
+ }
+ }
+
+ /// Keep fitting targets inside a central band, scrolling only to the nearest margin.
+ /// Oversized targets show their beginning with context above rather than clipping it.
+ pub(super) fn reveal_copy_context(&mut self, cells: &[Arc<dyn HistoryCell>]) {
+ if self.copy_mode.is_none() {
+ return;
+ }
+ let Some(selection) = &self.selection else {
+ return;
+ };
+ let (start, end) = (selection.start, selection.end);
+ let index = self.resolve(cells, start);
+ let Some(layout) = self.layout(cells, index) else {
+ return;
+ };
+ let first = layout.row_for_offset(start.offset);
+ // Match block painting: whole-entry highlights include final padding.
+ let finish = if start.offset == 0 && end.offset == layout.text().len() {
+ end.offset
+ } else {
+ end.offset.saturating_sub(/*rhs*/ 1)
+ };
+ let last = layout.row_for_offset(finish);
+ let height = usize::from(self.area.height);
+ if height == 0 {
+ return;
+ }
+ let target_height = last.saturating_sub(first) + 1;
+ // Reserve a quarter of the viewport, reducing the margin for taller targets.
+ let margin = (height / 4)
+ .max(1)
+ .min(height.saturating_sub(target_height) / 2);
+ let bottom_margin = (height / 4)
+ .max(1)
+ .min(height.saturating_sub(target_height).div_ceil(2));
+ let top = self.start(cells);
+ let inner_top = self.move_rows(cells, top.0, top.1, margin as isize);
+ let inner_bottom = self.move_rows(
+ cells,
+ top.0,
+ top.1,
+ height.saturating_sub(bottom_margin + 1) as isize,
+ );
+ if target_height < height && (index, first) >= inner_top && (index, last) <= inner_bottom {
+ return;
+ }
+ let inset = if target_height >= height {
+ height / 4
+ } else if (index, first) < inner_top {
+ margin
+ } else {
+ height - bottom_margin - target_height
+ };
+ let (index, row) = self.move_rows(cells, index, first, -(inset as isize));
+ if let Some(layout) = self.layout(cells, index) {
+ let offset = layout.position_at(row, /*column*/ 0);
+ self.position = Position::Reading(Anchor {
+ key: self.entry_key(cells, index),
+ index,
+ offset,
+ row_bias: layout.row_for_offset(offset) as isize - row as isize,
+ });
+ }
+ }
+
+ fn select_copy_response(&mut self, cells: &[Arc<dyn HistoryCell>]) -> bool {
+ let Some(mode) = &mut self.copy_mode else {
+ return false;
+ };
+ let Some((key, _)) = &mode.response else {
+ return false;
+ };
+ let Some(index) = cells.iter().position(|cell| EntryKey::cell(cell) == *key) else {
+ return false;
+ };
+ mode.whole = true;
+ mode.source = None;
+ mode.label = "Whole response";
+ let Some(layout) = self.layout(cells, index) else {
+ return false;
+ };
+ self.select_copy_range(cells, index, 0..layout.text().len());
+ true
+ }
+}
+
+fn is_response(cell: &Arc<dyn HistoryCell>) -> bool {
+ cell.as_any().is::<AgentMarkdownCell>() || cell.as_any().is::<ProposedPlanCell>()
+}
+
+fn user_ranges(text: &str, message: &str) -> Vec<(Range<usize>, &'static str, Option<String>)> {
+ use pulldown_cmark::Event;
+ use pulldown_cmark::Tag;
+ use pulldown_cmark::TagEnd;
+ let mut ranges = Vec::new();
+ if !text.trim().is_empty() {
+ ranges.push((
+ 0..text.len(),
+ "User message",
+ (!message.is_empty())
+ .then(|| crate::history_cell::sanitize_user_text(message.into()).into_owned()),
+ ));
+ }
+ let mut depth = 0;
+ let mut code: Option<(Range<usize>, String)> = None;
+ for (event, range) in pulldown_cmark::Parser::new(text).into_offset_iter() {
+ match event {
+ Event::Start(Tag::BlockQuote) => {
+ if depth == 0 {
+ let source = message
+ .is_empty()
+ .then(|| crate::markdown_copy::quote_content(&text[range.clone()]));
+ ranges.push((range, "Blockquote", source));
+ }
+ depth += 1;
+ }
+ Event::End(TagEnd::BlockQuote) => depth -= 1,
+ Event::Start(Tag::CodeBlock(_)) => {
+ code = Some((range.start..range.start, String::new()))
+ }
+ Event::Text(text) => {
+ if let Some((source, content)) = code.as_mut() {
+ content.push_str(&text);
+ if source.start == source.end {
+ source.start = range.start;
+ }
+ source.end = range.end;
+ }
+ }
+ Event::End(TagEnd::CodeBlock) => {
+ if let Some((range, content)) = code.take().filter(|(range, _)| !range.is_empty()) {
+ ranges.push((range, "Code block", Some(content)));
+ }
+ }
+ _ => {}
+ }
+ }
+ ranges
+}
+
+#[cfg(test)]
+#[path = "copy_mode_tests.rs"]
+mod tests;
diff --git a/codex-rs/tui/src/transcript_view/copy_mode_tests.rs b/codex-rs/tui/src/transcript_view/copy_mode_tests.rs
new file mode 100644
index 0000000000..27c37bdf0c
--- /dev/null
+++ b/codex-rs/tui/src/transcript_view/copy_mode_tests.rs
@@ -0,0 +1,707 @@
+//! Covers transcript copy navigation, rendering, and original-source clipboard payloads.
+
+use super::*;
+use crate::clipboard_copy::CopyStatus;
+use crate::transcript_view::tests::render;
+use crate::transcript_view::tests::text;
+use crossterm::event::KeyModifiers;
+use pretty_assertions::assert_eq;
+use std::path::Path;
+
+fn payload(view: &mut TranscriptView, cells: &[Arc<dyn HistoryCell>]) -> String {
+ let selected = view.selected_text(cells).unwrap();
+ let mut copied = String::new();
+ view.copy_selected_text_with(
+ cells,
+ &selected,
+ /*clear_selection*/ false,
+ |text, _| {
+ copied = text.to_owned();
+ Ok(CopyStatus::Confirmed)
+ },
+ )
+ .unwrap();
+ copied
+}
+
+#[test]
+fn navigate_copy_resize_and_exit() {
+ let cells: Vec<Arc<dyn HistoryCell>> = vec![
+ Arc::new(AgentMarkdownCell::new(
+ "Old answer\n\n```\nold code\n```".into(),
+ Path::new("/"),
+ )),
+ Arc::new(crate::history_cell::new_user_prompt(
+ "User text\n\n> user quote\n\n```\nuser code\n```".into(),
+ Vec::new(),
+ Vec::new(),
+ Vec::new(),
+ )),
+ Arc::new(crate::history_cell::new_proposed_plan(
+ "Latest **plan**\n\n> assistant quote\n\n```rust\nassistant code\n```".into(),
+ Path::new("/"),
+ )),
+ ];
+ let mut view = TranscriptView::default();
+ render(&mut view, &cells, /*width*/ 50, /*height*/ 8);
+ view.begin_copy_mode(&cells, /*guard*/ None);
+ render(&mut view, &cells, /*width*/ 50, /*height*/ 8);
+ assert_eq!(
+ payload(&mut view, &cells),
+ "Latest **plan**\n\n> assistant quote\n\n```rust\nassistant code\n```"
+ );
+ for expected in [
+ "assistant code\n",
+ "assistant quote\n",
+ "user code\n",
+ "> user quote\n",
+ "User text\n\n> user quote\n\n```\nuser code\n```",
+ "old code\n",
+ "old code\n",
+ ] {
+ view.move_copy_target(&cells, KeyCode::Up);
+ assert_eq!(payload(&mut view, &cells), expected);
+ render(&mut view, &cells, /*width*/ 50, /*height*/ 8);
+ }
+ for _ in 0..5 {
+ view.move_copy_target(&cells, KeyCode::Down);
+ }
+ let buffer = render(&mut view, &cells, /*width*/ 50, /*height*/ 8);
+ assert!(
+ buffer
+ .content
+ .iter()
+ .any(|cell| cell.modifier.contains(ratatui::style::Modifier::REVERSED))
+ );
+ insta::assert_snapshot!(text(&buffer), @"
+ › User text > user quote ``` user code ```
+
+ Latest plan
+
+ > assistant quote
+
+ assistant code
+ ");
+ insta::assert_snapshot!(
+ view.footer_with_navigation(/*width*/ 50, crate::motion::MotionMode::Reduced, "")
+ .unwrap()
+ .text
+ .to_string(), @"
+ Copy code block
+ ↑/↓/j/k select · g/G ends · enter copy · esc close
+ "
+ );
+ render(&mut view, &cells, /*width*/ 14, /*height*/ 8);
+ assert_eq!(payload(&mut view, &cells), "assistant code\n");
+ view.move_copy_target(&cells, KeyCode::Down);
+ assert_eq!(
+ payload(&mut view, &cells),
+ "Latest **plan**\n\n> assistant quote\n\n```rust\nassistant code\n```"
+ );
+ let selected = view.selected_text(&cells).unwrap();
+ view.copy_selected_text_with(
+ &cells,
+ &selected,
+ /*clear_selection*/ true,
+ |_, _| Ok(CopyStatus::Confirmed),
+ )
+ .unwrap();
+ assert!(view.is_following());
+ view.begin_copy_mode(&cells, /*guard*/ None);
+ for (key, expected) in [
+ ('g', "old code\n"),
+ (
+ 'G',
+ "Latest **plan**\n\n> assistant quote\n\n```rust\nassistant code\n```",
+ ),
+ ('k', "assistant code\n"),
+ ] {
+ view.handle_key(
+ KeyEvent::new(KeyCode::Char(key), KeyModifiers::NONE),
+ &cells,
+ );
+ render(&mut view, &cells, /*width*/ 50, /*height*/ 8);
+ assert_eq!(payload(&mut view, &cells), expected);
+ }
+ view.handle_copy_mode_key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE), &cells);
+ assert!(view.is_following());
+}
+
+#[test]
+fn copy_reveals_offscreen_block_with_context() {
+ let cells: Vec<Arc<dyn HistoryCell>> = vec![Arc::new(AgentMarkdownCell::new(
+ format!("{}\n```sh\nlast code\n```", "line\n".repeat(/*n*/ 20)),
+ Path::new("/"),
+ ))];
+ let mut view = TranscriptView::default();
+ render(&mut view, &cells, /*width*/ 50, /*height*/ 5);
+ view.scroll(&cells, /*rows*/ -5);
+ render(&mut view, &cells, /*width*/ 50, /*height*/ 5);
+ view.begin_copy_mode(&cells, /*guard*/ None);
+ render(&mut view, &cells, /*width*/ 50, /*height*/ 5);
+ view.move_copy_target(&cells, KeyCode::Up);
+ let after = render(&mut view, &cells, /*width*/ 50, /*height*/ 5);
+ insta::assert_snapshot!(text(&after), @"
+ line
+ line
+
+ last code
+ ");
+}
+
+#[test]
+fn user_messages_support_vim_navigation_without_an_assistant_response() {
+ let messages = ["First **user** message", "\nPlain prompt with wrapping\n\n"];
+ let cells: Vec<Arc<dyn HistoryCell>> = messages
+ .iter()
+ .map(|message| {
+ Arc::new(crate::history_cell::new_user_prompt(
+ (*message).into(),
+ Vec::new(),
+ Vec::new(),
+ Vec::new(),
+ )) as Arc<dyn HistoryCell>
+ })
+ .collect();
+ let mut view = TranscriptView::default();
+ render(&mut view, &cells, /*width*/ 50, /*height*/ 8);
+ view.begin_copy_mode(&cells, /*guard*/ None);
+ assert_eq!(payload(&mut view, &cells), messages[1]);
+ for (code, modifiers, expected) in [
+ (KeyCode::Char('k'), KeyModifiers::NONE, messages[0]),
+ (KeyCode::Char('j'), KeyModifiers::NONE, messages[1]),
+ (KeyCode::Char('g'), KeyModifiers::NONE, messages[0]),
+ (KeyCode::Char('G'), KeyModifiers::NONE, messages[1]),
+ (KeyCode::Char('g'), KeyModifiers::NONE, messages[0]),
+ (KeyCode::Char('g'), KeyModifiers::SHIFT, messages[1]),
+ ] {
+ view.handle_key(KeyEvent::new(code, modifiers), &cells);
+ render(&mut view, &cells, /*width*/ 18, /*height*/ 8);
+ assert_eq!(payload(&mut view, &cells), expected);
+ }
+ insta::assert_snapshot!(
+ view.footer_with_navigation(/*width*/ 60, crate::motion::MotionMode::Reduced, "")
+ .unwrap().text.to_string(), @"
+ Copy user message
+ ↑/↓/j/k select · g/G ends · enter copy · esc close
+ "
+ );
+}
+
+#[test]
+fn copy_highlight_fills_a_block_across_blank_and_wrapped_rows() {
+ let cells: Vec<Arc<dyn HistoryCell>> = vec![Arc::new(AgentMarkdownCell::new(
+ "Before\n\n```text\nlonger line\n\nx\n```\n\nAfter".into(),
+ Path::new("/"),
+ ))];
+ let mut view = TranscriptView::default();
+ render(&mut view, &cells, /*width*/ 16, /*height*/ 12);
+ view.begin_copy_mode(&cells, /*guard*/ None);
+ view.move_copy_target(&cells, KeyCode::Up);
+ let selected = ratatui::buffer::Cell::default()
+ .set_style(crate::style::selection_style())
+ .style();
+ let mut snapshots = Vec::new();
+ for width in [16, 8] {
+ let buffer = render(&mut view, &cells, width, /*height*/ 12);
+ let rows: Vec<String> = buffer
+ .content
+ .chunks(usize::from(width))
+ .map(|row| {
+ let mask: String = row
+ .iter()
+ .map(|cell| if cell.style() == selected { '#' } else { '.' })
+ .collect();
+ format!(
+ "{mask} | {}",
+ row.iter()
+ .map(ratatui::buffer::Cell::symbol)
+ .collect::<String>()
+ )
+ })
+ .collect();
+ snapshots.push(rows.join("\n"));
+ assert_eq!(payload(&mut view, &cells), "longer line\n\nx\n");
+ }
+ insta::assert_snapshot!(snapshots.join("\n---\n"));
+}
+
+#[test]
+fn whole_user_turn_highlight_includes_bottom_padding() {
+ let selected = ratatui::buffer::Cell::default()
+ .set_style(crate::style::selection_style())
+ .style();
+ let mut snapshots = Vec::new();
+ for (message, width, height) in [("Short prompt", 20, 4), ("Longer message\n\nlast", 10, 8)] {
+ let cells: Vec<Arc<dyn HistoryCell>> =
+ vec![Arc::new(crate::history_cell::new_user_prompt(
+ message.into(),
+ Vec::new(),
+ Vec::new(),
+ Vec::new(),
+ ))];
+ let mut view = TranscriptView::default();
+ render(&mut view, &cells, width, height);
+ view.begin_copy_mode(&cells, /*guard*/ None);
+ let buffer = render(&mut view, &cells, width, height);
+ let rows: Vec<String> = buffer
+ .content
+ .chunks(usize::from(width))
+ .map(|row| {
+ let mask: String = row
+ .iter()
+ .map(|cell| if cell.style() == selected { '#' } else { '.' })
+ .collect();
+ format!(
+ "{mask} | {}",
+ row.iter()
+ .map(ratatui::buffer::Cell::symbol)
+ .collect::<String>()
+ )
+ })
+ .collect();
+ snapshots.push(rows.join("\n"));
+ assert_eq!(payload(&mut view, &cells), message);
+ }
+ insta::assert_snapshot!(snapshots.join("\n---\n"));
+}
+
+#[test]
+fn rendered_mermaid_copies_source() {
+ let cells: Vec<Arc<dyn HistoryCell>> = vec![Arc::new(AgentMarkdownCell::new(
+ "```mermaid\ngraph LR\nA --> B\n```".into(),
+ Path::new("/"),
+ ))];
+ let mut view = TranscriptView::default();
+ let buffer = render(&mut view, &cells, /*width*/ 50, /*height*/ 8);
+ assert!(!text(&buffer).contains("graph LR"));
+ view.begin_copy_mode(&cells, /*guard*/ None);
+ view.move_copy_target(&cells, KeyCode::Up);
+ assert_eq!(payload(&mut view, &cells), "graph LR\nA --> B\n");
+}
+
+#[test]
+fn copy_source_survives_raw_rich_rendering_and_whitespace_normalization() {
+ let source = "Before\r\n\r\n```sh\r\necho x \r\n \r\n```\r\n\r\n> **quote**\r\n";
+ let displayed = crate::git_action_directives::parse_assistant_markdown(source, Path::new("/"))
+ .visible_markdown;
+ for mode in [
+ crate::history_cell::HistoryRenderMode::Rich,
+ crate::history_cell::HistoryRenderMode::Raw,
+ ] {
+ let cells: Vec<Arc<dyn HistoryCell>> = vec![Arc::new(
+ AgentMarkdownCell::new(displayed.clone(), Path::new("/"))
+ .with_copy_source(Some(source.into())),
+ )];
+ let mut view = TranscriptView::default();
+ view.set_presentation(/*detailed*/ false, mode);
+ render(&mut view, &cells, /*width*/ 50, /*height*/ 20);
+ view.begin_copy_mode(&cells, /*guard*/ None);
+ view.move_copy_target(&cells, KeyCode::Up);
+ assert_eq!(payload(&mut view, &cells), "**quote**\r\n");
+ view.move_copy_target(&cells, KeyCode::Up);
+ assert_eq!(payload(&mut view, &cells), "echo x \r\n \r\n");
+ }
+}
+
+#[test]
+fn copy_completion_keeps_payload_count_and_follow_intent() {
+ let cells: Vec<Arc<dyn HistoryCell>> = vec![Arc::new(AgentMarkdownCell::new(
+ "**bold**".into(),
+ Path::new("/"),
+ ))];
+ for result in [CopyStatus::Confirmed, CopyStatus::Pending(7)] {
+ let mut view = TranscriptView::default();
+ render(&mut view, &cells, /*width*/ 40, /*height*/ 5);
+ view.begin_copy_mode(&cells, /*guard*/ None);
+ let selected = view.selected_text(&cells).unwrap();
+ view.copy_selected_text_with(
+ &cells,
+ &selected,
+ /*clear_selection*/ true,
+ |_, _| Ok(result),
+ )
+ .unwrap();
+ assert_eq!(view.copy_feedback.as_ref().unwrap().characters, 8);
+ if matches!(result, CopyStatus::Pending(_)) {
+ assert_eq!(
+ view.finish_copy(
+ &cells,
+ &(7, Ok(CopyStatus::Confirmed)),
+ /*current*/ true
+ ),
+ Some(true)
+ );
+ view.jump_to_latest();
+ }
+ assert!(view.is_following());
+ let area = ratatui::layout::Rect::new(
+ /*x*/ 0, /*y*/ 0, /*width*/ 40, /*height*/ 1,
+ );
+ let mut buffer = ratatui::buffer::Buffer::empty(area);
+ view.render_composer_gap(
+ Some(area),
+ /*hint*/ None,
+ &mut buffer,
+ std::time::Instant::now(),
+ );
+ insta::allow_duplicates! {
+ insta::assert_snapshot!(text(&buffer).trim(), @"Copied 8 chars to host clipboard");
+ }
+ assert_eq!(view.copy_feedback.as_ref().unwrap().characters, 8);
+ }
+}
+
+#[test]
+fn find_and_shift_click_release_copy_payload() {
+ let cells: Vec<Arc<dyn HistoryCell>> = vec![Arc::new(AgentMarkdownCell::new(
+ "**bold** needle".into(),
+ Path::new("/"),
+ ))];
+ for detailed in [false, true] {
+ let mut view = TranscriptView::default();
+ view.set_presentation(detailed, crate::history_cell::HistoryRenderMode::Rich);
+ render(&mut view, &cells, /*width*/ 40, /*height*/ 5);
+ view.begin_copy_mode(&cells, /*guard*/ None);
+ view.begin_search();
+ assert!(view.copy_mode.is_none());
+ assert!(view.paste_search("needle"));
+ view.advance_search(&cells);
+ assert!(
+ view.footer_with_navigation(/*width*/ 80, crate::motion::MotionMode::Reduced, "")
+ .unwrap()
+ .text
+ .to_string()
+ .contains("needle")
+ );
+ }
+ let mut view = TranscriptView::default();
+ render(&mut view, &cells, /*width*/ 40, /*height*/ 5);
+ view.begin_copy_mode(&cells, /*guard*/ None);
+ render(&mut view, &cells, /*width*/ 40, /*height*/ 5);
+ let row = view.area.y
+ + view
+ .visible
+ .iter()
+ .position(|row| row.layout.text().contains("needle"))
+ .unwrap() as u16;
+ view.extend_selection(/*column*/ 6, row);
+ assert!(view.copy_mode.is_none());
+ assert_eq!(payload(&mut view, &cells), "**bold**");
+}
+
+#[test]
+fn empty_copy_releases_input_guard() {
+ let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
+ let guard = Arc::new(crate::copy_input_guard::CopyInputGuard(
+ crate::app_event_sender::AppEventSender::new(tx),
+ ));
+ let weak = Arc::downgrade(&guard);
+ let mut view = TranscriptView::default();
+ assert!(!view.begin_copy_mode(&[], Some(guard)));
+ assert!(weak.upgrade().is_none());
+ assert!(matches!(
+ rx.try_recv(),
+ Ok(crate::app_event::AppEvent::TranscriptCopyClosed)
+ ));
+}
+
+#[test]
+fn copy_input_guard_is_released_on_all_selector_exits() {
+ let cells: Vec<Arc<dyn HistoryCell>> = vec![Arc::new(AgentMarkdownCell::new(
+ "response".into(),
+ Path::new("/"),
+ ))];
+ for exit in ["escape", "find", "mouse", "confirmed", "presentation"] {
+ let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
+ let guard = Arc::new(crate::copy_input_guard::CopyInputGuard(
+ crate::app_event_sender::AppEventSender::new(tx),
+ ));
+ let weak = Arc::downgrade(&guard);
+ let mut view = TranscriptView::default();
+ render(&mut view, &cells, /*width*/ 40, /*height*/ 5);
+ view.begin_copy_mode(&cells, Some(guard));
+ assert!(weak.upgrade().is_some());
+ match exit {
+ "escape" => {
+ view.handle_key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE), &cells);
+ }
+ "find" => view.begin_search(),
+ "mouse" => {
+ view.begin_selection(&cells, /*column*/ 2, /*row*/ 0, /*clicks*/ 1)
+ }
+ "confirmed" => {
+ view.copy_selected_text_with(
+ &cells,
+ "response",
+ /*clear_selection*/ true,
+ |_, _| Ok(CopyStatus::Confirmed),
+ )
+ .unwrap();
+ }
+ "presentation" => view.set_presentation(
+ /*detailed*/ true,
+ crate::history_cell::HistoryRenderMode::Raw,
+ ),
+ _ => unreachable!(),
+ }
+ assert!(weak.upgrade().is_none(), "{exit}");
+ assert!(matches!(
+ rx.try_recv(),
+ Ok(crate::app_event::AppEvent::TranscriptCopyClosed)
+ ));
+ }
+}
+
+#[test]
+fn user_code_blocks_preserve_original_line_endings() {
+ let cells: Vec<Arc<dyn HistoryCell>> = vec![Arc::new(crate::history_cell::new_user_prompt(
+ "```sh\r\necho user \r\n```\r\n".into(),
+ Vec::new(),
+ Vec::new(),
+ Vec::new(),
+ ))];
+ let mut view = TranscriptView::default();
+ render(&mut view, &cells, /*width*/ 40, /*height*/ 10);
+ view.begin_copy_mode(&cells, /*guard*/ None);
+ assert_eq!(payload(&mut view, &cells), "echo user \r\n");
+}
+
+#[test]
+fn latest_partial_response_owns_its_payload() {
+ let cells: Vec<Arc<dyn HistoryCell>> = vec![
+ Arc::new(AgentMarkdownCell::new(
+ "Previous completed answer".into(),
+ Path::new("/"),
+ )),
+ Arc::new(AgentMarkdownCell::new(
+ "Interrupted **partial** answer".into(),
+ Path::new("/"),
+ )),
+ ];
+ let mut view = TranscriptView::default();
+ render(&mut view, &cells, /*width*/ 60, /*height*/ 12);
+ view.begin_copy_mode(&cells, /*guard*/ None);
+ assert_eq!(payload(&mut view, &cells), "Interrupted **partial** answer");
+}
+
+#[test]
+fn source_targets_survive_quotes_lists_and_rendered_tables() {
+ for (source, expected) in [
+ (
+ "> ```sh\n> echo first\n> ```\n\n> later **prose**\n",
+ vec![
+ "later **prose**\n",
+ "echo first\n",
+ "```sh\necho first\n```\n",
+ ],
+ ),
+ (
+ "- ```mermaid\n graph LR\n A --> B\n ```\n",
+ vec!["graph LR\nA --> B\n"],
+ ),
+ (
+ "> first ::git-push{cwd=\"/repo\"}\r\n\r\n> second\r\n",
+ vec!["first \r\n", "second\r\n"],
+ ),
+ (
+ "```md\n| A |\n| --- |\n| x |\n```\n\n```md\n| A |\n| --- |\n| x |\n```\n",
+ vec!["| A |\n| --- |\n| x |\n", "| A |\n| --- |\n| x |\n"],
+ ),
+ (
+ "```md\n| A | B |\n| --- | --- |\n| x | y |\n```\n",
+ vec!["| A | B |\n| --- | --- |\n| x | y |\n"],
+ ),
+ ] {
+ for mode in [
+ crate::history_cell::HistoryRenderMode::Rich,
+ crate::history_cell::HistoryRenderMode::Raw,
+ ] {
+ let cells: Vec<Arc<dyn HistoryCell>> = vec![Arc::new(AgentMarkdownCell::new(
+ source.into(),
+ Path::new("/"),
+ ))];
+ let mut view = TranscriptView::default();
+ view.set_presentation(/*detailed*/ false, mode);
+ render(&mut view, &cells, /*width*/ 60, /*height*/ 20);
+ view.begin_copy_mode(&cells, /*guard*/ None);
+ let mut actual = Vec::new();
+ for _ in &expected {
+ view.move_copy_target(&cells, KeyCode::Up);
+ actual.push(payload(&mut view, &cells));
+ }
+ actual.sort();
+ let mut expected = expected.clone();
+ expected.sort();
+ assert_eq!(actual, expected, "{mode:?}: {source}");
+ }
+ }
+}
+
+#[test]
+fn rendered_fenced_table_has_a_block_highlight() {
+ let cells: Vec<Arc<dyn HistoryCell>> = vec![Arc::new(AgentMarkdownCell::new(
+ "Before\n\n```md\n| A | B |\n| --- | --- |\n| x | y |\n```\n\nAfter".into(),
+ Path::new("/"),
+ ))];
+ let mut view = TranscriptView::default();
+ render(&mut view, &cells, /*width*/ 30, /*height*/ 10);
+ view.begin_copy_mode(&cells, /*guard*/ None);
+ view.move_copy_target(&cells, KeyCode::Up);
+ let buffer = render(&mut view, &cells, /*width*/ 30, /*height*/ 10);
+ let style = ratatui::buffer::Cell::default()
+ .set_style(crate::style::selection_style())
+ .style();
+ let rows = buffer
+ .content
+ .chunks(30)
+ .map(|row| {
+ let mark = if row.iter().all(|cell| cell.style() == style) {
+ "selected"
+ } else {
+ " "
+ };
+ format!(
+ "{mark} | {}",
+ row.iter()
+ .map(ratatui::buffer::Cell::symbol)
+ .collect::<String>()
+ .trim_end()
+ )
+ })
+ .collect::<Vec<_>>()
+ .join("\n");
+ insta::assert_snapshot!(rows);
+}
+
+#[test]
+fn copy_navigation_leaves_context_and_preserves_the_center_band() {
+ let context = (0..12)
+ .map(|i| format!("Context {i}\n\n"))
+ .collect::<String>();
+ let source = format!(
+ "{context}```sh\nfirst target\n```\n\n{context}```sh\nsecond target\n```\n\n{context}"
+ );
+ let cells: Vec<Arc<dyn HistoryCell>> =
+ vec![Arc::new(AgentMarkdownCell::new(source, Path::new("/")))];
+ let mut view = TranscriptView::default();
+ render(&mut view, &cells, /*width*/ 50, /*height*/ 16);
+ view.begin_copy_mode(&cells, /*guard*/ None);
+ for (key, expected_row) in [(KeyCode::Up, 11), (KeyCode::Up, 4), (KeyCode::Down, 11)] {
+ view.move_copy_target(&cells, key);
+ let buffer = render(&mut view, &cells, /*width*/ 50, /*height*/ 16);
+ let selection_style = ratatui::buffer::Cell::default()
+ .set_style(crate::style::selection_style())
+ .style();
+ let selected_rows = buffer
+ .content
+ .chunks(50)
+ .enumerate()
+ .filter_map(|(row, cells)| {
+ cells
+ .iter()
+ .any(|cell| cell.style() == selection_style)
+ .then_some(row)
+ })
+ .collect::<Vec<_>>();
+ assert_eq!(selected_rows, vec![expected_row]);
+ let before = text(&buffer);
+ view.reveal_copy_context(&cells);
+ assert_eq!(
+ text(&render(
+ &mut view, &cells, /*width*/ 50, /*height*/ 16
+ )),
+ before
+ );
+ }
+ let buffer = render(&mut view, &cells, /*width*/ 50, /*height*/ 10);
+ insta::assert_snapshot!(text(&buffer));
+}
+
+#[test]
+fn copy_resize_keeps_whole_user_padding_inside_context() {
+ let user = |message: &str| -> Arc<dyn HistoryCell> {
+ Arc::new(crate::history_cell::new_user_prompt(
+ message.into(),
+ Vec::new(),
+ Vec::new(),
+ Vec::new(),
+ ))
+ };
+ let cells: Vec<Arc<dyn HistoryCell>> = vec![
+ user("Earlier prompt"),
+ Arc::new(AgentMarkdownCell::new(
+ "Earlier context\n\n".repeat(12),
+ Path::new("/"),
+ )),
+ user("One\nTwo\nThree\nFour\nFive\nSix"),
+ Arc::new(AgentMarkdownCell::new(
+ "Later context\n\n".repeat(12),
+ Path::new("/"),
+ )),
+ ];
+ let mut view = TranscriptView::default();
+ render(&mut view, &cells, /*width*/ 50, /*height*/ 20);
+ view.begin_copy_mode(&cells, /*guard*/ None);
+ let len = view.layout(&cells, /*index*/ 2).unwrap().text().len();
+ view.select_copy_range(&cells, /*index*/ 2, 0..len);
+ render(&mut view, &cells, /*width*/ 50, /*height*/ 20);
+ let buffer = render(&mut view, &cells, /*width*/ 50, /*height*/ 10);
+ let selected = ratatui::buffer::Cell::default()
+ .set_style(crate::style::selection_style())
+ .style();
+ let rows = buffer
+ .content
+ .chunks(50)
+ .enumerate()
+ .filter_map(|(row, cells)| {
+ cells
+ .iter()
+ .any(|cell| cell.style() == selected)
+ .then_some(row)
+ })
+ .collect::<Vec<_>>();
+ assert!(!rows.is_empty());
+ assert!(
+ rows[0] > 0 && *rows.last().unwrap() < 9,
+ "selected rows: {rows:?}"
+ );
+ insta::assert_snapshot!(text(&buffer));
+}
+
+#[test]
+fn copy_navigation_keeps_bottom_context_when_prompt_header_appears() {
+ let cells: Vec<Arc<dyn HistoryCell>> = vec![
+ Arc::new(crate::history_cell::new_user_prompt(
+ "First prompt".into(),
+ Vec::new(),
+ Vec::new(),
+ Vec::new(),
+ )),
+ Arc::new(AgentMarkdownCell::new(
+ format!(
+ "{}\n```sh\necho target\n```\n\nLater context",
+ "Earlier context\n\n".repeat(/*n*/ 12)
+ ),
+ Path::new("/"),
+ )),
+ ];
+ let mut view = TranscriptView::default();
+ render(&mut view, &cells, /*width*/ 50, /*height*/ 7);
+ view.begin_copy_mode(&cells, /*guard*/ None);
+ view.move_copy_target(&cells, KeyCode::Home);
+ render(&mut view, &cells, /*width*/ 50, /*height*/ 7);
+ view.move_copy_target(&cells, KeyCode::Down);
+ let buffer = render(&mut view, &cells, /*width*/ 50, /*height*/ 7);
+ let rows = text(&buffer);
+ assert_eq!(
+ rows.lines().position(|line| line.contains("echo target")),
+ Some(5)
+ );
+ assert_eq!(
+ text(&render(
+ &mut view, &cells, /*width*/ 50, /*height*/ 7
+ )),
+ rows
+ );
+}
diff --git a/codex-rs/tui/src/transcript_view/footer.rs b/codex-rs/tui/src/transcript_view/footer.rs
index 27963d1037..e103c88436 100644
--- a/codex-rs/tui/src/transcript_view/footer.rs
+++ b/codex-rs/tui/src/transcript_view/footer.rs
@@ -20,6 +20,17 @@ impl TranscriptView {
motion: MotionMode,
latest_navigation: &str,
) -> Option<TranscriptFooter> {
+ if let Some(mode) = &self.copy_mode {
+ return Some(TranscriptFooter {
+ text: vec![
+ Line::from(format!("Copy {}", mode.label.to_lowercase())).bold(),
+ navigation_line("↑/↓/j/k select · g/G ends · enter copy · esc close"),
+ ]
+ .into(),
+ cursor_column: None,
+ is_interactive: true,
+ });
+ }
// A mouse-down anchor owns the gesture, but has no text to copy yet. Compare
// source positions so movement across wrapping or padding is not a selection.
let has_selected_text = self.selection.as_ref().is_some_and(|selection| {
diff --git a/codex-rs/tui/src/transcript_view/input.rs b/codex-rs/tui/src/transcript_view/input.rs
index f969ec17b2..883d1abaed 100644
--- a/codex-rs/tui/src/transcript_view/input.rs
+++ b/codex-rs/tui/src/transcript_view/input.rs
@@ -135,6 +135,9 @@ impl TranscriptView {
{
return true;
}
+ if self.copy_mode.is_some() {
+ return true;
+ }
if self.selection.is_some() {
return crate::text_selection::is_copy_key(key)
|| code == KeyCode::Esc
@@ -164,6 +167,9 @@ impl TranscriptView {
if key.kind == KeyEventKind::Release {
return None;
}
+ if let Some(action) = self.handle_copy_mode_key(key, cells) {
+ return Some(action);
+ }
if let Some(action) = self.handle_disclosure_key(key, cells) {
return Some(action);
}
@@ -336,7 +342,7 @@ impl TranscriptView {
self.handle_scroll_key(key, cells)
}
- fn handle_scroll_key(
+ pub(super) fn handle_scroll_key(
&mut self,
key: KeyEvent,
cells: &[Arc<dyn HistoryCell>],
diff --git a/codex-rs/tui/src/transcript_view/search.rs b/codex-rs/tui/src/transcript_view/search.rs
index 375041079b..6543524e10 100644
--- a/codex-rs/tui/src/transcript_view/search.rs
+++ b/codex-rs/tui/src/transcript_view/search.rs
@@ -102,6 +102,7 @@ impl TranscriptView {
if self.is_search_editing() {
return;
}
+ self.copy_mode = None;
let saved_position = self.position;
let saved_snapshot = self
.selection
diff --git a/codex-rs/tui/src/transcript_view/selection.rs b/codex-rs/tui/src/transcript_view/selection.rs
index 2c3868416d..26b8a2ae1f 100644
--- a/codex-rs/tui/src/transcript_view/selection.rs
+++ b/codex-rs/tui/src/transcript_view/selection.rs
@@ -20,6 +20,7 @@ struct PendingCopy {
detailed: bool,
follow: bool,
clear_selection: bool,
+ characters: usize,
}
pub(super) struct Selection {
@@ -41,6 +42,49 @@ pub(super) struct Selection {
}
impl TranscriptView {
+ pub(super) fn select_copy_range(
+ &mut self,
+ cells: &[Arc<dyn HistoryCell>],
+ index: usize,
+ range: std::ops::Range<usize>,
+ ) {
+ let Some(layout) = self.layout(cells, index) else {
+ return;
+ };
+ let key = self.entry_key(cells, index);
+ let start = Anchor {
+ key,
+ index,
+ offset: range.start,
+ row_bias: 0,
+ };
+ let end = Anchor {
+ offset: range.end,
+ ..start
+ };
+ let mut snapshot = self.capture_snapshot(cells);
+ snapshot.pinned.retain(|key, _| *key == EntryKey::Live);
+ snapshot.pinned.insert(key, layout);
+ self.selection = Some(Selection {
+ pending_copy: None,
+ primary_owner: None,
+ snapshot,
+ start,
+ end,
+ dragging: false,
+ moved: false,
+ moved_vertically: false,
+ pointer_origin_row: 0,
+ resume_on_empty: false,
+ pointer: None,
+ pressed_link: None,
+ origin: (start, end),
+ unit: SelectionUnit::Character,
+ preferred_column: None,
+ });
+ self.reveal_copy_context(cells);
+ }
+
pub(super) fn begin_selection(
&mut self,
cells: &[Arc<dyn HistoryCell>],
@@ -48,6 +92,7 @@ impl TranscriptView {
row: u16,
clicks: u8,
) {
+ self.copy_mode = None;
let Some((anchor, layout)) = self.hit_test(column, row) else {
return;
};
@@ -90,6 +135,7 @@ impl TranscriptView {
/// Rejoin current history, retaining Find offsets or a replaced group until navigation.
/// Real selections keep their reading position, including a retired live revision.
pub(crate) fn end_selection(&mut self, cells: &[Arc<dyn HistoryCell>]) {
+ self.copy_mode = None;
let Some(selection) = self.selection.take() else {
return;
};
@@ -133,6 +179,7 @@ impl TranscriptView {
let Some(mut selection) = self.selection.take() else {
return;
};
+ self.copy_mode = None;
// A Shift-click starts a new pointer gesture while retaining the text anchor.
if !selection.dragging {
selection.pointer_origin_row = row;
@@ -297,12 +344,33 @@ impl TranscriptView {
layout.copy_lines(range, separator, &mut lines);
previous = Some(layout);
}
- let (text, format) = crate::markdown_copy::selection(&lines, text);
+ let override_payload = self.copy_mode.as_ref().and_then(|mode| {
+ if mode.whole {
+ mode.response.as_ref().map(|(_, text)| {
+ (
+ text.to_string(),
+ crate::clipboard_copy::CopyFormat::Markdown,
+ )
+ })
+ } else {
+ mode.source
+ .as_ref()
+ .map(|text| (text.clone(), crate::clipboard_copy::CopyFormat::PlainText))
+ }
+ });
+ let (text, format) =
+ override_payload.unwrap_or_else(|| crate::markdown_copy::selection(&lines, text));
+ let characters = text.chars().count();
let result = copy(&text, format);
+ self.show_copy_feedback(&result, characters);
match result {
Ok(crate::clipboard_copy::CopyStatus::Confirmed) => {
if clear_selection {
+ let copy_mode = self.copy_mode.is_some();
self.end_selection(cells);
+ if copy_mode {
+ self.jump_to_latest();
+ }
}
}
Ok(crate::clipboard_copy::CopyStatus::Pending(id)) => {
@@ -313,8 +381,9 @@ impl TranscriptView {
end: selection.end,
position: self.position,
detailed: self.detailed,
- follow: false,
+ follow: clear_selection && self.copy_mode.is_some(),
clear_selection,
+ characters,
});
}
}
@@ -369,9 +438,7 @@ impl TranscriptView {
{
return None;
}
- let characters = self
- .selected_text(cells)
- .map_or(/*default*/ 0, |text| text.chars().count());
+ let characters = pending.characters;
if pending.clear_selection
&& completion.1 == Ok(crate::clipboard_copy::CopyStatus::Confirmed)
{
@@ -525,6 +592,20 @@ impl TranscriptView {
self.area.width,
/*height*/ 1,
);
+ if self.copy_mode.is_some() {
+ // Full-entry selections include final padding; partial ranges stay half-open.
+ let last = if begin == 0 && finish == visible.layout.text().len() {
+ finish
+ } else {
+ finish.saturating_sub(/*rhs*/ 1)
+ };
+ let rows =
+ visible.layout.row_for_offset(begin)..=visible.layout.row_for_offset(last);
+ if rows.contains(&visible.row) {
+ buf.set_style(area, crate::style::selection_style());
+ }
+ continue;
+ }
let next = (visible.index + 1..=end.index)
.filter_map(|index| {
selection
diff --git a/codex-rs/tui/src/transcript_view/snapshots/codex_tui__transcript_view__copy_mode__tests__copy_highlight_fills_a_block_across_blank_and_wrapped_rows.snap b/codex-rs/tui/src/transcript_view/snapshots/codex_tui__transcript_view__copy_mode__tests__copy_highlight_fills_a_block_across_blank_and_wrapped_rows.snap
new file mode 100644
index 0000000000..346ea211d2
--- /dev/null
+++ b/codex-rs/tui/src/transcript_view/snapshots/codex_tui__transcript_view__copy_mode__tests__copy_highlight_fills_a_block_across_blank_and_wrapped_rows.snap
@@ -0,0 +1,30 @@
+---
+source: tui/src/transcript_view/copy_mode_tests.rs
+assertion_line: 169
+expression: "snapshots.join(\"\\n---\\n\")"
+---
+................ | • Before
+................ |
+################ | longer line
+################ |
+################ | x
+................ |
+................ | After
+................ |
+................ |
+................ |
+................ |
+................ |
+---
+........ | • Before
+........ |
+######## | longer
+######## | line
+######## |
+######## | x
+........ |
+........ | After
+........ |
+........ |
+........ |
+........ |
diff --git a/codex-rs/tui/src/transcript_view/snapshots/codex_tui__transcript_view__copy_mode__tests__copy_navigation_leaves_context_and_preserves_the_center_band.snap b/codex-rs/tui/src/transcript_view/snapshots/codex_tui__transcript_view__copy_mode__tests__copy_navigation_leaves_context_and_preserves_the_center_band.snap
new file mode 100644
index 0000000000..e43aa2e0b8
--- /dev/null
+++ b/codex-rs/tui/src/transcript_view/snapshots/codex_tui__transcript_view__copy_mode__tests__copy_navigation_leaves_context_and_preserves_the_center_band.snap
@@ -0,0 +1,14 @@
+---
+source: tui/src/transcript_view/copy_mode_tests.rs
+expression: text(&buffer)
+---
+
+ Context 9
+
+ Context 10
+
+ Context 11
+
+ second target
+
+ Context 0
diff --git a/codex-rs/tui/src/transcript_view/snapshots/codex_tui__transcript_view__copy_mode__tests__copy_resize_keeps_whole_user_padding_inside_context.snap b/codex-rs/tui/src/transcript_view/snapshots/codex_tui__transcript_view__copy_mode__tests__copy_resize_keeps_whole_user_padding_inside_context.snap
new file mode 100644
index 0000000000..d3213328d1
--- /dev/null
+++ b/codex-rs/tui/src/transcript_view/snapshots/codex_tui__transcript_view__copy_mode__tests__copy_resize_keeps_whole_user_padding_inside_context.snap
@@ -0,0 +1,13 @@
+---
+source: tui/src/transcript_view/copy_mode_tests.rs
+assertion_line: 620
+expression: text(&buffer)
+---
+
+
+› One
+ Two
+ Three
+ Four
+ Five
+ Six
diff --git a/codex-rs/tui/src/transcript_view/snapshots/codex_tui__transcript_view__copy_mode__tests__rendered_fenced_table_has_a_block_highlight.snap b/codex-rs/tui/src/transcript_view/snapshots/codex_tui__transcript_view__copy_mode__tests__rendered_fenced_table_has_a_block_highlight.snap
new file mode 100644
index 0000000000..fea9a3118c
--- /dev/null
+++ b/codex-rs/tui/src/transcript_view/snapshots/codex_tui__transcript_view__copy_mode__tests__rendered_fenced_table_has_a_block_highlight.snap
@@ -0,0 +1,15 @@
+---
+source: tui/src/transcript_view/copy_mode_tests.rs
+assertion_line: 568
+expression: rows
+---
+ | • Before
+ |
+selected | A B
+selected | ━━━━━ ━━━━━
+selected | x y
+ |
+ | After
+ |
+ |
+ |
diff --git a/codex-rs/tui/src/transcript_view/snapshots/codex_tui__transcript_view__copy_mode__tests__whole_user_turn_highlight_includes_bottom_padding.snap b/codex-rs/tui/src/transcript_view/snapshots/codex_tui__transcript_view__copy_mode__tests__whole_user_turn_highlight_includes_bottom_padding.snap
new file mode 100644
index 0000000000..fe46f21e5f
--- /dev/null
+++ b/codex-rs/tui/src/transcript_view/snapshots/codex_tui__transcript_view__copy_mode__tests__whole_user_turn_highlight_includes_bottom_padding.snap
@@ -0,0 +1,18 @@
+---
+source: tui/src/transcript_view/copy_mode_tests.rs
+assertion_line: 235
+expression: "snapshots.join(\"\\n---\\n\")"
+---
+#################### |
+#################### | › Short prompt
+#################### |
+.................... |
+---
+########## |
+########## | › Longer
+########## | message
+########## |
+########## | last
+########## |
+.......... |
+.......... |
diff --git a/codex-rs/tui/src/transcript_view/text.rs b/codex-rs/tui/src/transcript_view/text.rs
index 44877552ca..282925dfd4 100644
--- a/codex-rs/tui/src/transcript_view/text.rs
+++ b/codex-rs/tui/src/transcript_view/text.rs
@@ -69,6 +69,62 @@ struct TextRow {
}
impl TextLayout {
+ pub(super) fn copy_block_ranges(&self) -> Vec<(Range<usize>, &'static str, Option<String>)> {
+ let mut ranges = Vec::new();
+ for (label, code) in [("Code block", true), ("Blockquote", false)] {
+ let mut active: Option<(Range<usize>, Option<std::sync::Arc<str>>)> = None;
+ let mut offset = 0;
+ for line in &self.logical {
+ let end = offset + line.origin.range.len();
+ let metadata = line.origin.copy.as_deref();
+ let matches = metadata.is_some_and(|copy| {
+ if code {
+ copy.code || copy.code_source.is_some()
+ } else {
+ copy.prefix.contains('>')
+ }
+ });
+ if matches {
+ let source = metadata.and_then(|copy| {
+ if code {
+ copy.code_source.as_ref()
+ } else {
+ copy.quote_source.as_ref()
+ }
+ });
+ // Shared source identity survives wrapping and separates adjacent blocks,
+ // including equal payloads. A list marker can precede the first source row.
+ if let Some(source) = source
+ && active
+ .as_ref()
+ .and_then(|(_, retained)| retained.as_ref())
+ .is_some_and(|retained| !std::sync::Arc::ptr_eq(retained, source))
+ && let Some((range, retained)) = active.take()
+ {
+ ranges.push((range, label, retained.map(|source| source.to_string())));
+ }
+ let (range, retained) = active.get_or_insert((offset..end, None));
+ range.end = end;
+ if retained.is_none() {
+ *retained = source.cloned();
+ }
+ } else if let Some((range, source)) = active.take() {
+ ranges.push((range, label, source.map(|source| source.to_string())));
+ }
+ offset = end + 1;
+ }
+ if let Some((range, source)) = active {
+ ranges.push((range, label, source.map(|source| source.to_string())));
+ }
+ }
+ ranges.retain(|(range, _, _)| {
+ self.text
+ .get(range.clone())
+ .is_some_and(|text| !text.trim().is_empty())
+ });
+ ranges
+ }
+
pub(super) fn new(lines: Vec<HyperlinkLine>, width: u16) -> Self {
let logical = logical_lines(&lines);
Self::from_logical(logical, width)