Dock the Agent Command Center beside the conversation (#62986)

## Why

Opening the Agent Command Center in a modal interrupts the conversation
view. Docking it keeps the transcript and draft visible while browsing
tasks when the terminal has room for both panes.

## What changed

With `features.tui_workspace` enabled in owned transcript mode, the
Command Center opens to the left of the conversation on wide terminals.
On narrow terminals, the focused pane fills the screen. Opening a task
returns focus to the conversation and keeps the dock open. Other
transcript modes continue to use the modal Command Center.

## Testing

Add coverage for draft and reading-position preservation, wide and narrow
layouts, queued results arriving after a focus change, and selecting a
new session when its task appears in the dock.

GitOrigin-RevId: d07c9cad3bb8685167b5995e550c406948d7a6e3
This commit is contained in:
Felipe Coury
2026-11-21 15:14:53 +00:00
committed by copyberry
parent 1145028ae4
commit 1731314b3b
32 changed files with 977 additions and 179 deletions
+36 -17
View File
@@ -28,6 +28,7 @@ use crate::app_server_session::app_server_rate_limit_snapshots;
use crate::bottom_pane::AppLinkViewParams;
use crate::bottom_pane::ApplyPatchApprovalRequest;
use crate::bottom_pane::ApprovalRequest;
use crate::bottom_pane::BottomPaneView;
use crate::bottom_pane::ExecApprovalRequest;
use crate::bottom_pane::FeedbackAudience;
use crate::bottom_pane::McpElicitationApprovalRequest;
@@ -230,6 +231,7 @@ mod composer_hints;
mod config_panel;
mod config_persistence;
mod connector_mentions;
mod conversation_workspace;
mod daemon_menu;
mod daybreak;
mod empty_state_policy;
@@ -1001,6 +1003,36 @@ impl App {
{
return Ok(AppRunControl::Continue);
}
if self.workspace_center_owns_input() {
match &event {
TuiEvent::Key(key) => {
self.handle_workspace_key(tui, *key);
if !self.agents_overview.workspace.is_open() {
self.cancel_cloud_inventory_refresh(app_server).await;
if self.reconnect.presentation == reconnect::ReconnectPresentation::Overview
{
self.reconnect.presentation =
reconnect::ReconnectPresentation::Conversation;
}
}
return Ok(AppRunControl::Continue);
}
TuiEvent::Paste(text) if !composer_paste => {
self.cancel_pending_key_chord();
if let Some(view) = &mut self.agents_overview.workspace.view {
view.handle_paste(text.clone());
}
tui.frame_requester().schedule_frame();
return Ok(AppRunControl::Continue);
}
_ => {}
}
}
if let TuiEvent::Mouse(mouse) = &event
&& self.handle_workspace_mouse(tui, *mouse)
{
return Ok(AppRunControl::Continue);
}
if matches!(&event, TuiEvent::Key(_))
&& self.handle_composer_copy_event(tui, &event, |tui, text| {
tui.copy_transcript_selection(text, crate::clipboard_copy::CopyFormat::PlainText)
@@ -1153,7 +1185,7 @@ impl App {
if let Some(current) = side_pane::layout(self, tui, size.into())
&& current.passive_thread == painted.passive_thread
&& let Some(peer) = self.current_displayed_thread_id()
&& painted.passive.union(painted.focused) == Rect::from(size)
&& painted.passive.union(painted.focused) == self.workspace_chat_area(size.into())
{
let painted_area = painted.passive;
if let Some(link) = self.transcript_link_at(*press) {
@@ -1203,20 +1235,10 @@ impl App {
return Ok(AppRunControl::Continue);
}
self.cancel_primed_browsing_for_event(&event);
let voice_toggle = |app: &Self, key: KeyEvent| {
key.kind == KeyEventKind::Press
&& app
.active_keymap_contexts()
.contains_action(crate::keymap::KeymapActionId {
context: crate::keymap::KeymapContext::Chat,
action: "toggle_voice",
})
&& app.keymap.chat.toggle_voice.is_pressed(key)
};
// Transcript interactions consume otherwise-unhandled keys; let enabled voice controls
// reach App.
if !matches!(&event, TuiEvent::Key(key)
if voice_toggle(self, *key)
if self.voice_toggle_pressed(*key)
&& (!self.transcript_view.owns_interaction_key(*key)
|| self.transcript_view.is_select_mode()))
&& !composer_paste
@@ -1247,12 +1269,8 @@ impl App {
}
}
if let TuiEvent::Key(key_event) = &event
&& voice_toggle(self, *key_event)
&& self.handle_voice_toggle_key(tui, *key_event)
{
self.cancel_transcript_browsing(tui);
if !self.chat_widget.handle_startup_submission_key(*key_event) {
self.control_voice(crate::app_event::VoiceControl::Toggle);
}
return Ok(AppRunControl::Continue);
}
if let TuiEvent::Key(key_event) = &event
@@ -1439,6 +1457,7 @@ impl App {
let visible = self.current_displayed_thread_id().filter(|&id| {
tui.is_terminal_focused()
&& !self.conversation_frame.panel_covers_transcript()
&& !self.conversation_area(screen_size.into()).is_empty()
&& matches!(self.overlay, None | Some(Overlay::Transcript(_)))
&& self.chat_widget.no_modal_or_popup_active()
&& self.initial_history_replay_buffer.is_none()
+6 -1
View File
@@ -177,12 +177,17 @@ impl Renderable for AgentsOverviewView {
);
tabs.width = tabs.width.saturating_sub(hint_width + 2);
}
render_filled_tab_bar(
let targets = render_filled_tab_bar(
&labels.iter().map(String::as_str).collect::<Vec<_>>(),
state.status_filter,
tabs,
buf,
);
if self.dock_focused == Some(false)
&& let Some((_, tab)) = targets.iter().find(|(id, _)| *id == state.status_filter)
{
buf.set_style(*tab, crate::style::quiet_workspace_style());
}
line(
"─"
.repeat(usize::from(area.width.saturating_sub(/*rhs*/ 4)))
+7 -2
View File
@@ -67,6 +67,11 @@ impl AgentsOverviewView {
);
return;
}
let selected_style = if self.dock_focused == Some(false) {
crate::style::quiet_workspace_style()
} else {
selection_style()
};
let entries = self.center_rows(&indices, state.grouping);
let selected = entries
.iter()
@@ -112,7 +117,7 @@ impl AgentsOverviewView {
let rect = row(viewport, offset as u16, /*height*/ 1);
let selected = self.selected == usize::MAX;
let style = if selected {
selection_style()
selected_style
} else {
Style::default()
};
@@ -196,7 +201,7 @@ impl AgentsOverviewView {
continue;
}
let style = if index == self.selected {
selection_style()
selected_style
} else {
Style::default()
};
+228
View File
@@ -1007,3 +1007,231 @@ async fn live_center_show_more_navigation_search_and_loading() {
);
insta::assert_snapshot!(screen(&view, /*width*/ 80, /*height*/ 12).lines().nth(6).unwrap(), @" › Show more matches");
}
#[tokio::test]
async fn workspace_navigation_preserves_the_draft_and_reading_position() -> Result<()> {
use crate::app::owned_transcript::tests::attach_thread;
use crate::app::owned_transcript::tests::buffer_text;
let (mut app, mut events, _ops) = make_test_app_with_channels().await;
let mut server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;
app.local_settings.tui.animations = false;
let wide = Size::new(/*width*/ 90, /*height*/ 14);
let mut tui = crate::tui::test_support::make_test_tui_with_size(wide)?;
tui.set_owned_screen(/*owned*/ true)?;
app.config.features.enable(Feature::TuiWorkspace)?;
app.local_settings.transcript_mode = crate::transcript_mode::TranscriptMode::Owned;
let id = ThreadId::from_u128(/*value*/ 12);
attach_thread(&mut app, id);
let mut title = "Investigate retry";
let mut task = overview_thread(
id,
/*parent_thread_id*/ None,
title,
ThreadStatus::Idle,
);
task.git_info = Some(codex_app_server_protocol::GitInfo {
branch: Some("retry-fix".into()),
sha: None,
origin_url: None,
});
task.updated_at = 4_000_000_000;
app.agents_overview.threads.insert(id, Some(task));
app.agents_overview
.pins_by_backend
.insert(server.backend_id(), Some(vec![id]));
let rows = (0..40)
.map(|i| format!("Response row {i}").into())
.collect();
app.transcript_cells
.push(Arc::new(history_cell::PlainHistoryCell::new(rows)));
let paste = TuiEvent::Paste("Keep this draft".into());
app.handle_tui_event(&mut tui, &mut server, paste).await?;
app.render_chat_widget_frame(&mut tui, wide)?;
app.transcript_view
.scroll(&app.transcript_cells, /*rows*/ -10);
app.render_chat_widget_frame(&mut tui, wide)?;
let before = buffer_text(tui.terminal.previous_buffer());
let first = before.lines().next().unwrap().trim();
assert!(first.starts_with("Response row"));
assert_eq!(
app.chat_widget.composer_text_with_pending(),
"Keep this draft"
);
let narrow = Size::new(50, 14);
let mut screens = Vec::new();
let mut wide_styles = Vec::new();
for (label, size, center_focused) in [
("Wide Command Center", wide, true),
("Wide conversation", wide, false),
("Narrow conversation", narrow, false),
("Narrow Command Center", narrow, true),
("Restored dock", wide, true),
] {
tui.terminal.resize(size)?;
if center_focused && !app.workspace_center_owns_input() {
Box::pin(app.handle_event(&mut tui, &mut server, AppEvent::OpenAgentsOverview)).await?;
} else if !center_focused && app.workspace_center_owns_input() {
let click = crossterm::event::MouseEvent {
kind: crossterm::event::MouseEventKind::Down(crossterm::event::MouseButton::Left),
column: wide.width - 1,
row: 0,
modifiers: KeyModifiers::NONE,
};
app.handle_tui_event(&mut tui, &mut server, TuiEvent::Mouse(click))
.await?;
}
if size == wide && !center_focused {
title = "Investigate retry again";
let renamed = ServerNotification::ThreadNameUpdated(ThreadNameUpdatedNotification {
thread_id: id.to_string(),
thread_name: Some(title.into()),
});
app.handle_app_server_event(
&server,
AppServerEvent::ServerNotification(Box::new(renamed)),
)
.await;
}
tui.screen_size_for_event(&TuiEvent::Resize(size))?;
crate::terminal_palette::with_test_default_colors(
crate::terminal_probe::DefaultColors {
fg: (230, 230, 230),
bg: (20, 20, 20),
},
|| app.render_chat_widget_frame(&mut tui, size),
)?;
let buffer = tui.terminal.previous_buffer();
let screen = buffer_text(buffer);
assert_eq!(app.workspace_center_owns_input(), center_focused, "{label}");
if size == wide && wide_styles.len() < 2 {
wide_styles.push([title, "All 1", "Keep this draft"].map(|text| {
let (row, prefix) = screen
.lines()
.enumerate()
.find_map(|(row, line)| Some((row, line.split_once(text)?.0)))
.expect("visible task, filter and draft");
buffer[(prefix.chars().count() as u16, row as u16)].style()
}));
}
if matches!(label, "Wide Command Center" | "Narrow Command Center") {
let screen = normalize_agent_center_snapshot(screen);
screens.push(format!("{label}\n{screen}"));
}
}
let [center, conversation] = wide_styles.as_slice() else {
panic!("expected both wide focus states");
};
for (center_style, conversation_style) in center.iter().zip(conversation) {
assert_ne!(center_style, conversation_style);
}
assert_ne!(center[2].fg, conversation[2].fg);
assert_ne!(center[2].bg, conversation[2].bg);
app.handle_tui_event(&mut tui, &mut server, TuiEvent::Key(KeyCode::Tab.into()))
.await?;
app.render_chat_widget_frame(&mut tui, wide)?;
assert!(buffer_text(tui.terminal.previous_buffer()).contains("No matching tasks"));
insta::assert_snapshot!("workspace_responsive_focus", screens.join("\n\n"));
app.handle_tui_event(&mut tui, &mut server, TuiEvent::Paste("ignored".into()))
.await?;
for key in [KeyCode::BackTab, KeyCode::Enter] {
app.handle_tui_event(&mut tui, &mut server, TuiEvent::Key(key.into()))
.await?;
}
let selected = std::iter::from_fn(|| events.try_recv().ok())
.find(|event| {
matches!(event, AppEvent::SelectAgentsOverviewThread { thread_id } if *thread_id == id)
})
.expect("Enter selects the displayed task");
Box::pin(app.handle_event(&mut tui, &mut server, selected)).await?;
let bottom = app.render_chat_widget_frame(&mut tui, wide)?;
let screen = buffer_text(tui.terminal.previous_buffer());
assert!(screen.contains(title));
assert!(screen.lines().next().unwrap().ends_with(first));
assert!(bottom.contains(tui.terminal.last_known_cursor_pos));
assert_eq!(
app.chat_widget.composer_text_with_pending(),
"Keep this draft"
);
Box::pin(app.handle_event(&mut tui, &mut server, AppEvent::OpenAgentsOverview)).await?;
app.sidebar_mut().show(
crate::app::sidebar::SidebarContent::Chooser,
crate::app::sidebar::PaneFocus::Sidebar,
);
let three_panes = Size::new(185, 18);
let combined = crate::app::test_support::side_frame(&mut app, &mut tui, three_panes)?;
let center = app.conversation_frame.command_center.unwrap();
let side = app.conversation_frame.panel_area().unwrap();
let middle = app.conversation_area(Rect::new(0, 0, 185, 18));
assert!(center.right() <= middle.x && middle.right() <= side.x && !middle.is_empty());
let labels = ["Agent command center", "Keep this draft", "Open in sidebar"].map(|label| {
combined
.lines()
.find_map(|line| line.find(label))
.map(|_| label)
});
insta::assert_snapshot!(format!("{labels:?}"),@"[Some(\"Agent command center\"), Some(\"Keep this draft\"), Some(\"Open in sidebar\")]");
let divider = app
.conversation_frame
.divider_area()
.expect("right divider");
let mouse = |kind, column| {
TuiEvent::Mouse(crossterm::event::MouseEvent {
kind,
column,
row: divider.y,
modifiers: KeyModifiers::NONE,
})
};
use crossterm::event::MouseButton::Left;
use crossterm::event::MouseEventKind::Down;
use crossterm::event::MouseEventKind::Drag;
tui.screen_size_for_event(&TuiEvent::Resize(three_panes))?;
app.handle_tui_event(&mut tui, &mut server, mouse(Down(Left), divider.x))
.await?;
app.handle_tui_event(&mut tui, &mut server, mouse(Drag(Left), divider.x - 6))
.await?;
crate::app::test_support::side_frame(&mut app, &mut tui, three_panes)?;
let preview = app
.conversation_frame
.divider_area()
.expect("right divider");
assert_eq!(preview.x, divider.x - 6);
app.handle_tui_event(&mut tui, &mut server, TuiEvent::Key(KeyCode::Enter.into()))
.await?;
let selected = std::iter::from_fn(|| events.try_recv().ok())
.find(|event| {
matches!(event, AppEvent::SelectAgentsOverviewThread { thread_id } if *thread_id == id)
})
.expect("Enter selects the displayed task with the chooser open");
Box::pin(app.handle_event(&mut tui, &mut server, selected)).await?;
assert_eq!(
app.panel_focus(),
Some(crate::app::sidebar::PaneFocus::Main)
);
app.handle_tui_event(&mut tui, &mut server, TuiEvent::Paste("!".into()))
.await?;
assert!(app.chat_widget.composer_text_with_pending().contains('!'));
app.handle_tui_event(
&mut tui,
&mut server,
TuiEvent::Key(KeyCode::Backspace.into()),
)
.await?;
app.open_agents_overview(&server);
app.sidebar_mut().hide();
app.handle_tui_event(&mut tui, &mut server, TuiEvent::Key(KeyCode::Esc.into()))
.await?;
tui.screen_size_for_event(&TuiEvent::Resize(wide))?;
app.render_chat_widget_frame(&mut tui, wide)?;
assert_eq!(buffer_text(tui.terminal.previous_buffer()), before);
server.shutdown().await?;
Ok(())
}
+63 -31
View File
@@ -41,6 +41,7 @@ pub(crate) const AGENTS_OVERVIEW_VIEW_ID: &str = "agents-overview";
#[derive(Default)]
pub(super) struct AgentsOverviewState {
pub(super) workspace: super::conversation_workspace::Workspace,
/// Missing metadata records a local resume until the next metadata refresh.
pub(super) threads: HashMap<ThreadId, Option<Thread>>,
/// Identifies the query that populated the cached search results.
@@ -137,18 +138,43 @@ impl Drop for AgentsOverviewState {
}
impl App {
/// Read the selected row from its host, even while a dialog has focus.
pub(super) fn overview_selected_index(&self) -> Option<usize> {
let workspace = &self.agents_overview.workspace;
if workspace.is_open() {
return workspace.selected_index();
}
self.chat_widget
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
}
pub(super) fn overview_selected_thread_id(&self) -> Option<ThreadId> {
let index = self.overview_selected_index()?;
self.agents_overview.visible_thread_ids.get(index).copied()
}
pub(super) fn agents_overview_has_focus(&self) -> bool {
self.workspace_center_owns_input()
|| self.chat_widget.active_view_is(AGENTS_OVERVIEW_VIEW_ID)
}
pub(super) fn open_agents_overview(&mut self, app_server: &AppServerSession) {
let threads = self
.agents_overview
.threads
.values()
.flatten()
.cloned()
.collect();
let selected_thread_id = self.agents_overview.selection_after_removal.take();
let dock = self.local_settings.workspace_enabled(&self.config);
let overview = &mut self.agents_overview;
let threads = overview.threads.values().flatten().cloned().collect();
let selected_thread_id = overview.selection_after_removal.take().or_else(|| {
let index = overview.workspace.selected_index()?;
overview.visible_thread_ids.get(index).copied()
});
let view = self.agents_overview_view(threads, selected_thread_id);
self.agents_overview.visible_thread_ids = view.thread_ids();
self.chat_widget.show_bottom_pane_view(Box::new(view));
if dock {
self.agents_overview.workspace.replace_view(view);
self.agents_overview.workspace.focus_center();
self.chat_widget.request_redraw();
} else {
self.chat_widget.show_bottom_pane_view(Box::new(view));
}
if self.reconnect.offline {
self.reconnect.presentation = reconnect::ReconnectPresentation::Overview;
let mut state = self
@@ -379,10 +405,7 @@ impl App {
if self.agents_overview.active_refresh.is_some() || self.reconnect.offline {
return;
}
let visible = self
.chat_widget
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
.is_some();
let visible = self.overview_selected_index().is_some();
if let Some((backend_id, handle)) = self
.agents_overview
.pending_refresh_backends
@@ -485,10 +508,7 @@ impl App {
}
pub(super) fn repaint_agents_overview(&mut self) {
let Some(selected) = self
.chat_widget
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
else {
let Some(selected) = self.overview_selected_index() else {
return;
};
let previous_thread_id = self
@@ -535,10 +555,7 @@ impl App {
.selected_index()
.and_then(|index| self.agents_overview.visible_thread_ids.get(index).copied());
if (previous_thread_id.is_none() || previous_thread_id != next_thread_id)
&& self
.chat_widget
.selected_index_for_active_view(AGENTS_OVERVIEW_VIEW_ID)
.is_some()
&& self.agents_overview_has_focus()
{
self.cancel_pending_key_chord();
}
@@ -557,8 +574,13 @@ impl App {
state.rename_target = None;
state.input.set_text_clearing_elements("");
}
self.chat_widget
.replace_bottom_pane_view_if_present(AGENTS_OVERVIEW_VIEW_ID, Box::new(view));
if self.agents_overview.workspace.is_open() {
self.agents_overview.workspace.replace_view(view);
self.chat_widget.request_redraw();
} else {
self.chat_widget
.replace_bottom_pane_view_if_present(AGENTS_OVERVIEW_VIEW_ID, Box::new(view));
}
}
pub(super) fn agents_overview_view(
@@ -744,6 +766,14 @@ impl App {
.await
}
fn redraw_during_task_attach(&mut self, tui: &mut tui::Tui) -> Result<()> {
if self.agents_overview.workspace.is_open() {
self.refresh_owned_transcript(tui)
} else {
loading::draw(tui).map_err(Into::into)
}
}
async fn attach_agents_overview_thread(
&mut self,
tui: &mut tui::Tui,
@@ -761,7 +791,9 @@ impl App {
{
self.cancel_cloud_inventory_refresh(app_server).await;
// Keep the displayed read-only snapshot frozen; R explicitly retries attachment.
if let Ok(mut state) = self.agents_overview.view_state.lock() {
if !self.agents_overview.workspace.is_open()
&& let Ok(mut state) = self.agents_overview.view_state.lock()
{
state.completion = Some(crate::bottom_pane::ViewCompletion::Accepted);
}
self.chat_widget.pre_draw_tick();
@@ -770,7 +802,7 @@ impl App {
if self.reject_pending_permission_root_switch() {
return Ok(AppRunControl::Continue);
}
if startup_draft.is_none() {
if startup_draft.is_none() && !self.agents_overview.workspace.is_open() {
loading::draw(tui)?;
}
let mut restored_blank_session = false;
@@ -922,9 +954,9 @@ impl App {
Err(control) => return Ok(control),
}
}
// Folder selection and trust prompts can replace or clear the loading frame.
// Folder selection and trust prompts can replace or clear the current frame.
if startup_draft.is_none() {
loading::draw(tui)?;
self.redraw_during_task_attach(tui)?;
}
let baseline_approval = resume_config.permissions.approval_policy.value();
let baseline_reviewer = resume_config.approvals_reviewer;
@@ -1123,10 +1155,6 @@ impl App {
if !is_new_session && !restored_blank_session {
self.agents_overview.blank_sessions.remove(&root_thread_id);
}
// Replacing the widget clears the terminal before the remaining server requests.
if startup_draft.is_none() {
loading::draw(tui)?;
}
if let Some(error) = provider_error {
self.chat_widget
.show_provider_error(error, /*rejected_message_id*/ None);
@@ -1145,6 +1173,10 @@ impl App {
self.chat_widget
.add_info_message(notice.to_string(), /*hint*/ None);
}
// Widget replacement clears the terminal. Paint the destination before further waits.
if startup_draft.is_none() {
self.redraw_during_task_attach(tui)?;
}
let mut destination_config = self.chat_widget.config_ref().clone();
if self.app_server_target.uses_remote_workspace() {
destination_config.cwd.clone_from(&self.config.cwd);
+21 -11
View File
@@ -8,6 +8,7 @@ use crate::app_event::AgentsOverviewAction;
use crate::app_event::AppEvent;
use crate::app_server_session::AppServerSession;
use crate::backend_id::BackendId;
use crate::bottom_pane::BottomPaneView;
use crate::bottom_pane::SelectionItem;
use crate::bottom_pane::SelectionViewParams;
use crate::chatwidget::ChatWidget;
@@ -71,18 +72,31 @@ async fn run_lifecycle_modal<T>(
if matches!(&event, tui::TuiEvent::Paste(_) | tui::TuiEvent::FocusLost) {
app.cancel_pending_key_chord();
}
let dashboard_active = app.chat_widget
let dock_owns_input = app.workspace_center_owns_input();
let dashboard_active = dock_owns_input || app.chat_widget
.selected_index_for_active_view(AGENTS_OVERVIEW_VIEW_ID)
.is_some();
match event {
tui::TuiEvent::Key(key) if dashboard_active => {
if let Some(key) = app.route_key_chord_event(tui, key) {
app.chat_widget.handle_key_event_with_activation_key(key, app.routed_key_activation);
if dock_owns_input {
if let Some(view) = &mut app.agents_overview.workspace.view {
view.handle_key_event(key);
}
} else {
app.chat_widget.handle_key_event_with_activation_key(key, app.routed_key_activation);
}
}
tui.frame_requester().schedule_frame();
}
tui::TuiEvent::Paste(text) if dashboard_active => {
app.chat_widget.handle_paste(text);
if dock_owns_input {
if let Some(view) = &mut app.agents_overview.workspace.view {
view.handle_paste(text);
}
} else {
app.chat_widget.handle_paste(text);
}
tui.frame_requester().schedule_frame();
}
tui::TuiEvent::Key(_) | tui::TuiEvent::Paste(_) | tui::TuiEvent::FocusLost | tui::TuiEvent::Mouse(_) => {}
@@ -399,14 +413,10 @@ impl App {
self.cancel_agents_overview_refresh(app_server.backend_id());
}
if detach_primary {
self.agents_overview.selection_after_removal =
self.agents_overview.selection_after_removal.or_else(|| {
self.chat_widget
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
.and_then(|index| {
self.agents_overview.visible_thread_ids.get(index).copied()
})
});
self.agents_overview.selection_after_removal = self
.agents_overview
.selection_after_removal
.or_else(|| self.overview_selected_thread_id());
self.reset_for_thread_switch(tui)?;
self.pending_thread_switch_resets += 1;
self.app_event_tx
@@ -17,6 +17,7 @@ use pretty_assertions::assert_eq;
#[tokio::test]
async fn pin_action_updates_shared_section_state() -> Result<()> {
let mut app = make_test_app().await;
crate::app::test_support::use_modal_agents_overview(&mut app);
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
app.app_event_tx = AppEventSender::new(tx);
let mut app_server = crate::start_embedded_app_server_for_picker(&app.config).await?;
@@ -364,6 +365,7 @@ async fn archiving_selects_the_next_displayed_task() -> Result<()> {
for filtered in [false, true] {
let (mut app, mut rx, _op_rx) =
crate::app::tests::make_test_app_with_channels().await;
crate::app::test_support::use_modal_agents_overview(&mut app);
let mut app_server =
crate::start_embedded_app_server_for_picker(&app.config).await?;
let mut tui = crate::tui::test_support::make_test_tui()?;
@@ -1009,6 +1011,7 @@ async fn lifecycle_removes_background_and_current_tasks_without_losing_the_dashb
};
let (mut app, mut rx, _op_rx) =
Box::pin(crate::app::tests::make_test_app_with_channels()).await;
crate::app::test_support::use_modal_agents_overview(&mut app);
let (release, gate) = tokio::sync::oneshot::channel();
let (server, _completions) = start_streaming_sse_server(vec![vec![
StreamingSseChunk {
@@ -136,7 +136,13 @@ async fn overview_return_to_current_chat_cancels_the_cloud_list_and_allows_reope
next_cloud_page(commands, /*cursor*/ None).await
};
let mut tui = crate::tui::test_support::make_test_tui()?;
crate::app::test_support::enable_side_retention(&mut app)?;
tui.set_owned_screen(/*owned*/ true)?;
for key in [KeyCode::Esc, KeyCode::Enter] {
if key == KeyCode::Enter {
// Escape closes the dock. Selection closes the original modal.
crate::app::test_support::use_modal_agents_overview(&mut app);
}
app.open_agents_overview(&cloud);
let held_list = tokio::time::timeout(timeout, next_list(&mut commands)).await?;
Box::pin(app.handle_tui_event(&mut tui, &mut cloud, TuiEvent::Key(key.into()))).await?;
@@ -157,7 +163,7 @@ async fn overview_return_to_current_chat_cancels_the_cloud_list_and_allows_reope
.await??;
}
assert!(held_list.response.is_closed());
assert!(!app.chat_widget.active_view_is(AGENTS_OVERVIEW_VIEW_ID));
assert!(app.overview_selected_index().is_none());
}
// The previous archive was observed, but its unarchive notification was missed.
@@ -30,11 +30,7 @@ impl App {
title: Option<&'static str>,
message: String,
) {
if self
.chat_widget
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
.is_some()
{
if self.overview_selected_index().is_some() {
let items = vec![SelectionItem {
name: "Return to command center".to_string(),
dismiss_on_select: true,
@@ -245,6 +245,9 @@ impl App {
"Could not open the new session.",
);
}
} else if self.agents_overview.workspace.is_open() {
self.focus_workspace_composer(tui);
self.repaint_agents_overview();
}
Ok(control)
}
@@ -2,19 +2,16 @@
//! Choose against the displayed order before mutation; pending successors survive
//! batched removals and duplicate completion notifications until the next repaint.
use super::AGENTS_OVERVIEW_VIEW_ID;
use super::App;
use codex_protocol::ThreadId;
use std::collections::HashSet;
impl App {
pub(in crate::app) fn prepare_agents_overview_removal(&mut self, removed: &HashSet<ThreadId>) {
let selected = self.agents_overview.selection_after_removal.or_else(|| {
let index = self
.chat_widget
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)?;
self.agents_overview.visible_thread_ids.get(index).copied()
});
let selected = self
.agents_overview
.selection_after_removal
.or_else(|| self.overview_selected_thread_id());
let Some(selected) = selected.filter(|id| removed.contains(id)) else {
return;
};
+128 -8
View File
@@ -366,8 +366,10 @@ async fn late_overview_page_only_refills_its_own_backend() {
}
#[tokio::test]
async fn queued_overview_page_survives_a_focus_change() {
async fn queued_overview_page_survives_a_focus_change() -> Result<()> {
let mut app = make_test_app().await;
app.config.features.enable(Feature::TuiWorkspace)?;
app.local_settings.transcript_mode = crate::transcript_mode::TranscriptMode::Owned;
let owner = BackendId::new();
let other = BackendId::new();
let (client, _commands, _events) = CloudClient::channel(/*capacity*/ 1);
@@ -409,9 +411,15 @@ async fn queued_overview_page_survives_a_focus_change() {
assert!(app.agents_overview.active_refresh.is_none());
app.app_server_backend_id = Some(owner);
app.open_agents_overview(&session);
let mut tui = crate::tui::test_support::make_test_tui()?;
app.focus_workspace_composer(&mut tui);
app.drain_agents_overview_refresh_queue();
let (page, page_owner) = app.agents_overview.active_refresh.unwrap();
assert_eq!(page_owner, owner);
assert_eq!(
app.agents_overview.pending_refresh_backends.front(),
Some(&owner)
);
assert!(app.agents_overview.refresh_show_more);
assert!(!app.agents_overview.active_refresh_recent);
assert!(app.agents_overview.refresh_recent_backends.contains(&owner));
@@ -440,6 +448,7 @@ async fn queued_overview_page_survives_a_focus_change() {
assert_eq!(app.agents_overview.active_refresh, Some((recent, owner)));
assert!(app.agents_overview.cloud_inventory_dirty.contains(&owner));
app.cancel_agents_overview_refresh(owner);
Ok(())
}
#[tokio::test]
@@ -474,6 +483,7 @@ async fn cloud_inventory_polls_when_visible_and_detached() {
#[tokio::test]
async fn overview_keeps_rows_and_routes_actions_to_the_owner() -> Result<()> {
let mut app = make_test_app().await;
crate::app::test_support::use_modal_agents_overview(&mut app);
let (mut displayed, mut commands, _events) =
overview_session_stub(BackendId::new(), ThreadParamsMode::Cloud);
let remote_owner = BackendId::new();
@@ -1063,6 +1073,7 @@ async fn shared_overview_keeps_rows_and_replays_changes_over_stale_reads() -> Re
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn shared_overview_seeds_once_and_retains_locally_resumed_history() -> Result<()> {
let mut app = make_test_app().await;
crate::app::test_support::use_modal_agents_overview(&mut app);
trust_fixture_folders(&mut app);
let mut ids = Vec::new();
for day in 1..=12 {
@@ -1221,6 +1232,7 @@ async fn shared_overview_seeds_once_and_retains_locally_resumed_history() -> Res
// A fresh TUI/server has no in-memory additions; read-only resumes did not promote history.
let mut restarted = make_test_app().await;
crate::app::test_support::use_modal_agents_overview(&mut restarted);
restarted.app_server_target = app.app_server_target.clone();
let app_server = Box::pin(crate::start_embedded_app_server_for_picker(&config)).await?;
let (event_tx, mut event_rx) = tokio::sync::mpsc::unbounded_channel();
@@ -2316,11 +2328,96 @@ async fn root_switch_preserves_vim_line_yank() -> Result<()> {
Ok(())
}
#[tokio::test]
async fn new_session_selects_its_task_when_the_open_dock_receives_the_row() -> Result<()> {
let mut app = Box::pin(make_test_app()).await;
trust_fixture_folders(&mut app);
app.local_settings.tui.animations = false;
std::fs::write(
&app.local_settings.user_config_path,
"[features]\ntui_workspace = true\n[tui]\nanimations = false\n",
)?;
app.config.features.enable(Feature::TuiWorkspace)?;
let mut tui = crate::tui::test_support::make_test_tui_with_size(Size::new(
/*width*/ 100, /*height*/ 24,
))?;
tui.set_owned_screen(/*owned*/ true)?;
app.local_settings.transcript_mode = tui.transcript_mode();
let mut server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;
let previous = Box::pin(server.start_thread(&app.config)).await?;
let previous_id = previous.session.thread_id;
app.enqueue_primary_thread_session(previous.session, previous.turns)
.await?;
let previous_row = overview_thread(
previous_id,
/*parent_thread_id*/ None,
"Previous task",
ThreadStatus::Idle,
);
app.agents_overview
.threads
.insert(previous_id, Some(previous_row));
app.open_agents_overview(&server);
app.focus_workspace_composer(&mut tui);
assert_eq!(app.overview_selected_thread_id(), Some(previous_id));
tui.pause_events();
Box::pin(app.handle_event(&mut tui, &mut server, AppEvent::NewSession { name: None })).await?;
let new_id = app.current_displayed_thread_id().expect("new conversation");
assert_ne!(new_id, previous_id);
app.repaint_agents_overview();
let thread = server.thread_read(new_id, /*include_turns*/ false).await?;
let started = ServerNotification::ThreadStarted(ThreadStartedNotification { thread });
Box::pin(app.handle_app_server_event(
&server,
AppServerEvent::ServerNotification(Box::new(started)),
))
.await;
assert_eq!(app.overview_selected_thread_id(), Some(new_id));
assert!(!app.workspace_center_owns_input());
app.render_chat_widget_frame(&mut tui, Size::new(/*width*/ 100, /*height*/ 24))?;
let screen = crate::app::owned_transcript::tests::buffer_text(tui.terminal.previous_buffer());
let selected_title = screen
.lines()
.filter_map(|line| line.split_once('│'))
.map(|(dock, _)| dock.trim())
.find(|line| line.starts_with('›'))
.expect("selected task in dock");
insta::assert_snapshot!(selected_title, @"› ○ Untitled task");
app.open_agents_overview(&server);
app.handle_workspace_key(&mut tui, KeyCode::Down.into());
assert_eq!(app.overview_selected_thread_id(), Some(previous_id));
app.focus_workspace_composer(&mut tui);
app.repaint_agents_overview();
assert_eq!(app.overview_selected_thread_id(), Some(previous_id));
app.open_agents_overview(&server);
Box::pin(app.new_agents_overview_session(&mut tui, &mut server, /*cwd*/ None)).await?;
assert_ne!(app.current_displayed_thread_id(), Some(new_id));
assert!(app.agents_overview.workspace.is_open());
assert!(!app.workspace_center_owns_input());
// Read receipts follow the visible conversation, including while the wide dock has focus.
app.open_agents_overview(&server);
let displayed = app.current_displayed_thread_id().expect("new dock task");
for (width, visible) in [(100, Some(displayed)), (50, None)] {
let size = Size::new(width, /*height*/ 24);
tui.terminal.resize(size)?;
Box::pin(app.handle_tui_event(&mut tui, &mut server, TuiEvent::Resize(size))).await?;
assert_eq!(server.focused_conversation, visible);
}
server.shutdown().await?;
Ok(())
}
#[tokio::test]
async fn root_switch_loads_local_preferences_from_disk() -> Result<()> {
// Keep the large setup and root-switch futures off the test thread's stack.
let mut app = Box::pin(make_test_app()).await;
trust_fixture_folders(&mut app);
app.local_settings.tui.animations = false;
let mut app_server = Box::pin(crate::start_embedded_app_server_for_picker(
app.chat_widget.config_ref(),
))
@@ -2341,15 +2438,28 @@ async fn root_switch_loads_local_preferences_from_disk() -> Result<()> {
)?;
std::fs::write(
app.local_settings.user_config_path.as_path(),
"[tui]\ntheme = \"dracula\"\nresume_cwd = \"session\"\n[history]\npersistence = \"none\"\n",
"[features]\ntui_workspace = true\n[tui]\nanimations = false\ntheme = \"dracula\"\nresume_cwd = \"session\"\n[history]\npersistence = \"none\"\n",
)?;
let config = Box::pin(app.rebuild_config_for_cwd(app.config.cwd.to_path_buf())).await?;
let expected = crate::local_settings::LocalSettings::from(&config);
let mut tui = crate::tui::test_support::make_test_tui()?;
Box::pin(app.select_agents_overview_thread(&mut tui, &mut app_server, target_thread_id))
.await?;
let mut tui = crate::tui::test_support::make_test_tui_with_size(Size::new(
/*width*/ 100, /*height*/ 24,
))?;
tui.set_owned_screen(/*owned*/ true)?;
let expected = crate::local_settings::LocalSettings::for_tui(&config, &tui);
app.config.features.enable(Feature::TuiWorkspace)?;
app.local_settings.transcript_mode = tui.transcript_mode();
app.open_agents_overview(&app_server);
Box::pin(app.handle_event(
&mut tui,
&mut app_server,
AppEvent::SelectAgentsOverviewThread {
thread_id: target_thread_id,
},
))
.await?;
assert!(app.agents_overview.workspace.is_open());
assert!(!app.workspace_center_owns_input());
assert_eq!(app.current_displayed_thread_id(), Some(target_thread_id));
assert_eq!(app.local_settings, expected);
assert_eq!(app.chat_widget.local_settings, expected);
@@ -3425,6 +3535,7 @@ async fn command_center_handles_resume_failure_and_success() -> Result<()> {
#[tokio::test]
async fn command_center_attach_conflict_opens_read_only_and_retries() -> Result<()> {
let mut app = Box::pin(make_test_app()).await;
crate::app::test_support::use_modal_agents_overview(&mut app);
trust_fixture_folders(&mut app);
std::fs::write(
app.config.codex_home.join("config.toml"),
@@ -3860,6 +3971,12 @@ async fn overview_fork_keeps_idle_source_input_queued() -> Result<()> {
ready = Some(event);
}
}
if cached_primary {
tui.set_owned_screen(/*owned*/ true)?;
app.local_settings.transcript_mode = tui.transcript_mode();
app.config.features.enable(Feature::TuiWorkspace)?;
app.open_agents_overview(&server);
}
// Failed reattachment can leave the source displayed as a saved replay.
app.app_server_target = AppServerTarget::LocalDaemon {
allow_embedded_fallback: true,
@@ -3878,9 +3995,12 @@ async fn overview_fork_keeps_idle_source_input_queued() -> Result<()> {
assert_eq!(app.current_displayed_thread_id(), Some(source));
assert_eq!(server.next_request_id(), RequestId::Integer(request + 1));
assert!(!app.chat_widget.fork_in_progress);
assert_eq!(app.workspace_center_owns_input(), cached_primary);
app.app_server_target = AppServerTarget::Embedded;
Box::pin(app.handle_event(&mut tui, &mut server, ready.expect("fork continuation")))
.await?;
assert_eq!(app.agents_overview.workspace.is_open(), cached_primary);
assert!(!app.workspace_center_owns_input());
assert_ne!(app.current_displayed_thread_id(), Some(source));
assert_eq!(app.agents_overview.input_states[&source], retained);
assert!(app.chat_widget.queued_user_message_texts().is_empty());
@@ -5,7 +5,6 @@
//! Discovery merges into retained membership without evicting rows.
use super::App;
use super::agents_overview::AGENTS_OVERVIEW_VIEW_ID;
use super::agents_overview_details::preview_agent_message;
use super::agents_overview_discovery::AgentsOverviewDiscovery;
use super::agents_overview_discovery::is_overview_root;
@@ -281,11 +280,7 @@ impl App {
&mut self,
app_server: &AppServerSession,
) {
if self
.chat_widget
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
.is_none()
{
if self.overview_selected_index().is_none() {
return;
}
self.agents_overview.pin_refresh_requested = true;
@@ -317,16 +312,13 @@ impl App {
{
return;
}
let visible = self.overview_selected_index().is_some();
let overview = &mut self.agents_overview;
let initialized = overview.initialized.contains(&backend_id);
let source_has_more = overview
.discovery
.get(&backend_id)
.is_none_or(AgentsOverviewDiscovery::has_more);
let visible = self
.chat_widget
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
.is_some();
if !visible && initialized {
return;
}
@@ -3,7 +3,6 @@
//! pending billing results and disabled capability state.
use super::App;
use super::agents_overview::AGENTS_OVERVIEW_VIEW_ID;
use super::background_requests::THREAD_USAGE_FETCH_TIMEOUT;
use super::background_requests::fetch_thread_usage;
use crate::app_event::AppEvent;
@@ -62,12 +61,7 @@ impl App {
{
return;
}
let Some(thread_id) = self
.chat_widget
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
.and_then(|index| self.agents_overview.visible_thread_ids.get(index))
.copied()
else {
let Some(thread_id) = self.overview_selected_thread_id() else {
return;
};
let owner = app_server.backend_id();
@@ -227,6 +227,8 @@ impl AgentsOverviewViewState {
}
pub(super) struct AgentsOverviewView {
/// Some when shown beside the conversation. The value records keyboard focus.
pub(super) dock_focused: Option<bool>,
use_theme_colors: bool,
pub(super) rows: Vec<AgentsOverviewRow>,
project_groups: Vec<AgentsOverviewProjectGroup>,
@@ -305,6 +307,7 @@ impl AgentsOverviewView {
}
}
let mut view = Self {
dock_focused: None,
editor_keymap: keymap.clone(),
use_theme_colors,
rows,
@@ -330,6 +333,29 @@ impl AgentsOverviewView {
view
}
pub(super) fn owns_nested_input(&self) -> bool {
let state = self.state();
state.editing_metadata() || state.help || state.removal.is_some() || state.creating_worktree
}
/// Follow a newly displayed task once its row arrives. Ordinary refreshes keep the browse position.
pub(super) fn follow_changed_conversation(&mut self, previous: &Self) {
let Some((index, current)) = self.rows.iter().enumerate().find(|(_, row)| row.is_current)
else {
return;
};
if !previous
.rows
.iter()
.any(|row| row.is_current && row.thread_id == current.thread_id)
&& !self.owns_nested_input()
&& self.visible_indices().contains(&index)
{
self.selected = index;
self.state().show_more_selected = false;
}
}
pub(super) fn thread_ids(&self) -> Vec<ThreadId> {
self.rows.iter().map(|row| row.thread_id).collect()
}
@@ -0,0 +1,228 @@
//! The docked Command Center requires the owned transcript renderer.
//! Its view stays in the workspace when focus moves to the conversation.
use super::App;
use super::agents_overview_view::AgentsOverviewView;
use super::sidebar::PaneFocus;
use crate::app_event::AppEvent;
use crate::app_event::ExitMode;
use crate::bottom_pane::BottomPaneView;
use crate::bottom_pane::CancellationEvent;
use crate::key_hint::KeyBindingListExt;
use crate::render::renderable::Renderable;
use crate::tui::Tui;
use crossterm::event::KeyCode;
use crossterm::event::KeyEvent;
use crossterm::event::KeyModifiers;
use crossterm::event::MouseEvent;
use crossterm::event::MouseEventKind;
use ratatui::layout::Constraint;
use ratatui::layout::Layout;
use ratatui::layout::Rect;
use ratatui::style::Style;
const CENTER_WIDTH: u16 = 36;
// One column for the divider and one for padding before the conversation.
const GUTTER_WIDTH: u16 = 2;
const MIN_CHAT_WIDTH: u16 = 48;
const MIN_SPLIT_WIDTH: u16 = CENTER_WIDTH + GUTTER_WIDTH + MIN_CHAT_WIDTH;
#[derive(Clone, Copy, PartialEq, Eq)]
enum Pane {
Center,
Conversation,
}
#[derive(Default)]
pub(super) struct Workspace {
pub(super) view: Option<AgentsOverviewView>,
/// None while the dock is closed.
focus: Option<Pane>,
}
impl Workspace {
pub(super) fn is_open(&self) -> bool {
self.focus.is_some()
}
pub(super) fn focus_center(&mut self) {
self.focus = Some(Pane::Center);
}
pub(super) fn replace_view(&mut self, mut view: AgentsOverviewView) {
if self.focus == Some(Pane::Conversation)
&& let Some(previous) = &self.view
{
view.follow_changed_conversation(previous);
}
self.view = Some(view);
}
pub(super) fn selected_index(&self) -> Option<usize> {
self.view.as_ref()?.selected_index()
}
}
impl App {
pub(super) fn workspace_center_owns_input(&self) -> bool {
self.agents_overview.workspace.focus == Some(Pane::Center)
&& self.overlay.is_none()
&& !self.chat_widget.has_active_view()
}
pub(super) fn workspace_chat_area(&self, viewport: Rect) -> Rect {
if self.agents_overview.workspace.is_open() {
self.workspace_areas(viewport).1.unwrap_or_default()
} else {
viewport
}
}
pub(super) fn workspace_areas(&self, viewport: Rect) -> (Option<Rect>, Option<Rect>) {
if viewport.width >= MIN_SPLIT_WIDTH {
let [center, _, conversation] = Layout::horizontal([
Constraint::Length(CENTER_WIDTH),
Constraint::Length(GUTTER_WIDTH),
Constraint::Min(MIN_CHAT_WIDTH),
])
.areas(viewport);
(Some(center), Some(conversation))
} else if self.workspace_center_owns_input() {
(Some(viewport), None)
} else {
(None, Some(viewport))
}
}
pub(super) fn focus_workspace_composer(&mut self, tui: &mut Tui) {
if self.agents_overview.workspace.is_open() {
self.agents_overview.workspace.focus = Some(Pane::Conversation);
}
if self.panel_focus() == Some(PaneFocus::Sidebar) {
let pane = self.sidebar_mut();
if let Some(content) = pane.visible_content() {
pane.show(content, PaneFocus::Main);
}
}
self.cancel_transcript_browsing(tui);
self.transcript_view.end_select_mode();
self.transcript_view.end_selection(&self.transcript_cells);
self.transcript_view.cancel_search();
self.transcript_view.clear_activity_focus();
self.cancel_pending_key_chord();
}
pub(super) fn handle_workspace_key(&mut self, tui: &mut Tui, mut key: KeyEvent) {
if self.should_recover_vim_insert_escape(tui, key)
&& let Some(view) = &mut self.agents_overview.workspace.view
{
view.handle_key_event(KeyCode::Esc.into());
key.modifiers.remove(KeyModifiers::ALT);
}
let Some(key) = self.route_key_chord_event(tui, key) else {
return;
};
if self.handle_voice_toggle_key(tui, key) {
return;
}
let Some(view) = &mut self.agents_overview.workspace.view else {
return;
};
if !view.owns_nested_input() && self.keymap.app.select_transcript.is_pressed(key) {
self.focus_workspace_composer(tui);
self.transcript_view
.begin_select_mode(&self.transcript_cells);
} else {
if crate::key_hint::ctrl(KeyCode::Char('c')).is_press(key) {
if view.on_ctrl_c() == CancellationEvent::NotHandled {
self.app_event_tx
.send(AppEvent::Exit(ExitMode::ShutdownFirst));
}
} else {
view.handle_key_event(key);
}
if view.is_complete() {
self.agents_overview.workspace.focus = None;
self.focus_workspace_composer(tui);
self.conversation_frame = Default::default();
}
}
tui.frame_requester().schedule_frame();
}
pub(super) fn handle_workspace_mouse(&mut self, tui: &mut Tui, mouse: MouseEvent) -> bool {
if !self.agents_overview.workspace.is_open()
|| self.overlay.is_some()
|| self.chat_widget.has_active_view()
{
return false;
}
let viewport: Rect = tui.terminal.last_known_screen_size.into();
let (center, conversation) = self.workspace_areas(viewport);
let center_was_focused = self.agents_overview.workspace.focus == Some(Pane::Center);
// The press chose the owner. Let its selection finish even outside its pane.
if matches!(mouse.kind, MouseEventKind::Drag(_) | MouseEventKind::Up(_)) {
return center_was_focused;
}
let point = (mouse.column, mouse.row).into();
let pressed = matches!(mouse.kind, MouseEventKind::Down(_));
if center.is_some_and(|rect| rect.contains(point)) {
if pressed {
self.agents_overview.workspace.focus_center();
self.cancel_pending_key_chord();
tui.frame_requester().schedule_frame();
}
return true;
}
if conversation.is_some_and(|rect| rect.contains(point)) {
if center_was_focused && pressed {
if !self
.agents_overview
.workspace
.view
.as_ref()
.is_some_and(|view| view.can_return_to_chat)
{
return true;
}
self.focus_workspace_composer(tui);
}
return false;
}
true
}
pub(super) fn paint_command_center(
&mut self,
frame: &mut crate::custom_terminal::Frame<'_>,
center: Rect,
conversation: Option<Rect>,
) {
let center_focused = self.workspace_center_owns_input();
frame
.image_placements
.retain(|image| !center.intersects(image.area));
if center_focused {
frame.cursor_position = None;
}
let area = center;
if let Some(view) = &mut self.agents_overview.workspace.view {
view.dock_focused = conversation.map(|_| center_focused);
view.render(area, frame.buffer);
if center_focused {
frame.cursor_position = view.cursor_pos(area).map(Into::into);
frame.set_cursor_style(view.cursor_style(area));
}
}
if conversation.is_some() {
for y in center.y..center.bottom() {
frame.buffer[(center.right(), y)]
.set_symbol("│")
.set_style(Style::default().dim());
}
}
}
}
+12 -2
View File
@@ -856,6 +856,10 @@ impl App {
}
// Keep local input without replacing the fork's running state.
self.chat_widget.restore_reconnected_input(retained_input, &[]);
if from_agents_overview && self.agents_overview.workspace.is_open() {
self.focus_workspace_composer(tui);
self.repaint_agents_overview();
}
if let Some(err) = name_error {
self.chat_widget.add_error_message(err);
}
@@ -1341,7 +1345,7 @@ impl App {
&& (self.agents_overview.threads.iter().any(|(id, thread)| {
(mode == ExitMode::Immediate
|| Some(*id) != self.current_displayed_thread_id()
|| self.chat_widget.active_view_is(AGENTS_OVERVIEW_VIEW_ID))
|| self.agents_overview_has_focus())
&& matches!(thread.as_ref().map(|t| &t.status), Some(ThreadStatus::Active { .. }))
}) || self.running_side_thread_id().await.is_some()) =>
{
@@ -3471,9 +3475,15 @@ impl App {
{
AppRunControl::Continue
if self.primary_thread_id.is_none()
&& self.chat_widget.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID).is_none() => {
&& self.overview_selected_index().is_none() => {
self.open_agents_overview(app_server);
}
AppRunControl::Continue
if self.agents_overview.workspace.is_open()
&& self.current_displayed_thread_id() == Some(thread_id) => {
self.focus_workspace_composer(tui);
self.repaint_agents_overview();
}
AppRunControl::Continue => {}
AppRunControl::Exit(reason) => return Ok(AppRunControl::Exit(reason)),
}
+37 -8
View File
@@ -22,12 +22,9 @@ impl App {
if self.focused_sidebar_chooser(tui) {
return false;
}
let rename_active = self
.chat_widget
.selected_index_for_active_view(AGENTS_OVERVIEW_VIEW_ID)
.is_some();
let overview_owns_input = self.agents_overview_has_focus();
let escape = KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE);
let insert_escape = if rename_active {
let insert_escape = if overview_owns_input {
let state = self
.agents_overview
.view_state
@@ -50,11 +47,11 @@ impl App {
&& (key_event.modifiers == KeyModifiers::ALT
|| key_event.modifiers == (KeyModifiers::ALT | KeyModifiers::SHIFT))
// ChatWidget's fixed image-paste shortcut is not in the configurable keymap.
&& !(!rename_active
&& !(!overview_owns_input
&& key_event.kind == KeyEventKind::Press
&& matches!(key_event.code, KeyCode::Char('v' | 'V')))
// Empty-draft agent navigation also has fixed legacy-terminal fallbacks.
&& !(!rename_active
&& !(!overview_owns_input
&& self.chat_widget.composer_text_with_pending().is_empty()
&& (previous_agent_shortcut_matches(key_event, /*allow_word_motion_fallback*/ true)
|| next_agent_shortcut_matches(key_event, /*allow_word_motion_fallback*/ true)))
@@ -97,7 +94,10 @@ impl App {
if let Some(overlay) = &mut self.overlay {
overlay.set_keymap_bindings(&self.keymap);
}
if self.overlay.is_none() && self.chat_widget.handle_quick_dial_menu(key_event) {
if self.overlay.is_none()
&& !self.workspace_center_owns_input()
&& self.chat_widget.handle_quick_dial_menu(key_event)
{
return None;
}
let contexts = self.key_chord_contexts(tui);
@@ -127,6 +127,7 @@ impl App {
},
)))
&& !select_mode_chord
&& !self.workspace_center_owns_input()
{
let close = tui.is_owned_screen()
&& self.overlay.is_none()
@@ -285,6 +286,12 @@ impl App {
}
pub(super) fn active_keymap_contexts(&self) -> crate::keymap::KeymapContextSet {
if self.workspace_center_owns_input()
&& let Some(view) = &self.agents_overview.workspace.view
{
use crate::bottom_pane::BottomPaneView;
return view.keymap_contexts().with_voice_toggle(&self.keymap);
}
use crate::keymap::KeymapContext;
use crate::keymap::KeymapContextSet;
@@ -350,6 +357,28 @@ impl App {
contexts.with_voice_toggle(&self.keymap)
}
pub(super) fn voice_toggle_pressed(&self, key: KeyEvent) -> bool {
key.kind == KeyEventKind::Press
&& self
.active_keymap_contexts()
.contains_action(crate::keymap::KeymapActionId {
context: crate::keymap::KeymapContext::Chat,
action: "toggle_voice",
})
&& self.keymap.chat.toggle_voice.is_pressed(key)
}
pub(super) fn handle_voice_toggle_key(&mut self, tui: &mut tui::Tui, key: KeyEvent) -> bool {
if !self.voice_toggle_pressed(key) {
return false;
}
self.cancel_transcript_browsing(tui);
if !self.chat_widget.handle_startup_submission_key(key) {
self.control_voice(crate::app_event::VoiceControl::Toggle);
}
true
}
pub(super) async fn launch_external_editor(&mut self, tui: &mut tui::Tui) {
self.chat_widget
.empty_state_animation
+36 -14
View File
@@ -39,6 +39,7 @@ use ratatui::widgets::Widget;
#[derive(Default)]
pub(super) struct ConversationFrame {
inset: Option<Rect>,
pub(super) command_center: Option<Rect>,
pub(super) sidebar: Option<sidebar::SidebarLayout>,
pub(super) chat_strip: Option<Rect>,
pub(super) sidebar_input: Option<sidebar::SidebarInputState>,
@@ -51,7 +52,10 @@ pub(super) struct ConversationFrame {
impl ConversationFrame {
pub(super) fn has_caller_inset(&self) -> bool {
self.inset.is_some() && self.sidebar.is_none() && self.chat_strip.is_none()
self.inset.is_some()
&& self.command_center.is_none()
&& self.sidebar.is_none()
&& self.chat_strip.is_none()
}
pub(super) fn side_pane(&self) -> Option<&side_pane::SidePaneLayout> {
@@ -251,7 +255,9 @@ impl App {
) -> Result<Rect> {
self.transcript_view.image_protocol = self.prepare_frame_images(tui);
let frames = tui.frame_requester();
if self.conversation_frame.sidebar.is_some() || self.conversation_frame.chat_strip.is_some()
if self.conversation_frame.command_center.is_some()
|| self.conversation_frame.sidebar.is_some()
|| self.conversation_frame.chat_strip.is_some()
{
// Recompute our own inset on every frame, including the first narrow frame.
self.conversation_frame = ConversationFrame::default();
@@ -268,7 +274,16 @@ impl App {
{
pane.sync_agent_rows(&self.agent_navigation);
}
let layout = sidebar::paint_layout(self, tui, screen_size.into());
let viewport: Rect = screen_size.into();
let (center, available) =
if caller_inset.is_none() && self.agents_overview.workspace.is_open() {
self.workspace_areas(viewport)
} else {
(None, Some(viewport))
};
self.conversation_frame.command_center = center;
let content = available.unwrap_or_default();
let layout = available.and_then(|area| sidebar::paint_layout(self, tui, area));
let displayed = self.current_displayed_thread_id();
let chat = match displayed.and_then(|id| self.side_pair_key(id)) {
Some(child) if Some(child) == displayed => TabState::Active,
@@ -286,13 +301,16 @@ impl App {
&& caller_inset.is_none()
&& self.side_retention_enabled(tui) =>
{
let [strip, body] = side_pane::tab_and_body(screen_size.into());
let [strip, body] = side_pane::tab_and_body(content);
(Some(body), Some(strip))
}
None => (None, None),
};
let mut prepared =
self.prepare_conversation(screen_size.into(), caller_inset.or(live), &frames);
let mut prepared = self.prepare_conversation(
viewport,
caller_inset.or(live).or(center.map(|_| content)),
&frames,
);
self.conversation_frame.sidebar = layout;
self.conversation_frame.chat_strip = strip;
self.conversation_frame.sidebar_input =
@@ -300,7 +318,7 @@ impl App {
let divider = self.conversation_frame.divider_area();
if self.divider_drag.is_some_and(|drag| {
divider.is_none()
|| !drag.matches(screen_size.into(), self)
|| !drag.matches(content, self)
|| !self.conversation_focus_available(tui)
}) {
self.divider_drag = None;
@@ -631,6 +649,9 @@ impl App {
if let Some(area) = self.hover_target_area(hover_mouse, frame.buffer) {
super::link_hover::paint_hover_foreground(area, frame.buffer);
}
if let Some(center) = center {
self.paint_command_center(frame, center, available);
}
self.paint_centered_dialog(frame);
})?;
// A shortcut HUD is painted after the conversation and can move over a stationary pointer.
@@ -744,6 +765,14 @@ impl App {
} else {
self.prompt_navigation_footer(area.width.saturating_sub(/*rhs*/ 2))
};
let unfocused = self.workspace_center_owns_input()
|| matches!(
self.conversation_frame.sidebar,
Some(sidebar::SidebarLayout::Panel {
focus: PaneFocus::Sidebar,
..
})
);
let chat_widget = &self.chat_widget;
let view = &mut self.transcript_view;
let active_key = chat_widget.active_cell_transcript_key();
@@ -753,13 +782,6 @@ impl App {
// which can change the footer hint and the composer's measured height.
let footer = view.footer_with_navigation(footer_width, motion, latest_navigation);
let max_composer_height = side_pane::composer_height_limit(area.height);
let unfocused = matches!(
self.conversation_frame.sidebar,
Some(sidebar::SidebarLayout::Panel {
focus: PaneFocus::Sidebar,
..
})
);
let options = |interacting| ComposerRenderOptions {
unfocused,
max_height: Some(max_composer_height),
+21 -3
View File
@@ -86,6 +86,7 @@ async fn external_writer_escape_returns_to_command_center_without_editing() -> R
(false, false, true),
] {
let mut app = crate::app::test_support::make_test_app().await;
crate::app::test_support::use_modal_agents_overview(&mut app);
attach_thread(&mut app, ThreadId::new());
app.transcript_cells = vec![user_cell("First prompt"), user_cell("Second prompt")];
app.app_server_target = AppServerTarget::Remote {
@@ -670,11 +671,16 @@ async fn owned_details_keep_the_composer_cursor_and_screen() -> Result<()> {
let frames = tui.frame_requester();
let mut painted = Default::default();
tui.draw(outer.height, |frame| {
for cell in &mut frame.buffer.content {
cell.set_char('·');
// Paint the side margins before the conversation and the rows below it afterward.
let viewport = frame.area();
for pos in viewport.positions().filter(|pos| pos.y < area.bottom()) {
frame.buffer[pos].set_char('·');
}
let prepared = app.prepare_conversation(frame.area(), Some(area), &frames);
let prepared = app.prepare_conversation(viewport, Some(area), &frames);
painted = app.paint_conversation(frame, &prepared);
for pos in viewport.positions().filter(|pos| pos.y >= area.bottom()) {
frame.buffer[pos].set_char('·');
}
frame
.image_placements
.push(crate::transcript_image::ImagePlacement {
@@ -804,6 +810,18 @@ async fn owned_details_keep_the_composer_cursor_and_screen() -> Result<()> {
),
(false, true, "preserved draft".to_string()),
);
// A replacement conversation starts at full width and drops the previous pane's image.
let init = app.chatwidget_init_for_forked_or_resumed_thread(
&mut tui,
app.config.clone(),
/*initial_user_message*/ None,
);
app.replace_chat_widget(ChatWidget::new_with_app_event(init));
assert_eq!(
app.render_owned_transcript(&mut tui, outer)?.width,
outer.width
);
assert!(presented(&tui).is_empty());
tui.set_owned_screen(/*owned*/ false)?;
Ok(())
}
+14 -13
View File
@@ -319,14 +319,8 @@ impl App {
.selected_index_for_active_view(agents_overview::AGENTS_OVERVIEW_VIEW_ID)
.is_some()
|| (self.current_displayed_thread_id().is_none()
&& self
.chat_widget
.selected_index_for_present_view(agents_overview::AGENTS_OVERVIEW_VIEW_ID)
.is_some())
&& self.overview_selected_index().is_some())
{
if let Ok(mut state) = self.agents_overview.view_state.lock() {
state.connection_notice = Some("Reconnecting — agent list is stale");
}
ReconnectPresentation::Overview
} else {
if !self
@@ -340,6 +334,12 @@ impl App {
}
ReconnectPresentation::Conversation
};
if (self.agents_overview.workspace.is_open()
|| self.reconnect.presentation == ReconnectPresentation::Overview)
&& let Ok(mut state) = self.agents_overview.view_state.lock()
{
state.connection_notice = Some("Reconnecting — agent list is stale");
}
if preserve_startup_input {
// Draining admission never reopens. Wait for this connection to close before
// reconnecting, then give the ordinary startup path one more attempt.
@@ -409,10 +409,7 @@ impl App {
archived_thread,
} = connected;
session.model_provider_override = self.harness_overrides.model_provider.clone();
let selected = self
.chat_widget
.selected_index_for_present_view(agents_overview::AGENTS_OVERVIEW_VIEW_ID)
.and_then(|index| self.agents_overview.visible_thread_ids.get(index).copied());
let selected = self.overview_selected_thread_id();
let displayed = self.reconnect_thread_id();
let mut input = self.chat_widget.capture_thread_input_state();
if let Some(input) = input.as_mut() {
@@ -644,7 +641,9 @@ impl App {
// A hidden overview performs this discovery when it is next opened.
self.reset_agents_overview_discovery(app_server.backend_id());
self.backend_registry.connect(app_server);
if self.reconnect.presentation == ReconnectPresentation::Overview {
if self.agents_overview.workspace.is_open() {
self.repaint_agents_overview();
} else if self.reconnect.presentation == ReconnectPresentation::Overview {
let threads = self
.agents_overview
.threads
@@ -675,7 +674,9 @@ impl App {
self.app_event_tx
.send(AppEvent::RefreshConfigReasoningSummary);
}
if self.reconnect.presentation == ReconnectPresentation::Overview {
if self.agents_overview.workspace.is_open()
|| self.reconnect.presentation == ReconnectPresentation::Overview
{
self.refresh_agents_overview_threads(app_server);
}
self.chat_widget.forget_inherited_quota_provider();
+1 -5
View File
@@ -282,11 +282,7 @@ impl App {
if options.cancel == Some(crate::onboarding::TrustCancelAction::CurrentTask) {
return Err(AppRunControl::Continue);
}
if self
.chat_widget
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
.is_none()
{
if self.overview_selected_index().is_none() {
self.open_agents_overview(app_server);
}
return Err(AppRunControl::Continue);
+12
View File
@@ -610,6 +610,7 @@ impl App {
mut chat_widget: ChatWidget,
thread_provider: Option<&str>,
) {
self.conversation_frame = Default::default();
self.statusline_picker = None;
chat_widget.inherit_view_transition_key_guard(&mut self.chat_widget);
chat_widget.fork_in_progress = self.chat_widget.fork_in_progress;
@@ -1026,6 +1027,7 @@ impl App {
.unwrap_or_default();
self.apply_session_account(&mut init, account);
}
let presented = preserve_screen.then(|| std::mem::take(&mut self.conversation_frame));
self.replace_chat_widget_for_provider(
ChatWidget::new_with_app_event(init),
snapshot
@@ -1033,6 +1035,9 @@ impl App {
.as_ref()
.map(|session| session.model_provider_id.as_str()),
);
if let Some(frame) = presented {
self.conversation_frame = frame;
}
self.chat_widget
.set_task_mentions_enabled(app_server.task_tools_available(thread_id));
self.chat_widget
@@ -1962,6 +1967,9 @@ impl App {
self.agents_overview
.hidden_threads
.remove(&target_session.thread_id);
if self.agents_overview.workspace.is_open() {
self.focus_workspace_composer(tui);
}
self.repaint_agents_overview();
tui.frame_requester().schedule_frame();
return Ok(AppRunControl::Continue);
@@ -2191,6 +2199,10 @@ impl App {
self.chat_widget
.add_info_message(notice.to_string(), /*hint*/ None);
}
if self.agents_overview.workspace.is_open() {
self.focus_workspace_composer(tui);
self.repaint_agents_overview();
}
self.backfill_loaded_subagent_threads(app_server).await;
if matches!(
self.runtime_approval_policy_override,
+4 -10
View File
@@ -109,11 +109,9 @@ impl App {
{
return Ok(AppRunControl::Exit(reason));
}
if self.active_thread_id == Some(thread_id)
&& self
.chat_widget
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
.is_some()
if !self.agents_overview.workspace.is_open()
&& self.active_thread_id == Some(thread_id)
&& self.overview_selected_index().is_some()
{
if let Ok(mut state) = self.agents_overview.view_state.lock() {
state.completion = Some(crate::bottom_pane::ViewCompletion::Accepted);
@@ -137,11 +135,7 @@ impl App {
}
pub(super) fn add_session_picker_error(&mut self, message: String) {
if self
.chat_widget
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
.is_some()
{
if self.overview_selected_index().is_some() {
self.chat_widget.show_selection_view(SelectionViewParams {
title: Some("Unable to resume session".to_string()),
subtitle: Some(message.clone()),
+11 -4
View File
@@ -108,6 +108,7 @@ fn visible_split(app: &App, tui: &Tui, area: Rect) -> Option<SidebarLayout> {
}
pub(super) fn split_layout(app: &App, tui: &Tui, area: Rect) -> Option<SidebarLayout> {
let area = app.workspace_chat_area(area);
let content = app.sidebar()?.visible_content()?;
if area.width < 100
|| app.conversation_frame.has_caller_inset()
@@ -250,6 +251,7 @@ impl App {
if key.kind == KeyEventKind::Release {
return true;
}
let screen = self.workspace_chat_area(screen);
let current = screen.right() - divider.right();
let step = match (key.code, key.modifiers) {
(KeyCode::Left | KeyCode::Char('h'), KeyModifiers::NONE) => 1,
@@ -301,6 +303,7 @@ impl App {
100 - focused_percent
};
// The sidebar gets the spare column when an equal split is odd.
let screen = self.workspace_chat_area(screen);
let available = u32::from(screen.width - GAP);
let preferred = (available * u32::from(side_percent)).div_ceil(100);
let width = sidebar_width(preferred as i32, screen.width);
@@ -335,7 +338,7 @@ impl App {
visible_split(self, tui, screen).and_then(|layout| layout.divider_area())
{
let current = screen.right() - divider.right();
let total = screen.width;
let total = self.workspace_chat_area(screen).width;
let step = (i32::from(total) * percent.abs() + 50) / 100;
let next = sidebar_width(i32::from(current) + step * percent.signum(), total);
if next != current {
@@ -402,6 +405,7 @@ impl App {
let Some(target) = self.sidebar_resize_target() else {
return Ok(false);
};
let screen = self.workspace_chat_area(screen);
let width = screen.right() - divider.right();
self.divider_drag = Some(DividerDrag {
target,
@@ -420,10 +424,13 @@ impl App {
return Ok(false);
};
let screen = tui.terminal.last_known_screen_size.into();
if drag.matches(screen, self) && visible_split(self, tui, screen).is_some() {
if drag.matches(self.workspace_chat_area(screen), self)
&& visible_split(self, tui, screen).is_some()
{
let width = i32::from(drag.initial_width) + i32::from(drag.press)
- i32::from(mouse.column);
let width = sidebar_width(width, screen.width);
let total = drag.screen.width;
let width = sidebar_width(width, total);
let changed = drag.width != width;
drag.width = width;
if mouse.kind == Drag(Left) {
@@ -434,7 +441,7 @@ impl App {
} else if let Some(percent) = drag.percent()
&& self.save_sidebar_width(percent).await
{
self.exact_sidebar_width = Some((screen.width, width));
self.exact_sidebar_width = Some((total, width));
}
}
}
@@ -0,0 +1,35 @@
---
source: tui/src/app/agent_center_tests.rs
expression: "screens.join(\"\\n\\n\")"
---
Wide Command Center
Agent command center Group: Pr… │ Response row 22
All 1 Needs you 0 › │ Response row 23
──────────────────────────────── │ Response row 24
Tasks │ Response row 25
Pinned 1 │ Response row 26
› ○ Investigate retry │ Response row 27
│ Response row 28
│ Response row 29
│ ↓ Back to bottom · esc
│
│ › Keep this draft
│
│ gpt-test default · /tmp/project
? help esc back ↑/↓ move ent… │
Narrow Command Center
Agent command center Group: Project g
All 1 Needs you 0 Working 0 Ready 1 ›
──────────────────────────────────────────────
Tasks
Pinned 1
› ○ Investigate retry again
? help esc back ↑/↓ move enter open n new
+10
View File
@@ -15,6 +15,16 @@ use codex_models_manager::test_support::get_model_offline_for_tests;
pub(crate) use super::cloud_switch_wait::ClipboardHandoff;
pub(crate) use super::cloud_switch_wait::wait_for_cloud_switch;
/// Opt in to testing the original Command Center modal through the chat widget.
pub(super) fn use_modal_agents_overview(app: &mut App) {
app.config
.features
.disable(Feature::TuiWorkspace)
.expect("disable TUI workspace for the modal fixture");
app.cli_kv_overrides
.push(("features.tui_workspace".to_owned(), false.into()));
}
pub(super) fn enable_side_retention(app: &mut App) -> Result<()> {
app.config.features.enable(Feature::TuiWorkspace)?;
app.local_settings.transcript_mode = crate::transcript_mode::TranscriptMode::Owned;
@@ -41,7 +41,7 @@ async fn agents_navigation_opens_the_command_center_on_every_target() -> Result<
let event = events.try_recv()?;
assert_matches!(event, AppEvent::OpenAgentsOverview);
app.handle_event(&mut tui, &mut app_server, event).await?;
assert!(app.chat_widget.active_view_is(AGENTS_OVERVIEW_VIEW_ID));
assert!(app.agents_overview_has_focus());
app_server.shutdown().await?;
}
Ok(())
@@ -50,6 +50,7 @@ async fn agents_navigation_opens_the_command_center_on_every_target() -> Result<
#[tokio::test]
async fn externally_archived_thread_keeps_advertised_agents_navigation() -> Result<()> {
let (mut app, mut events, _ops) = make_test_app_with_channels().await;
crate::app::test_support::use_modal_agents_overview(&mut app);
let mut tui = crate::tui::test_support::make_test_tui()?;
let mut app_server = start_config_write_test_app_server(&app).await?;
app.app_server_target = AppServerTarget::LocalDaemon {
@@ -167,7 +168,7 @@ async fn provider_error_opens_command_center_with_left() -> Result<()> {
TuiEvent::Key(KeyCode::Left.into()),
)
.await?;
assert!(app.chat_widget.active_view_is(AGENTS_OVERVIEW_VIEW_ID));
assert!(app.agents_overview_has_focus());
assert_eq!(
app.chat_widget.composer_text_with_pending(),
"Retained draft"
@@ -165,11 +165,7 @@ async fn external_writer_view_opens_agents_with_left() -> Result<()> {
)
.await?;
assert!(
app.chat_widget
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
.is_some()
);
assert!(app.agents_overview_has_focus());
assert_eq!(
app.chat_widget.composer_text_with_pending(),
"Retained draft"
@@ -28,6 +28,7 @@ async fn reconnect_daemon_command_center_after_socket_replacement_without_a_conv
(Some(ThreadId::new()), true, true),
] {
let (mut app, mut events, _) = make_test_app_with_channels().await;
crate::app::test_support::use_modal_agents_overview(&mut app);
app.keymap.app.open_agents = vec![crate::key_hint::alt(KeyCode::Char('a'))];
let child = ThreadId::new();
let child_recap = recap::RecapProgress {
@@ -1283,11 +1283,16 @@ async fn resumed_backend_handoff_detaches_through_the_source_connection() -> Res
cwd: Some(resumed.session.cwd.to_path_buf()),
history_mode: None,
};
let mut tui = crate::tui::test_support::make_test_tui()?;
tui.set_owned_screen(/*owned*/ true)?;
app.local_settings.transcript_mode = tui.transcript_mode();
app.config.features.enable(Feature::TuiWorkspace)?;
app.open_agents_overview(&source);
assert!(app.workspace_center_owns_input());
let mut backends = BackendSessions::from_initial(source, vec![destination]);
backends
.settings
.insert(destination_id, app.backend_settings());
let mut tui = crate::tui::test_support::make_test_tui()?;
let mut stale_input = app.chat_widget.capture_thread_input_state().unwrap();
stale_input.provider_error = Some(
codex_app_server_protocol::ModelProviderError::ModelProviderNotConfigured {
@@ -1304,6 +1309,8 @@ async fn resumed_backend_handoff_detaches_through_the_source_connection() -> Res
app.resume_backend_session(&mut tui, &mut backends, target)
.await?;
assert!(app.agents_overview.workspace.is_open());
assert!(!app.workspace_center_owns_input());
assert_eq!(backends.displayed_owner(), destination_id);
assert_eq!(app.chat_widget.thread_id(), Some(resumed_id));
assert!(!app.chat_widget.has_provider_error());
@@ -2360,7 +2360,7 @@ async fn delete_current_thread_navigates_only_after_success() -> Result<()> {
app.chat_widget.composer_text_with_pending(),
"Retained on failure"
);
assert!(!app.chat_widget.has_active_view());
assert!(!app.agents_overview_has_focus());
let resumed = server
.resume_thread(
@@ -2413,7 +2413,7 @@ async fn delete_current_thread_navigates_only_after_success() -> Result<()> {
);
assert_eq!(app.active_thread_id, Some(thread_id));
assert!(app.side_threads.contains_key(&side_id));
assert!(!app.chat_widget.has_active_view());
assert!(!app.agents_overview_has_focus());
assert_eq!(recorded_params(&requests, "thread/delete").len(), 1);
let (tx, mut events) = tokio::sync::mpsc::unbounded_channel();
app.app_event_tx = AppEventSender::new(tx);
@@ -2454,7 +2454,7 @@ async fn delete_current_thread_navigates_only_after_success() -> Result<()> {
(None, None, None)
);
assert!(app.chat_widget.composer_is_empty());
assert!(app.chat_widget.has_active_view());
assert!(app.agents_overview_has_focus());
assert_eq!(
recorded_params(&requests, "thread/delete"),
vec![
@@ -2626,7 +2626,7 @@ async fn embedded_archive_completes_after_opening_command_center() -> Result<()>
let (_tx, mut events) = tokio::sync::mpsc::unbounded_channel();
app.active_thread_id = Some(thread_id);
Box::pin(app.archive_current_thread(&mut tui, &mut server)).await?;
assert!(app.chat_widget.active_view_is(AGENTS_OVERVIEW_VIEW_ID));
assert!(app.agents_overview_has_focus());
assert_matches!(
app.saved_openings.next_event(&mut events).await,
Some(AppEvent::ArchiveFinished { thread_id: id, result: Ok(()), .. }) if id == thread_id
@@ -2694,7 +2694,7 @@ async fn archive_opens_command_center_before_the_server_replies() -> Result<()>
.expect("the confirmation must not wait for the archive RPC")?,
AppRunControl::Continue
);
assert!(app.chat_widget.active_view_is(AGENTS_OVERVIEW_VIEW_ID));
assert!(app.agents_overview_has_focus());
assert_eq!(app.current_displayed_thread_id(), None);
assert_eq!(app.agents_overview.visible_thread_ids, [other_id]);
assert_eq!(
@@ -2990,13 +2990,7 @@ async fn archive_current_thread_returns_to_agents() -> Result<()> {
recorded_params(&requests, "thread/archive"),
vec![serde_json::json!({"threadId": thread_id.to_string()})]
);
assert!(
app.chat_widget
.selected_index_for_present_view(
crate::app::agents_overview::AGENTS_OVERVIEW_VIEW_ID
)
.is_some()
);
assert!(app.agents_overview_has_focus());
server.shutdown().await?;
proxy.await??;
}
@@ -6844,6 +6838,7 @@ async fn external_writer_escape_preserves_snapshot_and_explicit_quits() -> Resul
AppServerTarget::Remote { endpoint },
] {
let (mut app, _codex_home) = make_history_test_app().await?;
crate::app::test_support::use_modal_agents_overview(&mut app);
let thread_id =
create_history_rollout(&app.config, ThreadHistoryMode::Legacy, "owned elsewhere")?;
let (mut server, requests, proxy) = start_recording_app_server(