Lightweight coding agent that runs in your terminal
Rust
use super::*;
use crate::app_event::TranscriptExportDestination;
use crate::bottom_pane::BottomPaneView;
use crate::test_support::boxed_future;
use app_test_support::create_fake_paginated_rollout;
use app_test_support::create_fake_parented_rollout_with_source;
use app_test_support::create_fake_rollout;
use app_test_support::rollout_path;
use codex_app_server_client::AppServerEvent;
use codex_app_server_protocol::ClientNotification;
use codex_app_server_protocol::ClientRequest;
use codex_app_server_protocol::JSONRPCError;
use codex_app_server_protocol::JSONRPCErrorError;
use codex_app_server_protocol::JSONRPCMessage;
use codex_app_server_protocol::JSONRPCRequest;
use codex_app_server_protocol::JSONRPCResponse;
use codex_app_server_protocol::SortDirection;
use codex_app_server_protocol::ThreadHistoryMode;
use codex_app_server_protocol::ThreadItemsListCursor;
use codex_app_server_protocol::ThreadItemsListParams;
use codex_app_server_protocol::ThreadItemsListResponse;
use codex_app_server_protocol::ThreadStatus;
use codex_protocol::AgentPath;
use codex_protocol::items::AgentMessageContent;
use codex_protocol::items::AgentMessageItem;
use codex_protocol::items::EnteredReviewModeItem;
use codex_protocol::items::ExitedReviewModeItem;
use codex_protocol::items::TurnItem;
use codex_protocol::items::UserMessageItem;
use codex_protocol::protocol::ItemCompletedEvent;
use codex_protocol::protocol::ReviewTarget;
use codex_protocol::user_input::UserInput as CoreUserInput;
use codex_state::SqliteConfig;
use futures::SinkExt;
use futures::StreamExt;
use pretty_assertions::assert_eq;
use std::sync::Mutex;
use tokio::net::TcpListener;
use tokio::sync::oneshot;
use tokio::task::JoinHandle;
use tokio_tungstenite::accept_async;
use tokio_tungstenite::tungstenite::Error as WebSocketError;
use tokio_tungstenite::tungstenite::Message;
use tokio_tungstenite::tungstenite::error::ProtocolError;
pub(super) type RecordedRequests = Arc<Mutex<Vec<JSONRPCRequest>>>;
pub(super) type RecordingAppServer = (AppServerSession, RecordedRequests, JoinHandle<Result<()>>);
fn is_recording_client_disconnect(error: &WebSocketError) -> bool {
match error {
WebSocketError::Protocol(ProtocolError::ResetWithoutClosingHandshake) => true,
WebSocketError::Io(error) => matches!(
error.kind(),
std::io::ErrorKind::BrokenPipe
| std::io::ErrorKind::ConnectionReset
| std::io::ErrorKind::ConnectionAborted
),
_ => false,
}
}
#[tokio::test]
async fn daybreak_command_persists_and_confirms_each_selection() -> Result<()> {
use codex_protocol::openai_models::ModelAccessPrograms;
use codex_protocol::turn_input::CyberAccessProgram;
let (mut app, mut events, mut ops) = make_test_app_with_channels().await;
let (mut server, requests, proxy) = start_recording_app_server(
&app.config,
/*blocked_thread_list*/ None,
/*failed_thread_name*/ None,
)
.await?;
let mut enabled_config = app.config.clone();
enabled_config.daybreak_enabled = true;
let startup = crate::app_server_session::start_thread_with_request_handle(
server.request_handle(),
&app.local_settings,
enabled_config.clone(),
crate::app_server_session::ThreadParamsMode::Embedded,
/*remote_cwd_override*/ None,
server.thread_tool_transport(),
crate::app_server_session::StartupLaunchChoices::default(),
)
.await?;
assert!(startup.session.daybreak_enabled);
enabled_config.ephemeral = true;
let ephemeral = server.start_thread(&enabled_config).await?;
assert!(ephemeral.session.daybreak_enabled);
let starts = recorded_params(&requests, "thread/start");
assert_eq!(starts[0]["daybreakEnabled"], true);
assert!(starts[1]["daybreakEnabled"].is_null());
let started = server.start_thread(&app.config).await?;
let thread_id = started.session.thread_id;
app.active_thread_id = Some(thread_id);
app.chat_widget.handle_thread_session_quiet(started.session);
app.chat_widget.update_account_state(
/*status_account_display*/ None, /*plan_type*/ None,
/*has_chatgpt_account*/ true, /*has_codex_backend_auth*/ true,
);
app.chat_widget.open_model_popup();
let request_id = std::iter::from_fn(|| events.try_recv().ok())
.find_map(|event| match event {
AppEvent::FetchModels { request_id } => Some(request_id),
_ => None,
})
.expect("model catalog request");
let mut model = crate::test_support::TEST_MODEL_PRESETS[0].clone();
model.model = app.chat_widget.current_model().to_string();
model.available_access_programs = Some(ModelAccessPrograms {
cyber: vec![
CyberAccessProgram::Standard,
CyberAccessProgram::DaybreakBlue,
],
});
let mut unsupported_model = model.clone();
unsupported_model.model = "standard-only".into();
unsupported_model.available_access_programs = Some(ModelAccessPrograms {
cyber: vec![CyberAccessProgram::Standard],
});
app.chat_widget
.on_models_loaded(request_id, Ok(vec![model, unsupported_model]));
app.chat_widget
.handle_key_event(KeyEvent::from(KeyCode::Esc));
let mut tui = crate::tui::test_support::make_test_tui()?;
let mut confirmations = Vec::new();
for enabled in [true, false] {
app.chat_widget.insert_str("/daybreak");
app.chat_widget
.handle_key_event(KeyEvent::from(KeyCode::Esc));
app.chat_widget
.handle_key_event(KeyEvent::from(KeyCode::Enter));
let selection = std::iter::from_fn(|| events.try_recv().ok())
.find(|event| matches!(event, AppEvent::PersistDaybreakSelection { .. }))
.expect("Daybreak selection event");
app.handle_event(&mut tui, &mut server, selection).await?;
confirmations.push(next_history_message(&mut events));
assert_eq!(
server
.thread_read(thread_id, /*include_turns*/ false)
.await?
.daybreak_enabled,
Some(enabled)
);
assert_eq!(app.config.daybreak_enabled, enabled);
let writes = recorded_params(&requests, "config/batchWrite");
let edit = &writes.last().expect("config write")["edits"][0];
assert_eq!(edit["keyPath"], "daybreak");
assert_eq!(edit["value"], enabled);
}
insta::assert_snapshot!("daybreak_toggle_confirmations", confirmations.join("\n\n"));
app.chat_widget.set_daybreak_enabled(/*enabled*/ true);
app.chat_widget
.handle_key_event(KeyEvent::from(KeyCode::Esc));
app.chat_widget
.apply_external_edit("side prompt".to_string());
app.chat_widget
.handle_key_event(KeyEvent::from(KeyCode::Enter));
let turn = next_user_turn_op(&mut ops);
let mut unsupported_turn = turn.clone();
let Op::UserTurn { model, .. } = &mut unsupported_turn else {
unreachable!("expected user turn");
};
*model = "standard-only".into();
while events.try_recv().is_ok() {}
app.submit_thread_op(&mut server, thread_id, unsupported_turn)
.await?;
assert!(recorded_params(&requests, "turn/start").is_empty());
assert!(next_history_message(&mut events).contains("Daybreak support for model standard-only"));
app.chat_widget
.set_side_conversation_active(/*active*/ true);
app.submit_thread_op(&mut server, thread_id, turn.clone())
.await?;
app.chat_widget
.set_side_conversation_active(/*active*/ false);
app.submit_thread_op(&mut server, thread_id, turn.clone())
.await?;
let background_thread_id = server.start_thread(&app.config).await?.session.thread_id;
app.side_threads.insert(
background_thread_id,
crate::app::side::SideThreadState::new(thread_id),
);
app.submit_thread_op(&mut server, background_thread_id, turn.clone())
.await?;
let turns = recorded_params(&requests, "turn/start");
assert_eq!(turns.len(), 3);
assert_eq!(turns[0]["cyberAccessProgram"], "standard");
assert_eq!(turns[1]["cyberAccessProgram"], "daybreakBlue");
assert_eq!(turns[2]["cyberAccessProgram"], "standard");
app.chat_widget
.set_feature_enabled(Feature::CliDaybreak, /*enabled*/ false);
for target in [thread_id, background_thread_id] {
app.submit_thread_op(&mut server, target, turn.clone())
.await?;
}
let turns = recorded_params(&requests, "turn/start");
assert!(turns[3]["cyberAccessProgram"].is_null());
assert!(turns[4]["cyberAccessProgram"].is_null());
app.chat_widget
.set_feature_enabled(Feature::CliDaybreak, /*enabled*/ true);
app.chat_widget.set_daybreak_enabled(/*enabled*/ true);
app.chat_widget
.set_feature_enabled(Feature::ApiKeyCyberAccessPrograms, /*enabled*/ false);
let models = app.chat_widget.model_catalog().models.clone();
app.chat_widget.update_account_state(
Some(crate::status::StatusAccountDisplay::ApiKey),
/*plan_type*/ None,
/*has_chatgpt_account*/ false,
/*has_codex_backend_auth*/ false,
);
assert!(!app.chat_widget.daybreak_enabled);
let request_id = std::iter::from_fn(|| events.try_recv().ok())
.filter_map(|event| match event {
AppEvent::FetchModels { request_id } => Some(request_id),
_ => None,
})
.last()
.expect("account model refresh");
assert!(app.chat_widget.on_models_loaded(request_id, Ok(models)));
for (cli_daybreak, api_key_cyber_access_programs, enabled) in [
(false, false, true),
(false, true, true),
(true, false, true),
(true, true, true),
(true, true, false),
] {
app.chat_widget
.set_feature_enabled(Feature::CliDaybreak, cli_daybreak);
app.chat_widget.set_feature_enabled(
Feature::ApiKeyCyberAccessPrograms,
api_key_cyber_access_programs,
);
app.chat_widget.set_daybreak_enabled(enabled);
app.submit_thread_op(&mut server, thread_id, turn.clone())
.await?;
}
let turns = recorded_params(&requests, "turn/start");
assert_eq!(
turns[5..]
.iter()
.map(|turn| turn["cyberAccessProgram"].as_str())
.collect::<Vec<_>>(),
vec![None, None, None, Some("daybreakBlue"), Some("standard")]
);
while events.try_recv().is_ok() {}
let missing_thread_id = ThreadId::new();
app.active_thread_id = Some(missing_thread_id);
app.persist_daybreak_selection(&mut server, missing_thread_id, /*enabled*/ true)
.await;
assert!(next_history_message(&mut events).contains("Failed to read the thread"));
assert!(!app.chat_widget.daybreak_enabled);
assert!(!app.config.daybreak_enabled);
server.shutdown().await?;
proxy.await??;
Ok(())
}
async fn complete_managed_worktree_creation(
app: &mut App,
tui: &mut crate::tui::Tui,
server: &mut AppServerSession,
events: &mut tokio::sync::mpsc::UnboundedReceiver<AppEvent>,
) -> Result<()> {
drain_managed_worktree_start(app, server).await;
assert!(
app.pending_managed_worktree_creation,
"checkout task started"
);
loop {
let event = tokio::time::timeout(Duration::from_secs(15), events.recv())
.await?
.ok_or_else(|| color_eyre::eyre::eyre!("worktree creation event channel closed"))?;
if matches!(event, AppEvent::ManagedWorktreeCreated(_)) {
app.handle_event(tui, server, event).await?;
if let Some(created) = app.pending_managed_worktree_created.take() {
app.finish_managed_worktree(*created).await;
}
if let Some(transition) = app.pending_managed_worktree_transition.take() {
assert!(app.pending_managed_worktree_attach.is_none());
if let Err(error) = app
.switch_to_managed_worktree(tui, server, *transition)
.await
{
app.chat_widget.add_error_message(error.to_string());
}
if let Some(attach) = app.pending_managed_worktree_attach.take() {
app.attach_working_directory(tui, server, *attach).await;
}
}
return Ok(());
}
}
}
#[tokio::test]
async fn same_thread_retry_keeps_subscription_and_restores_draft() -> Result<()> {
let (mut app, codex_home) = make_history_test_app().await?;
let thread_id = ThreadId::from_string(
&create_fake_rollout(
codex_home.path(),
"2026-01-01T00-00-00",
"2026-01-01T00:00:00Z",
"Saved user message",
Some(app.config.model_provider_id.as_str()),
/*git_info*/ None,
)
.expect("create rollout"),
)?;
let path = Some(rollout_path(
codex_home.path(),
"2026-01-01T00-00-00",
&thread_id.to_string(),
));
let (mut app_server, requests, proxy) = start_recording_app_server(
&app.config,
/*blocked_thread_list*/ None,
/*failed_thread_name*/ None,
)
.await?;
let backend_id = app_server.backend_id();
app.enqueue_primary_thread_session(
test_thread_session(thread_id, test_path_buf("/tmp/project")),
Vec::new(),
)
.await?;
app.ensure_thread_channel(thread_id).mark_external_writer();
app.chat_widget.insert_str("Retained draft");
app.chat_widget.show_external_writer_thread();
crate::legacy_core::config::set_project_trust_level(
app.config.codex_home.as_path(),
app.config.cwd.as_path(),
codex_protocol::config_types::TrustLevel::Trusted,
)
.map_err(std::io::Error::other)?;
app.harness_overrides.cwd = Some(app.config.cwd.to_path_buf());
requests.lock().expect("request recorder lock").clear();
let mut tui = crate::tui::test_support::make_test_tui()?;
app.resume_target_session(
&mut tui,
&mut app_server,
crate::resume_picker::SessionTarget {
backend_id,
path,
thread_id,
cwd: None,
history_mode: None,
},
)
.await?;
assert_eq!(recorded_params(&requests, "thread/resume").len(), 1);
assert!(recorded_params(&requests, "thread/unsubscribe").is_empty());
assert!(!app.chat_widget.is_external_writer_view());
assert_eq!(
app.chat_widget.composer_text_with_pending(),
"Retained draft"
);
proxy.abort();
Ok(())
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(super) enum HistoryCapabilities {
Current,
LegacyOnly,
LegacyOnlyUnsupportedVariant,
LegacyDynamicToolsAndHistory,
ForkHydrationFails,
ReadAfterResumeFails,
ItemsListFails,
ItemsAndSummaryTurnsFail,
ThreadListFails,
ThreadStartFails,
ThreadStartWhileShuttingDown,
ThreadStartDuringLegacyShutdown,
ConfigReadUnsupported(i64),
ConfigReadFails,
SuperBindingsUnsupported,
ConfigReadUnknownVoice,
VoiceCatalogCustom,
VoiceCatalogUnavailable,
}
/// Returns and resets `(thread/loaded/list, thread/read)` request counts.
fn take_backfill_counts(requests: &RecordedRequests) -> (usize, usize) {
let requests = std::mem::take(&mut *requests.lock().expect("request recorder lock"));
(
requests
.iter()
.filter(|request| request.method == "thread/loaded/list")
.count(),
requests
.iter()
.filter(|request| request.method == "thread/read")
.count(),
)
}
/// Starts an embedded app server behind a loopback WebSocket proxy that records JSON-RPC methods.
pub(super) async fn start_recording_app_server(
config: &Config,
blocked_thread_list: Option<(ThreadId, oneshot::Sender<()>, oneshot::Receiver<()>)>,
failed_thread_name: Option<&'static str>,
) -> Result<RecordingAppServer> {
start_recording_app_server_with_history(
config,
HistoryCapabilities::Current,
blocked_thread_list,
failed_thread_name,
crate::app_server_session::ThreadParamsMode::Embedded,
LoaderOverrides::without_managed_config_for_tests(),
)
.await
}
pub(super) async fn start_recording_remote_app_server(
config: &Config,
) -> Result<RecordingAppServer> {
start_recording_app_server_with_history(
config,
HistoryCapabilities::Current,
/*blocked_thread_list*/ None,
/*failed_thread_name*/ None,
crate::app_server_session::ThreadParamsMode::Remote,
LoaderOverrides::default(),
)
.await
}
/// Proxies a real app server while optionally rejecting modern pagination like an older server.
pub(super) async fn start_recording_app_server_with_history(
config: &Config,
history_capabilities: HistoryCapabilities,
blocked_thread_list: Option<(ThreadId, oneshot::Sender<()>, oneshot::Receiver<()>)>,
failed_thread_name: Option<&'static str>,
thread_params_mode: crate::app_server_session::ThreadParamsMode,
loader_overrides: LoaderOverrides,
) -> Result<RecordingAppServer> {
start_recording_app_server_with_realtime_speech(
config,
history_capabilities,
blocked_thread_list,
failed_thread_name,
thread_params_mode,
RealtimeRequestBehavior::Forward,
loader_overrides,
)
.await
}
#[derive(Clone, Copy, PartialEq, Eq)]
pub(super) enum RealtimeRequestBehavior {
Forward,
AcceptStart,
AcceptSpeech,
AcceptSpeechAndStallStop,
}
pub(super) async fn start_recording_realtime_speech_app_server(
config: &Config,
realtime_behavior: RealtimeRequestBehavior,
) -> Result<RecordingAppServer> {
start_recording_app_server_with_realtime_speech(
config,
HistoryCapabilities::Current,
/*blocked_thread_list*/ None,
/*failed_thread_name*/ None,
crate::app_server_session::ThreadParamsMode::Embedded,
realtime_behavior,
LoaderOverrides::default(),
)
.await
}
pub(super) async fn start_recording_app_server_with_realtime_speech(
config: &Config,
history_capabilities: HistoryCapabilities,
mut blocked_thread_list: Option<(ThreadId, oneshot::Sender<()>, oneshot::Receiver<()>)>,
failed_thread_name: Option<&'static str>,
thread_params_mode: crate::app_server_session::ThreadParamsMode,
realtime_behavior: RealtimeRequestBehavior,
loader_overrides: LoaderOverrides,
) -> Result<RecordingAppServer> {
let state_db =
crate::init_state_db_for_app_server_target(config, &crate::AppServerTarget::Embedded)
.await?;
let mut embedded = crate::start_embedded_app_server(
codex_arg0::Arg0DispatchPaths::default(),
config.clone(),
Vec::new(),
loader_overrides,
/*strict_config*/ false,
codex_config::CloudConfigBundleLoader::default(),
codex_feedback::CodexFeedback::new(),
/*log_db*/ None,
state_db,
Arc::new(codex_exec_server::EnvironmentManager::default_for_tests()),
Default::default(),
)
.await?;
let codex_home = config.codex_home.display().to_string();
let requests = Arc::new(Mutex::new(Vec::new()));
let request_sink = Arc::clone(&requests);
let listener = TcpListener::bind("127.0.0.1:0").await?;
let websocket_url = format!("ws://{}", listener.local_addr()?);
let proxy = tokio::spawn(async move {
let (stream, _) = listener.accept().await?;
let mut websocket = accept_async(stream).await?;
let mut inventories = usize::from(failed_thread_name == Some("background"));
let mut reject_detach = false;
let mut reject_thread_list = history_capabilities == HistoryCapabilities::ThreadListFails;
loop {
let frame = tokio::select! {
frame = websocket.next() => frame,
event = embedded.next_event() => {
let Some(event) = event else { break };
if let codex_app_server_client::InProcessServerEvent::ServerNotification(notification) = event
&& matches!(*notification, ServerNotification::ThreadSettingsUpdated(_))
{
let result = websocket.send(Message::Text(serde_json::to_string(¬ification)?.into())).await;
if result.as_ref().is_err_and(is_recording_client_disconnect) {
break;
}
result?;
}
continue;
}
};
let Some(frame) = frame else { break };
// The client can close with requests or notifications pending during shutdown.
if frame.as_ref().is_err_and(is_recording_client_disconnect) {
break;
}
let Message::Text(text) = frame? else {
continue;
};
let message = serde_json::from_str::<JSONRPCMessage>(&text)?;
match message {
JSONRPCMessage::Request(request) if request.method == "initialize" => {
let result = websocket
.send(Message::Text(
serde_json::to_string(&JSONRPCMessage::Response(JSONRPCResponse {
id: request.id,
result: serde_json::json!({
"userAgent": "codex-tui-test",
"codexHome": codex_home,
}),
}))?
.into(),
))
.await;
if result.as_ref().is_err_and(is_recording_client_disconnect) {
break;
}
result?;
}
JSONRPCMessage::Request(request) => {
request_sink
.lock()
.expect("request recorder lock")
.push(request.clone());
if realtime_behavior == RealtimeRequestBehavior::AcceptSpeechAndStallStop
&& request.method == "thread/realtime/stop"
{
continue;
}
let request_id = request.id.clone();
let params = request.params.as_ref();
let requires_pagination = match request.method.as_str() {
"thread/start" => params
.and_then(|params| params.get("historyMode"))
.is_some_and(|mode| !mode.is_null()),
"thread/resume" | "thread/fork" => params
.and_then(|params| params.get("excludeTurns"))
.and_then(serde_json::Value::as_bool)
.unwrap_or(false),
"thread/turns/list" | "thread/items/list" => true,
_ => false,
};
let reject_fork_hydration = history_capabilities
== HistoryCapabilities::ForkHydrationFails
&& request.method == "thread/items/list"
&& request_sink
.lock()
.expect("request recorder lock")
.iter()
.any(|recorded| recorded.method == "thread/fork");
let reject_dynamic_tools = history_capabilities
== HistoryCapabilities::LegacyDynamicToolsAndHistory
&& request.method == "thread/start"
&& params
.and_then(|params| params.get("dynamicTools"))
.and_then(serde_json::Value::as_array)
.is_some_and(|tools| {
tools.iter().any(|tool| tool["type"] == "namespace")
});
let fake_realtime_response = (realtime_behavior
== RealtimeRequestBehavior::AcceptStart
&& request.method == "thread/realtime/start")
|| (matches!(
realtime_behavior,
RealtimeRequestBehavior::AcceptSpeech
| RealtimeRequestBehavior::AcceptSpeechAndStallStop
) && request.method == "thread/realtime/appendSpeech");
let response = if fake_realtime_response {
JSONRPCMessage::Response(JSONRPCResponse {
id: request_id,
result: serde_json::json!({}),
})
} else if (matches!(
history_capabilities,
HistoryCapabilities::ItemsListFails
| HistoryCapabilities::ItemsAndSummaryTurnsFail
) && (request.method == "thread/items/list"
|| (history_capabilities == HistoryCapabilities::ItemsAndSummaryTurnsFail
&& request.method == "thread/turns/list"
&& params.is_some_and(|params| params["itemsView"] == "summary"))))
|| (history_capabilities == HistoryCapabilities::ReadAfterResumeFails
&& request.method == "thread/read"
&& request_sink
.lock()
.expect("request recorder lock")
.iter()
.any(|recorded| recorded.method == "thread/resume"))
{
JSONRPCMessage::Error(JSONRPCError {
id: request_id,
error: JSONRPCErrorError {
code: -32603,
data: None,
message: "saved history unavailable".to_string(),
},
})
} else if let HistoryCapabilities::ConfigReadUnsupported(code) =
history_capabilities
&& request.method == "config/read"
{
JSONRPCMessage::Error(JSONRPCError {
id: request_id,
error: JSONRPCErrorError {
code,
data: None,
message: "unknown variant `config/read`".to_string(),
},
})
} else if history_capabilities == HistoryCapabilities::ConfigReadFails
&& request.method == "config/read"
{
JSONRPCMessage::Error(JSONRPCError {
id: request_id,
error: JSONRPCErrorError {
code: -32603,
data: None,
message: "config temporarily unavailable".to_string(),
},
})
} else if history_capabilities == HistoryCapabilities::SuperBindingsUnsupported
&& request.method == "config/value/write"
{
JSONRPCMessage::Error(JSONRPCError {
id: request_id,
error: JSONRPCErrorError {
code: -32600,
data: None,
message: "Invalid configuration: unknown key `super-left`"
.to_string(),
},
})
} else if history_capabilities == HistoryCapabilities::VoiceCatalogUnavailable
&& request.method == "thread/realtime/listVoices"
{
JSONRPCMessage::Error(JSONRPCError {
id: request_id,
error: JSONRPCErrorError {
code: -32601,
data: None,
message: "method not found".to_string(),
},
})
} else if matches!(
history_capabilities,
HistoryCapabilities::ThreadStartFails
| HistoryCapabilities::ThreadStartWhileShuttingDown
| HistoryCapabilities::ThreadStartDuringLegacyShutdown
) && request.method == "thread/start"
{
let (code, message, data) = match history_capabilities {
HistoryCapabilities::ThreadStartWhileShuttingDown => (
-32600,
"not accepting new actions",
Some(serde_json::json!({ "reason": "serverShuttingDown" })),
),
HistoryCapabilities::ThreadStartDuringLegacyShutdown => {
(-32600, "Server is draining; retry after reconnecting", None)
}
_ => (-32603, "replacement unavailable", None),
};
JSONRPCMessage::Error(JSONRPCError {
id: request_id,
error: JSONRPCErrorError {
code,
data,
message: message.to_string(),
},
})
} else if request.method == "thread/list"
&& params.is_some_and(|params| params["sortKey"] == "recency_at")
&& std::mem::take(&mut reject_thread_list)
{
JSONRPCMessage::Error(JSONRPCError {
id: request_id,
error: JSONRPCErrorError {
code: -32603,
data: None,
message: "thread listing unavailable".to_string(),
},
})
} else if history_capabilities == HistoryCapabilities::LegacyOnly
&& request.method == "thread/list"
&& params.is_some_and(|params| params["sortKey"] == "recency_at")
{
JSONRPCMessage::Error(JSONRPCError {
id: request_id,
error: JSONRPCErrorError {
code: -32602,
data: None,
message: "unknown variant `recency_at`".to_string(),
},
})
} else if reject_dynamic_tools {
JSONRPCMessage::Error(JSONRPCError {
id: request_id,
error: JSONRPCErrorError {
code: -32602,
data: None,
message: "missing field `inputSchema`".to_string(),
},
})
} else if matches!(
history_capabilities,
HistoryCapabilities::LegacyOnly
| HistoryCapabilities::LegacyOnlyUnsupportedVariant
| HistoryCapabilities::LegacyDynamicToolsAndHistory
) && requires_pagination
{
let (code, message) = if history_capabilities
== HistoryCapabilities::LegacyOnlyUnsupportedVariant
&& request.method == "thread/start"
{
(-32602, "unknown variant \"paginated\", expected \"legacy\"")
} else {
(-32601, "method not found")
};
JSONRPCMessage::Error(JSONRPCError {
id: request_id,
error: JSONRPCErrorError {
code,
data: None,
message: message.to_string(),
},
})
} else if reject_fork_hydration {
JSONRPCMessage::Error(JSONRPCError {
id: request_id,
error: JSONRPCErrorError {
code: -32603,
data: None,
message: "fork history hydration failed".to_string(),
},
})
} else {
let background = request.method == "thread/backgroundTerminals/list" && {
inventories += usize::from(inventories > 0);
matches!(inventories, 2 | 4)
};
let detach = request.method == "thread/unsubscribe";
let request = serde_json::from_value::<ClientRequest>(
serde_json::to_value(request)?,
)?;
if let ClientRequest::ThreadList { params, .. } = &request
&& let Some((root, started, release)) = blocked_thread_list.take()
{
assert_eq!(params.ancestor_thread_id, Some(root.to_string()));
assert_eq!(params.sort_direction, Some(SortDirection::Desc));
let _ = started.send(());
let _ = release.await;
}
let force_failure = matches!(
&request,
ClientRequest::ThreadSetName { params, .. }
if failed_thread_name == Some(params.name.as_str())
) || matches!(
&request,
ClientRequest::ThreadFork { params, .. }
if params.cwd.as_deref().is_some_and(|cwd| cwd.ends_with("failure"))
&& { reject_detach = true; true }
) || (detach && std::mem::take(&mut reject_detach));
if force_failure {
JSONRPCMessage::Error(JSONRPCError {
id: request_id,
error: JSONRPCErrorError {
code: -32603,
message: "forced thread/name/set failure".to_string(),
data: None,
},
})
} else {
let unknown_voice = history_capabilities
== HistoryCapabilities::ConfigReadUnknownVoice
&& matches!(&request, ClientRequest::ConfigRead { .. });
let custom_voice_catalog = history_capabilities
== HistoryCapabilities::VoiceCatalogCustom
&& matches!(
&request,
ClientRequest::ThreadRealtimeListVoices { .. }
);
let mut result = embedded.request(request).await?;
if unknown_voice && let Ok(value) = &mut result {
value["config"]["realtime"]["voice"] =
serde_json::json!("future_voice");
}
if custom_voice_catalog && let Ok(value) = &mut result {
value["voices"]["v1"] =
serde_json::json!(["maple", "cove", "juniper"]);
value["voices"]["defaultV1"] = serde_json::json!("maple");
}
if background {
let terminal = r#"{"data":[{"itemId":"x","processId":"x","command":"x","cwd":"/"}],"nextCursor":null}"#;
result = Ok(serde_json::from_str(terminal)?);
}
match result {
Ok(result) => JSONRPCMessage::Response(JSONRPCResponse {
id: request_id,
result,
}),
Err(error) => JSONRPCMessage::Error(JSONRPCError {
id: request_id,
error,
}),
}
}
};
let result = websocket
.send(Message::Text(serde_json::to_string(&response)?.into()))
.await;
if result.as_ref().is_err_and(is_recording_client_disconnect) {
break;
}
result?;
}
JSONRPCMessage::Notification(notification)
if notification.method == "initialized" => {}
JSONRPCMessage::Notification(notification) => {
embedded
.notify(serde_json::from_value::<ClientNotification>(
serde_json::to_value(notification)?,
)?)
.await?;
}
JSONRPCMessage::Response(response) => {
request_sink
.lock()
.expect("request recorder lock")
.push(JSONRPCRequest {
id: response.id,
method: "server/request/response".to_string(),
params: Some(response.result),
trace: None,
});
}
JSONRPCMessage::Error(error) => {
request_sink
.lock()
.expect("request recorder lock")
.push(JSONRPCRequest {
id: error.id,
method: "server/request/error".to_string(),
params: Some(serde_json::to_value(error.error)?),
trace: None,
});
}
}
}
embedded.shutdown().await?;
Ok(())
});
let app_server = crate::connect_remote_app_server(crate::RemoteAppServerEndpoint::WebSocket {
websocket_url,
auth_token: None,
})
.await?;
Ok((
AppServerSession::new(
crate::backend_id::BackendId::new(),
app_server,
thread_params_mode,
)
.with_local_codex_home(&config.codex_home),
requests,
proxy,
))
}
fn create_history_rollout(
config: &Config,
history_mode: ThreadHistoryMode,
preview: &str,
) -> Result<ThreadId> {
let create_rollout = match history_mode {
ThreadHistoryMode::Legacy => create_fake_rollout,
ThreadHistoryMode::Paginated => create_fake_paginated_rollout,
};
let thread_id = create_rollout(
config.codex_home.as_path(),
"2026-01-02T00-00-00",
"2026-01-02T00:00:00Z",
preview,
Some(config.model_provider_id.as_str()),
/*git_info*/ None,
)
.map_err(|err| color_eyre::eyre::eyre!("failed to create history rollout: {err}"))?;
Ok(ThreadId::from_string(&thread_id)?)
}
pub(super) fn recorded_params(requests: &RecordedRequests, method: &str) -> Vec<serde_json::Value> {
requests
.lock()
.expect("request recorder lock")
.iter()
.filter(|request| request.method == method)
.map(|request| request.params.clone().unwrap_or(serde_json::Value::Null))
.collect()
}
async fn make_history_test_app() -> Result<(Box<App>, tempfile::TempDir)> {
let mut app = make_test_app().await;
let codex_home = tempdir()?;
app.config.codex_home = codex_home.path().to_path_buf().abs();
app.config.sqlite = SqliteConfig::new_for_testing(codex_home.path().abs());
Ok((app, codex_home))
}
#[tokio::test]
async fn in_app_remote_resume_picker_preserves_remote_cwd_filter() -> Result<()> {
let (mut app, _codex_home) = make_history_test_app().await?;
let remote_root = tempdir()?;
let remote_cwd = remote_root.path().join("project");
std::fs::create_dir(&remote_cwd)?;
let (app_server, _requests, active_proxy) =
start_recording_remote_app_server(&app.config).await?;
let mut app_server = app_server.with_remote_cwd_override(Some(remote_cwd.clone()));
app.harness_overrides.model_provider = Some(app.config.model_provider_id.clone());
let listener = TcpListener::bind("127.0.0.1:0").await?;
app.app_server_target = AppServerTarget::Remote {
endpoint: crate::resolve_remote_addr(&format!("ws://{}", listener.local_addr()?))?,
};
let (request_tx, request_rx) = oneshot::channel();
let (release_tx, release_rx) = oneshot::channel::<()>();
let codex_home = app.config.codex_home.display().to_string();
let recorder = tokio::spawn(async move {
let (socket, _) = listener.accept().await?;
let mut websocket = accept_async(socket).await?;
while let Some(frame) = websocket.next().await {
let Message::Text(text) = frame? else {
continue;
};
match serde_json::from_str::<JSONRPCMessage>(&text)? {
JSONRPCMessage::Request(request) if request.method == "initialize" => {
let response = JSONRPCMessage::Response(JSONRPCResponse {
id: request.id,
result: serde_json::json!({
"userAgent": "codex-tui-test",
"codexHome": codex_home,
}),
});
websocket
.send(Message::Text(serde_json::to_string(&response)?.into()))
.await?;
}
JSONRPCMessage::Request(request) if request.method == "thread/list" => {
let _ = request_tx.send(request.params.unwrap_or_default());
let _ = release_rx.await;
return Ok::<(), color_eyre::Report>(());
}
_ => {}
}
}
Err(color_eyre::eyre::eyre!(
"picker disconnected before requesting its thread list"
))
});
let mut tui = crate::tui::test_support::make_test_tui()?;
tui.set_alt_screen_enabled(/*enabled*/ false);
tui.pause_events();
let mut picker = Box::pin(app.open_resume_picker(&mut tui, &mut app_server));
let params = tokio::time::timeout(std::time::Duration::from_secs(/*secs*/ 5), async {
tokio::select! {
biased;
params = request_rx => params.map_err(|_| {
color_eyre::eyre::eyre!("picker request recorder closed")
}),
result = &mut picker => {
result?;
Err(color_eyre::eyre::eyre!(
"picker exited before requesting its thread list"
))
}
}
})
.await??;
drop(picker);
let _ = release_tx.send(());
recorder.await??;
app_server.shutdown().await?;
active_proxy.await??;
assert_eq!(
params["cwd"],
serde_json::Value::String(remote_cwd.display().to_string())
);
Ok(())
}
#[tokio::test]
async fn delete_current_thread_navigates_only_after_success() -> Result<()> {
let endpoint = crate::resolve_remote_addr("ws://127.0.0.1:4500")?;
for target in [
AppServerTarget::Embedded,
AppServerTarget::LocalDaemon {
allow_embedded_fallback: true,
endpoint: endpoint.clone(),
},
AppServerTarget::Remote { endpoint },
] {
let (mut app, _codex_home) = make_history_test_app().await?;
let thread_id =
create_history_rollout(&app.config, ThreadHistoryMode::Legacy, "delete me")?;
let (mut server, requests, proxy) = start_recording_app_server(
&app.config,
/*blocked_thread_list*/ None,
/*failed_thread_name*/ None,
)
.await?;
app.app_server_target = target;
let mut tui = crate::tui::test_support::make_test_tui()?;
let missing_id = ThreadId::new();
app.active_thread_id = Some(missing_id);
app.chat_widget.insert_str("Retained on failure");
assert_matches!(
app.delete_current_thread(&mut tui, &mut server).await?,
AppRunControl::Continue
);
assert_eq!(app.active_thread_id, Some(missing_id));
assert_eq!(
app.chat_widget.composer_text_with_pending(),
"Retained on failure"
);
assert!(!app.chat_widget.has_active_view());
let resumed = server
.resume_thread(
&app.local_settings,
app.config.clone(),
thread_id,
crate::app_server_session::ResumeModelSettings::RestoreFromThread,
)
.await?;
app.active_thread_id = Some(thread_id);
app.enqueue_primary_thread_session(resumed.session.clone(), resumed.turns)
.await?;
app.chat_widget.handle_thread_session(resumed.session);
let mut side_config = app.config.clone();
side_config.ephemeral = true;
let side = server
.fork_side_thread(
&app.local_settings,
side_config.clone(),
thread_id,
/*selected_profile*/ None,
)
.await?;
let side_id = side.session.thread_id;
app.side_threads
.insert(side_id, SideThreadState::new(thread_id));
if !matches!(app.app_server_target, AppServerTarget::Embedded) {
// The recording proxy rejects the next unsubscribe after a failed fork.
side_config.cwd = side_config.cwd.join("failure");
assert!(
server
.fork_side_thread(
&app.local_settings,
side_config,
thread_id,
/*selected_profile*/ None
)
.await
.is_err()
);
assert_matches!(
app.delete_current_thread(&mut tui, &mut server).await?,
AppRunControl::Continue
);
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_eq!(recorded_params(&requests, "thread/delete").len(), 1);
}
let (tx, mut events) = tokio::sync::mpsc::unbounded_channel();
app.app_event_tx = AppEventSender::new(tx);
let control =
Box::pin(app.handle_event(&mut tui, &mut server, AppEvent::DeleteCurrentThread))
.await?;
assert!(
server
.thread_read(thread_id, /*include_turns*/ false)
.await
.is_err()
);
if matches!(app.app_server_target, AppServerTarget::Embedded) {
assert_matches!(control, AppRunControl::Exit(ExitReason::ThreadRemoved));
assert!(recorded_params(&requests, "thread/unsubscribe").is_empty());
} else {
assert_matches!(control, AppRunControl::Continue);
assert!(app.side_threads.is_empty());
assert_eq!(
recorded_params(&requests, "thread/unsubscribe"),
vec![serde_json::json!({"threadId": side_id.to_string()}); 2]
);
loop {
let event = tokio::time::timeout(Duration::from_secs(/*secs*/ 5), events.recv())
.await?
.expect("command center refresh");
let refreshed = matches!(&event, AppEvent::AgentsOverviewThreadsLoaded { .. });
Box::pin(app.handle_event(&mut tui, &mut server, event)).await?;
if refreshed {
break;
}
}
assert_eq!(
(
app.active_thread_id,
app.primary_thread_id,
app.chat_widget.thread_id()
),
(None, None, None)
);
assert!(app.chat_widget.composer_is_empty());
assert!(app.chat_widget.has_active_view());
}
assert_eq!(
recorded_params(&requests, "thread/delete"),
vec![
serde_json::json!({"threadId": missing_id.to_string()}),
serde_json::json!({"threadId": thread_id.to_string()}),
]
);
server.shutdown().await?;
proxy.await??;
}
Ok(())
}
fn spawn_approved_task_tool_call(
app: &App,
app_server: &AppServerSession,
request_id: AppServerRequestId,
params: codex_app_server_protocol::DynamicToolCallParams,
) {
let request_handle = app_server.request_handle();
let app_event_tx = app.app_event_tx.clone();
let status_updates = app.dynamic_tool_status_updates.subscribe();
let mut thread_start_params = crate::app_server_session::thread_start_params_from_config(
&app.config,
app_server.thread_params_mode(),
app_server.remote_cwd_override(),
/*session_start_source*/ None,
);
app_server
.thread_tool_transport()
.configure(&mut thread_start_params);
let features = app.config.features.get().clone();
tokio::spawn(async move {
let response = crate::dynamic_tools::execute(
request_handle,
params,
thread_start_params,
features,
status_updates,
Some(&app_event_tx),
)
.await;
app_event_tx.send(AppEvent::DynamicToolCallCompleted {
request_id,
response,
});
});
}
#[tokio::test]
async fn external_transport_registers_dynamic_tools_and_finds_task_mentions() -> Result<()> {
let (app, _codex_home) = make_history_test_app().await?;
let (mut app_server, requests, proxy) = Box::pin(start_recording_app_server(
&app.config,
/*blocked_thread_list*/ None,
/*failed_thread_name*/ None,
))
.await?;
let started = app_server.start_thread(&app.config).await?;
assert!(started.task_tools_available);
assert!(app_server.task_tools_available(started.session.thread_id));
let startup = crate::app_server_session::start_thread_with_request_handle(
app_server.request_handle(),
&app.local_settings,
app.config.clone(),
crate::app_server_session::ThreadParamsMode::Embedded,
/*remote_cwd_override*/ None,
app_server.thread_tool_transport(),
crate::app_server_session::StartupLaunchChoices::default(),
)
.await?;
assert!(startup.task_tools_available);
let starts = recorded_params(&requests, "thread/start");
assert_eq!(starts.len(), 2);
for params in starts {
assert_eq!(params["dynamicTools"][0]["type"], "namespace");
assert_eq!(params["dynamicTools"][0]["name"], "codex_tui");
assert_eq!(
params["dynamicTools"][0]["tools"].as_array().map(Vec::len),
Some(6)
);
assert!(
params["dynamicTools"][0]["tools"]
.as_array()
.is_some_and(|tools| tools.iter().all(|tool| {
tool["deferLoading"] == true
&& !crate::dynamic_tools::DELEGATION_TOOLS
.contains(&tool["name"].as_str().unwrap_or_default())
}))
);
}
let target_id = started.session.thread_id;
app_server
.thread_inject_items(target_id, vec![App::side_boundary_prompt_item()])
.await?;
crate::init_state_db_for_app_server_target(&app.config, &crate::AppServerTarget::Embedded)
.await?
.expect("state database")
.set_thread_preview_if_empty(target_id, "Review database migration")
.await
.expect("seed searchable thread preview");
app_server.shutdown().await?;
proxy.await??;
let (mut restarted_app_server, _restarted_requests, restarted_proxy) =
Box::pin(start_recording_app_server(
&app.config,
/*blocked_thread_list*/ None,
/*failed_thread_name*/ None,
))
.await?;
let resumed = Box::pin(restarted_app_server.resume_thread(
&app.local_settings,
app.config.clone(),
target_id,
crate::app_server_session::ResumeModelSettings::RestoreFromThread,
))
.await?;
assert!(resumed.task_tools_available);
assert!(restarted_app_server.task_tools_available(target_id));
let forked = Box::pin(restarted_app_server.fork_thread(
&app.local_settings,
app.config.clone(),
target_id,
))
.await?;
assert!(forked.task_tools_available);
assert!(restarted_app_server.task_tools_available(forked.session.thread_id));
restarted_app_server
.thread_set_name(target_id, "Bluebird".to_string())
.await?;
let (sender, mut events) = tokio::sync::mpsc::unbounded_channel();
crate::task_mentions::spawn_search(
restarted_app_server.request_handle(),
"bbd".to_string(),
startup.session.thread_id,
app.config.cwd.to_path_buf(),
restarted_app_server.task_search_generation(),
crate::app_event_sender::AppEventSender::new(sender),
);
let event = tokio::time::timeout(Duration::from_secs(/*secs*/ 5), events.recv())
.await?
.expect("expected task search results");
let AppEvent::TaskSearchResult { matches, .. } = event else {
panic!("expected task search results");
};
assert!(
matches
.iter()
.any(|task| task.thread_id == target_id.to_string() && task.title == "Bluebird"),
"expected created task in {matches:?}"
);
restarted_app_server.shutdown().await?;
restarted_proxy.await??;
Ok(())
}
#[tokio::test]
async fn archive_current_thread_reports_success_only_after_archiving() -> Result<()> {
let (mut app, _codex_home) = make_history_test_app().await?;
let thread_id = ThreadId::from_string(
&create_fake_rollout(
&app.config.codex_home,
"2026-08-25T01-00-00",
"2026-08-25T01:00:00Z",
"archive me",
Some(&app.config.model_provider_id),
/*git_info*/ None,
)
.expect("create rollout"),
)?;
let mut app_server = crate::start_embedded_app_server_for_picker(&app.config).await?;
let mut tui = crate::tui::test_support::make_test_tui()?;
app.active_thread_id = Some(ThreadId::new());
assert_matches!(
app.archive_current_thread(&mut tui, &mut app_server)
.await?,
AppRunControl::Continue
);
app.active_thread_id = Some(thread_id);
assert_matches!(
app.archive_current_thread(&mut tui, &mut app_server).await?,
AppRunControl::Exit(ExitReason::Archived(archived_id)) if archived_id == thread_id
);
app_server.shutdown().await?;
Ok(())
}
#[tokio::test]
async fn archive_current_thread_returns_shared_servers_to_agents() -> Result<()> {
let endpoint = crate::resolve_remote_addr("ws://127.0.0.1:4500")?;
for (target, attachment, side_exists) in [
AppServerTarget::LocalDaemon {
allow_embedded_fallback: true,
endpoint: endpoint.clone(),
},
AppServerTarget::Remote { endpoint },
]
.into_iter()
.flat_map(|target| {
[
(ThreadEventAttachment::Live, true),
(ThreadEventAttachment::ReplayOnly, true),
(ThreadEventAttachment::ReplayOnly, false),
]
.map(|(attachment, side_exists)| (target.clone(), attachment, side_exists))
}) {
let (mut app, _codex_home) = make_history_test_app().await?;
let thread_id =
create_history_rollout(&app.config, ThreadHistoryMode::Legacy, "archive me")?;
let (mut server, requests, proxy) = start_recording_app_server(
&app.config,
/*blocked_thread_list*/ None,
/*failed_thread_name*/ None,
)
.await?;
let resumed = server
.resume_thread(
&app.local_settings,
app.config.clone(),
thread_id,
crate::app_server_session::ResumeModelSettings::RestoreFromThread,
)
.await?;
let side_id = if side_exists {
let mut side_config = app.config.clone();
side_config.ephemeral = true;
server
.fork_side_thread(
&app.local_settings,
side_config,
thread_id,
/*selected_profile*/ None,
)
.await?
.session
.thread_id
} else {
// The saved side transcript outlived its ephemeral server thread.
ThreadId::new()
};
if attachment == ThreadEventAttachment::ReplayOnly {
app.ensure_thread_channel(side_id).mark_replay_only();
}
app.side_threads
.insert(side_id, SideThreadState::new(thread_id));
app.app_server_target = target;
app.enqueue_primary_thread_session(resumed.session.clone(), resumed.turns)
.await?;
app.chat_widget.handle_thread_session(resumed.session);
app.chat_widget.insert_str("Unsent archived draft");
let mut tui = crate::tui::test_support::make_test_tui()?;
let (tx, mut events) = tokio::sync::mpsc::unbounded_channel();
app.app_event_tx = AppEventSender::new(tx);
assert_matches!(
Box::pin(app.handle_event(&mut tui, &mut server, AppEvent::ArchiveCurrentThread))
.await?,
AppRunControl::Continue
);
loop {
let event = tokio::time::timeout(Duration::from_secs(/*secs*/ 5), events.recv())
.await?
.expect("expected command center refresh");
let refreshed = matches!(&event, AppEvent::AgentsOverviewThreadsLoaded { .. });
Box::pin(app.handle_event(&mut tui, &mut server, event)).await?;
if refreshed {
break;
}
}
assert!(app.agents_overview.initialized);
assert_eq!(
(
app.active_thread_id,
app.primary_thread_id,
app.chat_widget.thread_id()
),
(None, None, None)
);
assert!(!app.agents_overview.threads.contains_key(&thread_id));
assert!(app.thread_event_channels.is_empty());
assert!(app.side_threads.is_empty());
assert_eq!(
recorded_params(&requests, "thread/unsubscribe"),
vec![serde_json::json!({"threadId": side_id.to_string()})]
);
assert_eq!(
recorded_params(&requests, "turn/interrupt"),
vec![serde_json::json!({"threadId": side_id.to_string(), "turnId": ""})]
);
assert!(app.chat_widget.composer_is_empty());
assert_eq!(
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()
);
server.shutdown().await?;
proxy.await??;
}
Ok(())
}
#[tokio::test]
async fn local_daemon_registers_approval_gated_mcp_tools_for_both_start_paths() -> Result<()> {
boxed_future!(local_daemon_registers_approval_gated_mcp_tools_for_both_start_paths_scenario())
.await
}
async fn local_daemon_registers_approval_gated_mcp_tools_for_both_start_paths_scenario()
-> Result<()> {
let (mut app, events, _ops) = Box::pin(make_test_app_with_channels()).await;
// Invalid optional worktree settings must preserve both daemon start paths.
let codex_home = tempdir()?;
app.config.codex_home = codex_home.path().to_path_buf().abs();
app.config.sqlite = SqliteConfig::new_for_testing(codex_home.path().abs());
std::fs::write(
codex_home.path().join("config.toml"),
"web_search = \"disabled\"\n[desktop]\ngit-worktree-root = 'relative'\n",
)?;
// Keep the large lifecycle futures off the Windows test thread's stack.
let (mut app_server, mut requests, mut proxy) = Box::pin(start_recording_app_server(
&app.config,
/*blocked_thread_list*/ None,
/*failed_thread_name*/ None,
))
.await?;
Box::pin(app_server.start_dynamic_tool_mcp(
app.config.clone(),
app.app_event_tx.clone(),
app.dynamic_tool_status_updates.clone(),
))
.await?;
let started = Box::pin(app_server.start_thread(&app.config)).await?;
let thread_id = started.session.thread_id;
assert!(started.task_tools_available);
assert!(app_server.task_tools_available(thread_id));
let startup = crate::app_server_session::start_thread_with_request_handle(
app_server.request_handle(),
&app.local_settings,
app.config.clone(),
crate::app_server_session::ThreadParamsMode::Embedded,
/*remote_cwd_override*/ None,
app_server.thread_tool_transport(),
crate::app_server_session::StartupLaunchChoices::default(),
)
.await?;
assert!(startup.task_tools_available);
let inventory: codex_app_server_protocol::ListMcpServerStatusResponse = app_server
.request_handle()
.request_typed(ClientRequest::McpServerStatusList {
request_id: AppServerRequestId::String("tui-tool-inventory".to_string()),
params: codex_app_server_protocol::ListMcpServerStatusParams {
server_name: None,
cursor: None,
limit: None,
detail: Some(codex_app_server_protocol::McpServerStatusDetail::ToolsAndAuthOnly),
thread_id: Some(thread_id.to_string()),
},
})
.await?;
let tools = &inventory
.data
.iter()
.find(|server| server.name == "codex_tui")
.expect("local daemon must connect to the TUI MCP server")
.tools;
assert_eq!(tools.len(), 9);
for tool in crate::dynamic_tools::DELEGATION_TOOLS {
assert!(tools.contains_key(tool));
}
assert!(
!tools["create_thread"]
.input_schema
.get("properties")
.and_then(serde_json::Value::as_object)
.is_some_and(|properties| properties.contains_key("permissions"))
);
let starts = recorded_params(&requests, "thread/start");
assert_eq!(starts.len(), 2);
for params in &starts {
assert_eq!(params["dynamicTools"], serde_json::Value::Null);
assert_eq!(params["config"].get("web_search"), None);
let server = ¶ms["config"]["mcp_servers.codex_tui"];
assert!(
server["url"]
.as_str()
.is_some_and(|url| url.starts_with("http://127.0.0.1:"))
);
assert!(
server["http_headers"]["Authorization"]
.as_str()
.is_some_and(|header| header.starts_with("Bearer "))
);
assert_eq!(server["default_tools_approval_mode"], "approve");
for tool in crate::dynamic_tools::DELEGATION_TOOLS {
assert_eq!(server["tools"][tool]["approval_mode"], "prompt");
}
}
let mcp_url = starts[0]["config"]["mcp_servers.codex_tui"]["url"]
.as_str()
.expect("MCP server URL");
let unauthorized = codex_http_client::HttpClientBuilder::new()
.build_direct()?
.post(mcp_url)
.send()
.await?;
assert_eq!(unauthorized.status().as_u16(), 401);
app.config
.web_search_mode
.set(codex_protocol::config_types::WebSearchMode::Disabled)?;
let delegation_source = create_history_rollout(
&app.config,
ThreadHistoryMode::Legacy,
"Approved task source",
)?;
Box::pin(app_server.resume_thread(
&app.local_settings,
app.config.clone(),
delegation_source,
crate::app_server_session::ResumeModelSettings::RestoreFromThread,
))
.await?;
let resumed = recorded_params(&requests, "thread/resume")
.pop()
.expect("resumed task request");
assert_eq!(
resumed["config"]["mcp_servers.codex_tui"],
starts[0]["config"]["mcp_servers.codex_tui"]
);
Box::pin(app_server.resume_thread(
&app.local_settings,
app.config.clone(),
delegation_source,
crate::app_server_session::ResumeModelSettings::PreserveExistingThread,
))
.await?;
let reattached = recorded_params(&requests, "thread/resume")
.pop()
.expect("reattached task request");
assert_eq!(
reattached["config"]["mcp_servers.codex_tui"],
starts[0]["config"]["mcp_servers.codex_tui"]
);
Box::pin(app_server.fork_thread(&app.local_settings, app.config.clone(), delegation_source))
.await?;
let forked = recorded_params(&requests, "thread/fork")
.pop()
.expect("forked task request");
assert_eq!(
forked["config"]["mcp_servers.codex_tui"],
starts[0]["config"]["mcp_servers.codex_tui"]
);
let authorization =
starts[0]["config"]["mcp_servers.codex_tui"]["http_headers"]["Authorization"]
.as_str()
.expect("MCP bearer token");
let client = codex_http_client::HttpClientBuilder::new().build_direct()?;
let call_tool = |id: u32, tool: &'static str, arguments: serde_json::Value| {
client
.post(mcp_url)
.header("Authorization", authorization)
.header("Accept", "application/json, text/event-stream")
.header("MCP-Protocol-Version", "2026-07-28")
.header("MCP-Method", "tools/call")
.header("MCP-Name", tool)
.json(&serde_json::json!({
"jsonrpc": "2.0",
"id": id,
"method": "tools/call",
"params": {
"name": tool,
"arguments": arguments,
"_meta": {
"threadId": delegation_source,
"io.modelcontextprotocol/protocolVersion": "2026-07-28",
"io.modelcontextprotocol/clientCapabilities": {}
}
}
}))
};
let transport = app_server.thread_tool_transport();
let crate::dynamic_tools_mcp::ThreadToolTransport::Mcp(tool_server) = &transport else {
panic!("expected the daemon task-tool bridge");
};
tool_server.suspend();
let paused = call_tool(0, "list_threads", serde_json::json!({}))
.send()
.await?
.text()
.await?;
assert!(
paused.contains("TUI is reconnecting; tool was not sent"),
"{paused}"
);
let (replacement, replacement_requests, replacement_proxy) =
Box::pin(start_recording_app_server(
&app.config,
/*blocked_thread_list*/ None,
/*failed_thread_name*/ None,
))
.await?;
let (new_tx, new_rx) = mpsc::unbounded_channel();
let new_sender = AppEventSender::new(new_tx);
drop(events);
let mut events = new_rx;
assert!(app.app_event_tx.app_event_tx.is_closed());
tool_server.reconnect(replacement.request_handle(), new_sender);
let previous = std::mem::replace(
&mut app_server,
replacement.with_thread_tool_transport(transport),
);
previous.shutdown().await?;
proxy.await??;
requests = replacement_requests;
proxy = replacement_proxy;
// The same MCP URL and credentials now use the new connection and event receiver.
let response = call_tool(1, "list_threads", serde_json::json!({}))
.send()
.await?;
let status = response.status();
let response = response.text().await?;
assert!(status.is_success(), "{status}: {response}");
assert!(response.contains("threads"), "{response}");
let mut creation = tokio::spawn(
call_tool(
2,
"create_thread",
serde_json::json!({"prompt": "Start an approved task"}),
)
.send(),
);
let registration = tokio::select! {
event = events.recv() => event.expect("approved MCP task must register before starting"),
response = &mut creation => {
let response = response??;
panic!("MCP task creation completed without registration: {}", response.text().await?);
}
_ = tokio::time::sleep(std::time::Duration::from_secs(/*secs*/ 5)) => {
panic!("timed out waiting for MCP task registration");
}
};
let AppEvent::DynamicToolThreadStarted {
thread,
task_tools_available,
registered,
} = registration
else {
panic!("expected the MCP-created task to register")
};
let child_thread_id = ThreadId::from_string(&thread.id)?;
assert!(task_tools_available);
assert!(registered.send(()).is_ok());
let created = creation.await??;
assert!(created.status().is_success());
assert!(created.text().await?.contains(&child_thread_id.to_string()));
let child = recorded_params(&requests, "thread/start")
.pop()
.expect("MCP child thread/start request");
assert_eq!(child["dynamicTools"], serde_json::Value::Null);
assert!(child["config"]["web_search"].is_null());
assert_eq!(
child["config"]["mcp_servers.codex_tui"],
starts[0]["config"]["mcp_servers.codex_tui"]
);
// Fork another task: this synthetic MCP call has no active turn to cut before.
let fork_source =
create_history_rollout(&app.config, ThreadHistoryMode::Legacy, "Task to fork")?;
let forked = tokio::spawn(
call_tool(
3,
"fork_thread",
serde_json::json!({"threadId": fork_source}),
)
.send(),
);
let mut registered_ids = Vec::new();
let mut tui = crate::tui::test_support::make_test_tui()?;
for _ in 0..2 {
let registration = tokio::time::timeout(Duration::from_secs(/*secs*/ 5), events.recv())
.await?
.expect("fork registration event");
let AppEvent::DynamicToolThreadStarted { thread, .. } = ®istration else {
panic!("expected the MCP fork to register")
};
let forked_thread_id = ThreadId::from_string(&thread.id)?;
let expected_thread = thread.clone();
if registered_ids.is_empty() {
assert!(recorded_params(&requests, "thread/fork").is_empty());
}
Box::pin(app.handle_event(&mut tui, &mut app_server, registration)).await?;
assert_eq!(
app.agents_overview.threads[&forked_thread_id],
Some(expected_thread)
);
registered_ids.push(forked_thread_id);
}
assert_eq!(registered_ids[0], fork_source);
let forked_thread_id = registered_ids[1];
let forked = forked.await??;
assert!(forked.status().is_success());
assert!(forked.text().await?.contains(&forked_thread_id.to_string()));
let forked = recorded_params(&requests, "thread/fork")
.pop()
.expect("MCP-created fork request");
assert_eq!(
forked["config"]["mcp_servers.codex_tui"],
starts[0]["config"]["mcp_servers.codex_tui"]
);
app_server.shutdown().await?;
proxy.await??;
Ok(())
}
#[tokio::test]
async fn local_mcp_respects_configured_servers_and_managed_requirements() -> Result<()> {
for scenario in ["conflicting", "blocked", "mismatched", "allowed"] {
let (mut app, _codex_home) = make_history_test_app().await?;
if scenario == "conflicting" {
let raw = serde_json::from_value::<codex_config::RawMcpServerConfig>(
serde_json::json!({"url": "http://127.0.0.1:1/mcp", "enabled": false}),
)?;
let mut servers = app.config.mcp_servers.get().clone();
servers.insert(
crate::dynamic_tools::NAMESPACE.to_string(),
codex_config::McpServerConfig::try_from(raw)
.map_err(color_eyre::eyre::Report::msg)?,
);
app.config.mcp_servers.set(servers)?;
} else {
let mut allowed_servers = std::collections::BTreeMap::new();
if matches!(scenario, "mismatched" | "allowed") {
let requirement = if scenario == "allowed" {
codex_config::McpServerRequirement::Url(
codex_protocol::mcp_policy::McpServerValueMatcher::Prefix {
value: "http://127.0.0.1:".to_string(),
},
)
} else {
codex_config::McpServerRequirement::Identity {
identity: codex_config::McpServerIdentity::Url {
url: "http://127.0.0.1:1/mcp".to_string(),
},
}
};
allowed_servers.insert(crate::dynamic_tools::NAMESPACE.to_string(), requirement);
}
let requirements = codex_config::ConfigRequirements {
mcp_servers: Some(codex_config::Sourced::new(
allowed_servers,
codex_config::RequirementSource::Unknown,
)),
..Default::default()
};
app.config.config_layer_stack = codex_config::ConfigLayerStack::new(
Vec::new(),
requirements,
codex_config::ConfigRequirementsToml::default(),
)?;
}
let (mut app_server, requests, proxy) = start_recording_app_server(
&app.config,
/*blocked_thread_list*/ None,
/*failed_thread_name*/ None,
)
.await?;
let result = app_server
.start_dynamic_tool_mcp(
app.config.clone(),
app.app_event_tx.clone(),
app.dynamic_tool_status_updates.clone(),
)
.await;
if scenario == "allowed" {
result?;
} else {
let error = result.expect_err("unavailable internal MCP must fail closed");
assert_eq!(
error.kind(),
if scenario == "conflicting" {
std::io::ErrorKind::AlreadyExists
} else {
std::io::ErrorKind::PermissionDenied
}
);
}
app_server.start_thread(&app.config).await?;
let start = recorded_params(&requests, "thread/start")
.pop()
.expect("fallback task start");
if scenario == "allowed" {
assert!(start["dynamicTools"].is_null());
assert!(start["config"]["mcp_servers.codex_tui"].is_object());
} else {
assert_eq!(
start["dynamicTools"][0]["tools"].as_array().map(Vec::len),
Some(6)
);
assert!(start["config"]["mcp_servers.codex_tui"].is_null());
}
app_server.shutdown().await?;
proxy.await??;
}
Ok(())
}
#[tokio::test]
async fn older_external_server_starts_without_unsupported_dynamic_tools_or_history() -> Result<()> {
let (app, _codex_home) = make_history_test_app().await?;
let (mut app_server, requests, proxy) = start_recording_app_server_with_history(
&app.config,
HistoryCapabilities::LegacyDynamicToolsAndHistory,
/*blocked_thread_list*/ None,
/*failed_thread_name*/ None,
crate::app_server_session::ThreadParamsMode::Embedded,
LoaderOverrides::default(),
)
.await?;
let started = app_server.start_thread(&app.config).await?;
assert!(!started.task_tools_available);
assert!(!app_server.task_tools_available(started.session.thread_id));
let startup = crate::app_server_session::start_thread_with_request_handle(
app_server.request_handle(),
&app.local_settings,
app.config.clone(),
crate::app_server_session::ThreadParamsMode::Embedded,
/*remote_cwd_override*/ None,
app_server.thread_tool_transport(),
crate::app_server_session::StartupLaunchChoices::default(),
)
.await?;
assert!(!startup.task_tools_available);
let starts = recorded_params(&requests, "thread/start");
assert_eq!(starts.len(), 6);
for attempts in starts.as_chunks::<3>().0 {
assert_eq!(attempts[0]["dynamicTools"][0]["type"], "namespace");
assert_eq!(attempts[0]["historyMode"], "paginated");
assert_eq!(attempts[1]["dynamicTools"], serde_json::Value::Null);
assert_eq!(attempts[1]["historyMode"], "paginated");
assert_eq!(attempts[2]["dynamicTools"], serde_json::Value::Null);
assert_eq!(attempts[2]["historyMode"], serde_json::Value::Null);
}
app_server.shutdown().await?;
proxy.await??;
Ok(())
}
#[tokio::test]
async fn embedded_server_rejects_unowned_dynamic_tool_calls() -> Result<()> {
let (mut app, mut events, _ops) = make_test_app_with_channels().await;
let codex_home = tempdir()?;
app.config.codex_home = codex_home.path().to_path_buf().abs();
app.config.sqlite = SqliteConfig::new_for_testing(codex_home.path().abs());
let app_server = crate::start_embedded_app_server_for_picker(&app.config).await?;
app.handle_app_server_event(
&app_server,
codex_app_server_client::AppServerEvent::ServerRequest(Box::new(
ServerRequest::DynamicToolCall {
request_id: AppServerRequestId::Integer(100),
params: codex_app_server_protocol::DynamicToolCallParams {
thread_id: "thread-1".to_string(),
turn_id: "turn-1".to_string(),
call_id: "call-1".to_string(),
namespace: Some("codex_app".to_string()),
tool: "list_threads".to_string(),
arguments: serde_json::json!({}),
},
},
)),
)
.await;
let AppEvent::DynamicToolCallCompleted { response, .. } = events
.try_recv()
.expect("embedded dynamic calls must receive a response")
else {
panic!("expected a dynamic tool failure response")
};
assert!(!response.success);
app_server.shutdown().await?;
Ok(())
}
#[tokio::test]
async fn dynamic_tool_requests_ignore_other_namespaces_and_dispatch_tui_namespace() -> Result<()> {
use HistoryCapabilities::ConfigReadUnsupported;
use HistoryCapabilities::Current;
use codex_app_server_protocol::AuthMode::ApiKey;
use codex_app_server_protocol::AuthMode::Chatgpt;
for (
rollout_enabled,
auth_mode,
api_key_cyber_access_programs,
history_capabilities,
expected_program,
) in [
(true, Chatgpt, false, Current, Some("daybreakBlue")),
(false, Chatgpt, false, Current, None),
(true, ApiKey, false, Current, None),
(true, ApiKey, true, Current, Some("daybreakBlue")),
(true, Chatgpt, false, ConfigReadUnsupported(-32601), None),
(true, Chatgpt, false, ConfigReadUnsupported(-32600), None),
] {
boxed_future!(check_dynamic_tool_requests(
rollout_enabled,
auth_mode,
api_key_cyber_access_programs,
history_capabilities,
expected_program,
))
.await?;
}
Ok(())
}
async fn check_dynamic_tool_requests(
rollout_enabled: bool,
auth_mode: codex_app_server_protocol::AuthMode,
api_key_cyber_access_programs: bool,
history_capabilities: HistoryCapabilities,
expected_program: Option<&str>,
) -> Result<()> {
let (mut app, mut events, _ops) = make_test_app_with_channels().await;
app.config
.features
.set_enabled(Feature::CliDaybreak, rollout_enabled)?;
let codex_home = tempdir()?;
let backend = wiremock::MockServer::start().await;
let backend_url = format!("{}/backend-api", backend.uri());
let api_url = format!("{}/v1", backend.uri());
app.config.model_provider.base_url = Some(api_url.clone());
app.config.codex_home = codex_home.path().to_path_buf().abs();
app.config.sqlite = SqliteConfig::new_for_testing(codex_home.path().abs());
let mut catalog = codex_models_manager::bundled_models_response()?;
for model in &mut catalog.models {
model.available_access_programs =
Some(codex_protocol::openai_models::ModelAccessPrograms {
cyber: vec![codex_protocol::turn_input::CyberAccessProgram::DaybreakBlue],
});
}
let catalog_path = codex_home.path().join("models.json");
std::fs::write(&catalog_path, serde_json::to_vec(&catalog)?)?;
// The server's target-thread config may differ from the launching TUI's defaults.
std::fs::write(
codex_home.path().join("config.toml"),
format!(
"daybreak = true\nmodel_catalog_json = {:?}\nchatgpt_base_url = {backend_url:?}\ncli_auth_credentials_store = \"file\"\nopenai_base_url = {api_url:?}\nfeatures.cli_daybreak = {rollout_enabled}\nfeatures.api_key_cyber_access_programs = {api_key_cyber_access_programs}\n",
catalog_path.display().to_string()
),
)?;
app.config.chatgpt_base_url = backend_url;
app.config.model_catalog = Some(catalog);
app.config.cli_auth_credentials_store_mode = codex_login::AuthCredentialsStoreMode::File;
app_test_support::write_chatgpt_auth(
codex_home.path(),
app_test_support::ChatGptAuthFixture::new("test-token")
.chatgpt_user_id("test-user")
.plan_type("plus"),
codex_login::AuthCredentialsStoreMode::File,
)
.expect("write fixture auth");
if auth_mode == codex_app_server_protocol::AuthMode::ApiKey {
codex_login::login_with_api_key(
codex_home.path(),
"test-key",
codex_login::AuthCredentialsStoreMode::File,
codex_login::AuthKeyringBackendKind::default(),
)?;
}
app.config
.permissions
.set_permission_profile(PermissionProfile::workspace_write_with(
&[app.config.cwd.clone()],
codex_protocol::permissions::NetworkSandboxPolicy::Restricted,
/*exclude_tmpdir_env_var*/ true,
/*exclude_slash_tmp*/ true,
))?;
let (mut app_server, requests, proxy) = start_recording_app_server_with_history(
&app.config,
history_capabilities,
/*blocked_thread_list*/ None,
/*failed_thread_name*/ Some("Unavailable name"),
crate::app_server_session::ThreadParamsMode::Embedded,
LoaderOverrides::without_managed_config_for_tests(),
)
.await?;
let thread_id = app_server
.start_thread(&app.config)
.await?
.session
.thread_id
.to_string();
for namespace in [Some("codex_app"), None] {
app.handle_app_server_event(
&app_server,
codex_app_server_client::AppServerEvent::ServerRequest(Box::new(
ServerRequest::DynamicToolCall {
request_id: AppServerRequestId::Integer(100),
params: codex_app_server_protocol::DynamicToolCallParams {
thread_id: thread_id.clone(),
turn_id: "turn-1".to_string(),
call_id: "call-1".to_string(),
namespace: namespace.map(str::to_string),
tool: "list_threads".to_string(),
arguments: serde_json::json!({}),
},
},
)),
)
.await;
assert!(events.try_recv().is_err());
}
app.handle_app_server_event(
&app_server,
codex_app_server_client::AppServerEvent::ServerRequest(Box::new(
ServerRequest::DynamicToolCall {
request_id: AppServerRequestId::Integer(101),
params: codex_app_server_protocol::DynamicToolCallParams {
thread_id: thread_id.clone(),
turn_id: "turn-1".to_string(),
call_id: "call-2".to_string(),
namespace: Some("codex_tui".to_string()),
tool: "list_threads".to_string(),
arguments: serde_json::json!({}),
},
},
)),
)
.await;
let event = tokio::time::timeout(std::time::Duration::from_secs(/*secs*/ 5), events.recv())
.await?
.expect("dynamic tool completion event");
let AppEvent::DynamicToolCallCompleted {
request_id,
response,
} = event
else {
panic!("expected a dynamic tool completion event")
};
assert_eq!(request_id, AppServerRequestId::Integer(101));
assert!(response.success, "{response:?}");
let list_requests = recorded_params(&requests, "thread/list");
assert_eq!(list_requests.len(), 1);
assert_eq!(list_requests[0]["useStateDbOnly"], true);
assert_eq!(list_requests[0]["sourceKinds"], serde_json::Value::Null);
let mut tui = crate::tui::test_support::make_test_tui()?;
// Box each dispatcher await so this test does not retain its large future inline.
Box::pin(app.handle_event(
&mut tui,
&mut app_server,
AppEvent::DynamicToolCallCompleted {
request_id,
response,
},
))
.await?;
let completed = tokio::time::timeout(std::time::Duration::from_secs(/*secs*/ 5), async {
loop {
if let Some(response) = recorded_params(&requests, "server/request/response").pop() {
break response;
}
tokio::task::yield_now().await;
}
})
.await?;
assert_eq!(completed["success"], true);
app.handle_app_server_event(
&app_server,
codex_app_server_client::AppServerEvent::ServerRequest(Box::new(
ServerRequest::DynamicToolCall {
request_id: AppServerRequestId::Integer(102),
params: codex_app_server_protocol::DynamicToolCallParams {
thread_id: thread_id.clone(),
turn_id: "turn-1".to_string(),
call_id: "call-3".to_string(),
namespace: Some("codex_tui".to_string()),
tool: "set_thread_title".to_string(),
arguments: serde_json::json!({"threadId": thread_id, "title": "Renamed"}),
},
},
)),
)
.await;
let AppEvent::DynamicToolCallCompleted { response, .. } =
tokio::time::timeout(std::time::Duration::from_secs(/*secs*/ 5), events.recv())
.await?
.expect("dynamic mutation completion event")
else {
panic!("expected a dynamic mutation completion event")
};
assert!(response.success, "{response:?}");
assert_eq!(
recorded_params(&requests, "thread/name/set")[0]["name"],
"Renamed"
);
for (index, tool) in crate::dynamic_tools::DELEGATION_TOOLS
.into_iter()
.enumerate()
{
app.handle_app_server_event(
&app_server,
codex_app_server_client::AppServerEvent::ServerRequest(Box::new(
ServerRequest::DynamicToolCall {
request_id: AppServerRequestId::String(format!("rejected-{index}")),
params: codex_app_server_protocol::DynamicToolCallParams {
thread_id: thread_id.clone(),
turn_id: "turn-1".to_string(),
call_id: format!("rejected-{index}"),
namespace: Some("codex_tui".to_string()),
tool: tool.to_string(),
arguments: serde_json::json!({}),
},
},
)),
)
.await;
let AppEvent::DynamicToolCallCompleted { response, .. } = events
.try_recv()
.expect("legacy delegation call must receive an immediate rejection")
else {
panic!("expected a legacy delegation failure response")
};
assert!(!response.success);
}
let creation_source = create_history_rollout(
&app.config,
ThreadHistoryMode::Legacy,
"Background task source",
)?;
app_server
.resume_thread(
&app.local_settings,
app.config.clone(),
creation_source,
crate::app_server_session::ResumeModelSettings::RestoreFromThread,
)
.await?;
let project: codex_app_server_protocol::ProjectCreateResponse = app_server
.request_handle()
.request_typed(ClientRequest::ProjectCreate {
request_id: AppServerRequestId::String("create-source-project".to_string()),
params: codex_app_server_protocol::ProjectCreateParams {
name: "Source project".to_string(),
roots: vec![codex_app_server_protocol::ProjectRoot {
path: app.config.cwd.clone(),
}],
metadata: None,
idempotency_key: "source-project".to_string(),
},
})
.await?;
let _: codex_app_server_protocol::ThreadMetadataUpdateResponse = app_server
.request_handle()
.request_typed(ClientRequest::ThreadMetadataUpdate {
request_id: AppServerRequestId::String("assign-source-project".to_string()),
params: codex_app_server_protocol::ThreadMetadataUpdateParams {
thread_id: creation_source.to_string(),
project_id: Some(project.project.id.clone()),
daybreak_enabled: Some(false),
git_info: None,
},
})
.await?;
let source_settings: codex_app_server_protocol::ThreadResumeResponse = app_server
.request_handle()
.request_typed(ClientRequest::ThreadResume {
request_id: AppServerRequestId::String("read-source-sandbox".to_string()),
params: codex_app_server_protocol::ThreadResumeParams {
thread_id: creation_source.to_string(),
..codex_app_server_protocol::ThreadResumeParams::default()
},
})
.await?;
let source_sandbox = if source_settings.active_permission_profile.is_some() {
serde_json::Value::Null
} else {
serde_json::to_value(source_settings.sandbox)?
};
spawn_approved_task_tool_call(
&app,
&app_server,
AppServerRequestId::Integer(103),
codex_app_server_protocol::DynamicToolCallParams {
thread_id: creation_source.to_string(),
turn_id: "turn-1".to_string(),
call_id: "call-4".to_string(),
namespace: Some("codex_tui".to_string()),
tool: "create_thread".to_string(),
arguments: serde_json::json!({
"prompt": "Check <main> & report",
"title": "Unavailable name"
}),
},
);
let registration =
tokio::time::timeout(std::time::Duration::from_secs(/*secs*/ 5), events.recv())
.await?
.expect("background task registration event");
let AppEvent::DynamicToolThreadStarted {
thread,
task_tools_available,
registered,
} = registration
else {
panic!("expected background task registration before its first turn: {registration:?}")
};
assert!(recorded_params(&requests, "turn/start").is_empty());
let created_thread_id = ThreadId::from_string(&thread.id)?;
let expected_thread = thread.clone();
Box::pin(app.handle_event(
&mut tui,
&mut app_server,
AppEvent::DynamicToolThreadStarted {
thread,
task_tools_available,
registered,
},
))
.await?;
assert_eq!(
app.agents_overview.threads[&created_thread_id],
Some(expected_thread)
);
assert!(
app.agents_overview
.dispatched_requests
.contains_key(&created_thread_id)
);
assert!(app_server.task_tools_available(created_thread_id));
let AppEvent::DynamicToolCallCompleted { response, .. } =
tokio::time::timeout(std::time::Duration::from_secs(/*secs*/ 5), events.recv())
.await?
.expect("background task creation completion")
else {
panic!("expected a background task completion event")
};
assert!(response.success, "{response:?}");
assert_eq!(
recorded_params(&requests, "thread/start")
.last()
.expect("background task creation")["projectId"],
project.project.id
);
assert_eq!(
recorded_params(&requests, "thread/start").last().unwrap()["daybreakEnabled"],
serde_json::json!(
(rollout_enabled && history_capabilities == HistoryCapabilities::Current)
.then_some(true)
)
);
assert_eq!(
recorded_params(&requests, "thread/start")
.last()
.expect("background task creation")["permissions"],
serde_json::json!(
source_settings
.active_permission_profile
.map(|profile| profile.id)
)
);
let turn = recorded_params(&requests, "turn/start")
.pop()
.expect("background task turn request");
assert_eq!(
turn["cyberAccessProgram"],
serde_json::json!(expected_program)
);
assert_eq!(turn["input"], serde_json::json!([]));
assert_eq!(
turn["toolOutput"],
serde_json::json!({
"name": "create_thread",
"namespace": "codex_tui",
"output": format!(
"<codex_delegation>\n <source_thread_id>{creation_source}</source_thread_id>\n <input>Check <main> & report</input>\n</codex_delegation>"
)
})
);
assert_eq!(turn["sandboxPolicy"], source_sandbox);
app.handle_app_server_event(
&app_server,
codex_app_server_client::AppServerEvent::ServerRequest(Box::new(exec_approval_request(
created_thread_id,
"turn-2",
"item-1",
/*approval_id*/ None,
))),
)
.await;
assert_eq!(
app.agents_overview.dispatched_requests[&created_thread_id].len(),
1
);
let config_path = codex_home.path().join("config.toml");
let config = std::fs::read_to_string(&config_path)?;
std::fs::write(
&config_path,
config.replace("daybreak = true", "daybreak = false"),
)?;
spawn_approved_task_tool_call(
&app,
&app_server,
AppServerRequestId::Integer(104),
codex_app_server_protocol::DynamicToolCallParams {
thread_id: thread_id.clone(),
turn_id: "turn-1".to_string(),
call_id: "call-5".to_string(),
namespace: Some("codex_tui".to_string()),
tool: "send_message_to_thread".to_string(),
arguments: serde_json::json!({
"threadId": created_thread_id,
"prompt": "Follow <up> & report"
}),
},
);
let AppEvent::DynamicToolThreadStarted {
thread,
task_tools_available,
registered,
} = tokio::time::timeout(std::time::Duration::from_secs(/*secs*/ 5), events.recv())
.await?
.expect("follow-up task registration event")
else {
panic!("expected follow-up task registration before its next turn")
};
assert_eq!(ThreadId::from_string(&thread.id)?, created_thread_id);
assert_eq!(recorded_params(&requests, "turn/start").len(), 1);
Box::pin(app.handle_event(
&mut tui,
&mut app_server,
AppEvent::DynamicToolThreadStarted {
thread,
task_tools_available,
registered,
},
))
.await?;
let AppEvent::DynamicToolCallCompleted { response, .. } =
tokio::time::timeout(std::time::Duration::from_secs(/*secs*/ 5), events.recv())
.await?
.expect("follow-up task completion")
else {
panic!("expected a follow-up task completion event")
};
assert!(response.success, "{response:?}");
let turn = &recorded_params(&requests, "turn/start")[1];
assert_eq!(
turn["cyberAccessProgram"],
serde_json::json!(expected_program)
);
assert_eq!(turn["input"], serde_json::json!([]));
assert_eq!(
turn["toolOutput"],
serde_json::json!({
"name": "send_message_to_thread",
"namespace": "codex_tui",
"output": format!(
"<codex_delegation>\n <source_thread_id>{thread_id}</source_thread_id>\n <input>Follow <up> & report</input>\n</codex_delegation>"
)
})
);
app.dynamic_tool_tasks.insert(
AppServerRequestId::Integer(105),
(thread_id, tokio::spawn(std::future::pending::<()>())),
);
assert_matches!(
app.handle_exit_mode(&mut app_server, ExitMode::ShutdownFirst)
.await,
AppRunControl::Exit(ExitReason::UserRequested)
);
let cancelled = tokio::time::timeout(Duration::from_secs(/*secs*/ 5), async {
loop {
if let Some(response) = recorded_params(&requests, "server/request/response")
.into_iter()
.find(|response| response["success"] == false)
{
break response;
}
tokio::task::yield_now().await;
}
})
.await?;
assert_eq!(cancelled["success"], false);
assert!(app.dynamic_tool_tasks.is_empty());
app_server.shutdown().await?;
proxy.await??;
Ok(())
}
#[tokio::test]
async fn older_pagination_reconciles_review_prompts_across_page_boundaries() -> Result<()> {
let (mut app, codex_home) = make_history_test_app().await?;
// The inline scrollback row cap fixes the page boundary around the review marker.
app.local_settings.transcript_mode = crate::transcript_mode::TranscriptMode::Terminal;
app.local_settings.tui.alternate_screen = codex_config::types::AltScreenMode::Never;
app.local_settings.tui.terminal_resize_reflow_max_rows = Some(100);
let thread_id = create_fake_paginated_rollout(
codex_home.path(),
"2026-01-02T00-00-00",
"2026-01-02T00:00:00Z",
"older visible prompt",
Some(app.config.model_provider_id.as_str()),
/*git_info*/ None,
)
.map_err(|error| color_eyre::eyre::eyre!("failed to create paginated rollout: {error}"))?;
let thread_id = ThreadId::from_string(&thread_id)?;
let path = rollout_path(
codex_home.path(),
"2026-01-02T00-00-00",
&thread_id.to_string(),
);
let mut records = std::fs::read_to_string(&path)?
.lines()
.map(serde_json::from_str::<serde_json::Value>)
.collect::<Result<Vec<_>, _>>()?;
let user_item = |id: &str, text: &str| {
TurnItem::UserMessage(UserMessageItem {
id: id.to_string(),
client_id: None,
content: vec![CoreUserInput::Text {
text: text.to_string(),
text_elements: Vec::new(),
}],
})
};
let mut items = vec![
user_item("older-visible-prompt", "older visible prompt"),
TurnItem::EnteredReviewMode(EnteredReviewModeItem {
id: "cross-page-review-start".to_string(),
target: ReviewTarget::UncommittedChanges,
user_facing_hint: "review started".to_string(),
}),
user_item("hidden-review-prompt", "hidden cross-page review prompt"),
];
items.extend((0..97).map(|index| {
TurnItem::AgentMessage(AgentMessageItem {
id: format!("review-output-{index}"),
content: vec![AgentMessageContent::Text {
text: format!("review output {index}"),
}],
phase: None,
memory_citation: None,
delivery: None,
questions: None,
})
}));
items.extend([
TurnItem::ExitedReviewMode(ExitedReviewModeItem {
id: "cross-page-review-end".to_string(),
review_output: None,
}),
user_item("newer-visible-prompt", "newer visible prompt"),
]);
let events = std::iter::once(EventMsg::TurnStarted(TurnStartedEvent {
turn_attribution: None,
turn_id: "cross-page-review-turn".to_string(),
root_turn_id: None,
trace_id: None,
started_at: None,
model_context_window: None,
collaboration_mode_kind: Default::default(),
}))
.chain(items.into_iter().map(|item| {
EventMsg::ItemCompleted(ItemCompletedEvent {
thread_id,
turn_id: "cross-page-review-turn".to_string(),
item,
started_at_ms: None,
completed_at_ms: 0,
})
}));
for event in events {
records.push(serde_json::json!({
"timestamp": "2026-01-02T00:00:00Z",
"ordinal": records.len(),
"type": "event_msg",
"payload": serde_json::to_value(event)?,
}));
}
let records = records
.into_iter()
.map(|record| record.to_string())
.collect::<Vec<_>>()
.join("\n");
std::fs::write(path, format!("{records}\n"))?;
let (mut app_server, _requests, proxy) = start_recording_app_server(
&app.config,
/*blocked_thread_list*/ None,
/*failed_thread_name*/ None,
)
.await?;
let started = app_server
.resume_thread(
&app.local_settings,
app.config.clone(),
thread_id,
crate::app_server_session::ResumeModelSettings::RestoreFromThread,
)
.await?;
let initial_cells = crate::thread_transcript::thread_items_to_transcript_cells(
Some(thread_id),
&app.config.cwd,
started.turns.iter().flat_map(|turn| turn.items.clone()),
crate::thread_transcript::RawReasoningVisibility::Hidden,
Some(&app.config),
);
app.enqueue_primary_thread_session(started.session, started.turns)
.await?;
app.transcript_cells = initial_cells;
assert_eq!(
app.transcript_cells
.iter()
.filter_map(|cell| cell.as_any().downcast_ref::<UserHistoryCell>())
.map(|user| user.message.as_str())
.collect::<Vec<_>>(),
vec!["hidden cross-page review prompt", "newer visible prompt"]
);
app.backtrack.overlay_preview_active = true;
app.backtrack.nth_user_message = 1;
let mut tui = crate::tui::test_support::make_test_tui()?;
app.open_transcript_overlay(&mut tui);
app.apply_backtrack_selection_internal(app.backtrack.nth_user_message);
let cursor = app_server
.begin_older_history_page(thread_id)
.expect("review-mode marker should remain on an older page");
let request_id = app_server.next_request_id();
let page: ThreadItemsListResponse = app_server
.request_handle()
.request_typed(ClientRequest::ThreadItemsList {
request_id,
params: ThreadItemsListParams {
thread_id: thread_id.to_string(),
turn_id: None,
cursor: Some(ThreadItemsListCursor::Opaque(cursor.clone())),
limit: Some(crate::app_server_session::HISTORY_ITEM_PAGE_LIMIT),
sort_direction: Some(SortDirection::Desc),
},
})
.await?;
app.handle_older_history_page(&mut tui, &mut app_server, thread_id, &cursor, Ok(page))
.await?;
let visible_user_messages = app
.transcript_cells
.iter()
.filter_map(|cell| cell.as_any().downcast_ref::<UserHistoryCell>())
.map(|user| user.message.clone())
.collect::<Vec<_>>();
assert_eq!(
visible_user_messages,
vec!["older visible prompt", "newer visible prompt"]
);
assert_eq!(app.backtrack.nth_user_message, 1);
let area = ratatui::layout::Rect::new(
/*x*/ 0, /*y*/ 0, /*width*/ 80, /*height*/ 12,
);
let mut buffer = Buffer::empty(area);
let Some(Overlay::Transcript(overlay)) = app.overlay.as_mut() else {
panic!("expected a transcript overlay");
};
overlay.render(area, &mut buffer);
let highlighted_output = area
.positions()
.filter(|position| {
buffer[*position]
.style()
.add_modifier
.contains(ratatui::style::Modifier::REVERSED)
})
.map(|position| buffer[position].symbol())
.collect::<String>();
let highlighted_message = visible_user_messages
.iter()
.find(|message| highlighted_output.contains(message.as_str()))
.expect("the selected user message should remain highlighted");
insta::assert_snapshot!(
format!(
"{}\nhighlighted: {highlighted_message}",
visible_user_messages.join("\n")
),
@r"
older visible prompt
newer visible prompt
highlighted: newer visible prompt
");
app_server.shutdown().await?;
proxy.await??;
Ok(())
}
#[tokio::test]
async fn transcript_alt_beginning_loads_every_older_history_page() -> Result<()> {
let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await;
let codex_home = tempdir()?;
app.config.codex_home = codex_home.path().to_path_buf().abs();
app.config.sqlite = SqliteConfig::new_for_testing(codex_home.path().abs());
app.local_settings.tui.terminal_resize_reflow_max_rows = Some(2);
let thread_id = create_fake_paginated_rollout(
codex_home.path(),
"2026-01-02T00-00-00",
"2026-01-02T00:00:00Z",
"multi-page transcript",
Some(app.config.model_provider_id.as_str()),
/*git_info*/ None,
)
.map_err(|error| color_eyre::eyre::eyre!("failed to create paginated rollout: {error}"))?;
let thread_id = ThreadId::from_string(&thread_id)?;
let path = rollout_path(
codex_home.path(),
"2026-01-02T00-00-00",
&thread_id.to_string(),
);
let mut records = std::fs::read_to_string(&path)?
.lines()
.map(serde_json::from_str::<serde_json::Value>)
.collect::<Result<Vec<_>, _>>()?;
let events = std::iter::once(EventMsg::TurnStarted(TurnStartedEvent {
turn_attribution: None,
turn_id: "multi-page-turn".to_string(),
root_turn_id: None,
trace_id: None,
started_at: None,
model_context_window: None,
collaboration_mode_kind: Default::default(),
}))
.chain((0..305).map(|index| {
EventMsg::ItemCompleted(ItemCompletedEvent {
thread_id,
turn_id: "multi-page-turn".to_string(),
item: TurnItem::AgentMessage(AgentMessageItem {
id: format!("history-item-{index}"),
content: vec![AgentMessageContent::Text {
text: format!("history output {index}"),
}],
phase: None,
memory_citation: None,
delivery: None,
questions: None,
}),
started_at_ms: None,
completed_at_ms: 0,
})
}));
for event in events {
records.push(serde_json::json!({
"timestamp": "2026-01-02T00:00:00Z",
"ordinal": records.len(),
"type": "event_msg",
"payload": serde_json::to_value(event)?,
}));
}
let records = records
.into_iter()
.map(|record| record.to_string())
.collect::<Vec<_>>()
.join("\n");
std::fs::write(path, format!("{records}\n"))?;
let (mut app_server, requests, proxy) = start_recording_app_server(
&app.config,
/*blocked_thread_list*/ None,
/*failed_thread_name*/ None,
)
.await?;
let started = app_server
.resume_thread(
&app.local_settings,
app.config.clone(),
thread_id,
crate::app_server_session::ResumeModelSettings::RestoreFromThread,
)
.await?;
let initial_cells = crate::thread_transcript::thread_items_to_transcript_cells(
Some(thread_id),
&app.config.cwd,
started.turns.iter().flat_map(|turn| turn.items.clone()),
crate::thread_transcript::RawReasoningVisibility::Hidden,
Some(&app.config),
);
app.enqueue_primary_thread_session(started.session, started.turns)
.await?;
app.transcript_cells = initial_cells;
while app_event_rx.try_recv().is_ok() {}
let initial_turn_requests = recorded_params(&requests, "thread/turns/list").len();
let initial_item_requests = recorded_params(&requests, "thread/items/list").len();
let export_path = codex_home.path().join("complete-export.md");
app.chat_widget
.set_queue_autosend_suppressed(/*suppressed*/ true);
app.chat_widget.insert_str("queued after export");
app.chat_widget
.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
let mut tui = crate::tui::test_support::make_test_tui()?;
// Keep the large dispatcher future off the Windows test thread's stack.
Box::pin(app.handle_event(
&mut tui,
&mut app_server,
AppEvent::ExportTranscript {
destination: TranscriptExportDestination::File(export_path.clone()),
},
))
.await?;
assert!(app.chat_widget.queued_user_message_texts().is_empty());
let markdown = std::fs::read_to_string(export_path)?;
assert!(
(0..305)
.map(|index| format!("history output {index}"))
.eq(markdown.lines().filter(|line| line.starts_with("history")))
);
assert!(
recorded_params(&requests, "thread/turns/list")[initial_turn_requests..]
.iter()
.all(|params| params["itemsView"] == "notLoaded")
);
assert!(
recorded_params(&requests, "thread/items/list")[initial_item_requests..]
.iter()
.all(|params| {
params["limit"] == crate::app_server_session::HISTORY_ITEM_PAGE_LIMIT
})
);
app.scrollback_has_older_history = app_server.has_older_history(thread_id);
assert!(app.scrollback_has_older_history);
while app_event_rx.try_recv().is_ok() {}
let initial_page_requests = recorded_params(&requests, "thread/items/list").len();
app.open_transcript_overlay(&mut tui);
app.handle_backtrack_overlay_event(
&mut tui,
&mut app_server,
TuiEvent::Key(KeyEvent::new(KeyCode::Char('<'), KeyModifiers::ALT)),
)
.await?;
while app_server.has_older_history(thread_id) {
let event = tokio::time::timeout(Duration::from_secs(5), app_event_rx.recv())
.await?
.ok_or_else(|| color_eyre::eyre::eyre!("history event channel closed"))?;
if matches!(event, AppEvent::OlderThreadHistoryLoaded { .. }) {
Box::pin(app.handle_event(&mut tui, &mut app_server, event)).await?;
}
}
assert!(recorded_params(&requests, "thread/items/list").len() >= initial_page_requests + 3);
assert!(app.transcript_cells.iter().any(|cell| {
cell.display_lines(/*width*/ 80)
.iter()
.any(|line| line.to_string().contains("history output 0"))
}));
let Some(Overlay::Transcript(overlay)) = app.overlay.as_mut() else {
panic!("expected transcript overlay after beginning navigation");
};
let area = Rect::new(
/*x*/ 0, /*y*/ 0, /*width*/ 80, /*height*/ 12,
);
let mut buffer = Buffer::empty(area);
overlay.render(area, &mut buffer);
let visible = (area.y..area.bottom())
.map(|y| {
(area.x..area.right())
.map(|x| buffer[(x, y)].symbol())
.collect::<String>()
})
.collect::<Vec<_>>()
.join("\n");
assert!(visible.contains("history output 0"), "{visible}");
assert!(!visible.contains("history output 304"), "{visible}");
app_server.shutdown().await?;
proxy.await??;
Ok(())
}
#[tokio::test]
async fn remote_legacy_history_start_negotiates_once_for_resume_and_fork() -> Result<()> {
let (app, _codex_home) = make_history_test_app().await?;
let legacy_thread_id =
create_history_rollout(&app.config, ThreadHistoryMode::Legacy, "legacy history")?;
let paginated_thread_id = create_history_rollout(
&app.config,
ThreadHistoryMode::Paginated,
"paginated history",
)?;
let (mut app_server, requests, proxy) = start_recording_app_server_with_history(
&app.config,
HistoryCapabilities::LegacyOnly,
/*blocked_thread_list*/ None,
/*failed_thread_name*/ None,
crate::app_server_session::ThreadParamsMode::Embedded,
LoaderOverrides::default(),
)
.await?;
let started = app_server.start_thread(&app.config).await?;
let resumed = app_server
.resume_thread(
&app.local_settings,
app.config.clone(),
legacy_thread_id,
crate::app_server_session::ResumeModelSettings::RestoreFromThread,
)
.await?;
let forked = app_server
.fork_thread(&app.local_settings, app.config.clone(), legacy_thread_id)
.await?;
assert_ne!(started.session.thread_id, legacy_thread_id);
assert_eq!(resumed.session.thread_id, legacy_thread_id);
assert_ne!(forked.session.thread_id, legacy_thread_id);
let starts = recorded_params(&requests, "thread/start");
assert_eq!(starts.len(), 2);
assert_eq!(starts[0]["historyMode"], "paginated");
assert_eq!(starts[1]["historyMode"], serde_json::Value::Null);
for method in ["thread/resume", "thread/fork"] {
let params = recorded_params(&requests, method);
assert_eq!(params.len(), 1, "legacy {method} must not be reprobed");
assert_ne!(params[0]["excludeTurns"], true);
}
assert!(recorded_params(&requests, "thread/turns/list").is_empty());
assert!(recorded_params(&requests, "thread/items/list").is_empty());
let initial_read_count = recorded_params(&requests, "thread/read").len();
let exported = crate::app::transcript_export::load_export_transcript(
&mut app_server,
paginated_thread_id,
crate::thread_transcript::RawReasoningVisibility::Hidden,
Some(&app.config),
vec![Arc::new(PlainHistoryCell::new(vec!["visible".into()]))],
)
.await
.map_err(|error| color_eyre::eyre::eyre!(error))?;
assert_eq!(exported[0].raw_lines()[0].to_string(), "visible");
assert!(
recorded_params(&requests, "thread/read")[initial_read_count..]
.iter()
.any(|params| params["includeTurns"] == true)
);
assert_eq!(recorded_params(&requests, "thread/turns/list").len(), 1);
let (_status_sender, status_updates) = tokio::sync::broadcast::channel(/*capacity*/ 1);
let response = crate::dynamic_tools::execute(
app_server.request_handle(),
codex_app_server_protocol::DynamicToolCallParams {
thread_id: started.session.thread_id.to_string(),
turn_id: "source-turn".to_string(),
call_id: "legacy-wait".to_string(),
namespace: Some(crate::dynamic_tools::NAMESPACE.to_string()),
tool: "wait_threads".to_string(),
arguments: serde_json::json!({
"targets": [{"threadId": legacy_thread_id}],
"timeoutMs": 0
}),
},
codex_app_server_protocol::ThreadStartParams::default(),
app.config.features.get().clone(),
status_updates,
/*app_event_tx*/ None,
)
.await;
assert!(response.success, "{response:?}");
assert!(
recorded_params(&requests, "thread/read")
.iter()
.any(|params| {
params["threadId"] == legacy_thread_id.to_string() && params["includeTurns"] == true
})
);
app_server.shutdown().await?;
proxy.await??;
Ok(())
}
#[tokio::test]
async fn remote_legacy_history_start_retries_unsupported_paginated_variant() -> Result<()> {
let (app, _codex_home) = make_history_test_app().await?;
let (mut app_server, requests, proxy) = start_recording_app_server_with_history(
&app.config,
HistoryCapabilities::LegacyOnlyUnsupportedVariant,
/*blocked_thread_list*/ None,
/*failed_thread_name*/ None,
crate::app_server_session::ThreadParamsMode::Embedded,
LoaderOverrides::default(),
)
.await?;
app_server.start_thread(&app.config).await?;
let starts = recorded_params(&requests, "thread/start");
assert_eq!(starts.len(), 2);
assert_eq!(starts[0]["historyMode"], "paginated");
assert_eq!(starts[1]["historyMode"], serde_json::Value::Null);
app_server.shutdown().await?;
proxy.await??;
Ok(())
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum LegacyHistoryRequest {
Resume,
Fork,
}
async fn assert_remote_legacy_history_retry(request: LegacyHistoryRequest) -> Result<()> {
let (app, _codex_home) = make_history_test_app().await?;
let legacy_thread_id =
create_history_rollout(&app.config, ThreadHistoryMode::Legacy, "legacy history")?;
let (mut app_server, requests, proxy) = start_recording_app_server_with_history(
&app.config,
HistoryCapabilities::LegacyOnly,
/*blocked_thread_list*/ None,
/*failed_thread_name*/ None,
crate::app_server_session::ThreadParamsMode::Embedded,
LoaderOverrides::default(),
)
.await?;
let method = match request {
LegacyHistoryRequest::Resume => {
let resumed = app_server
.resume_thread(
&app.local_settings,
app.config.clone(),
legacy_thread_id,
crate::app_server_session::ResumeModelSettings::RestoreFromThread,
)
.await?;
assert_eq!(resumed.session.thread_id, legacy_thread_id);
"thread/resume"
}
LegacyHistoryRequest::Fork => {
let forked = app_server
.fork_thread(&app.local_settings, app.config.clone(), legacy_thread_id)
.await?;
assert_ne!(forked.session.thread_id, legacy_thread_id);
"thread/fork"
}
};
let attempts = recorded_params(&requests, method);
if request == LegacyHistoryRequest::Resume {
assert_eq!(attempts.len(), 2);
assert_eq!(attempts[0]["excludeTurns"], true);
} else {
assert_eq!(attempts.len(), 1);
}
assert_ne!(
attempts.last().expect("history request")["excludeTurns"],
true
);
assert!(recorded_params(&requests, "thread/turns/list").is_empty());
assert!(recorded_params(&requests, "thread/items/list").is_empty());
app_server.shutdown().await?;
proxy.await??;
Ok(())
}
#[tokio::test]
async fn remote_legacy_history_resume_retries_generic_method_not_found() -> Result<()> {
Box::pin(assert_remote_legacy_history_retry(
LegacyHistoryRequest::Resume,
))
.await
}
#[tokio::test]
async fn remote_legacy_history_fork_avoids_unsupported_fields() -> Result<()> {
assert_remote_legacy_history_retry(LegacyHistoryRequest::Fork).await
}
#[tokio::test]
async fn paginated_fork_survives_post_response_hydration_failure() -> Result<()> {
let (app, _codex_home) = Box::pin(make_history_test_app()).await?;
let parent_thread_id = create_history_rollout(
&app.config,
ThreadHistoryMode::Paginated,
"paginated fork parent",
)?;
let (mut app_server, requests, proxy) = start_recording_app_server_with_history(
&app.config,
HistoryCapabilities::ForkHydrationFails,
/*blocked_thread_list*/ None,
/*failed_thread_name*/ None,
crate::app_server_session::ThreadParamsMode::Embedded,
LoaderOverrides::default(),
)
.await?;
let started = Box::pin(app_server.resume_thread(
&app.local_settings,
app.config.clone(),
parent_thread_id,
crate::app_server_session::ResumeModelSettings::RestoreFromThread,
))
.await?;
assert_eq!(started.session.thread_id, parent_thread_id);
let forked =
Box::pin(app_server.fork_thread(&app.local_settings, app.config.clone(), parent_thread_id))
.await?;
assert_ne!(forked.session.thread_id, parent_thread_id);
assert_eq!(recorded_params(&requests, "thread/fork").len(), 1);
app_server.shutdown().await?;
proxy.await??;
Ok(())
}
#[tokio::test]
async fn underfilled_scrollback_fetches_older_pages_without_opening_the_transcript() -> Result<()> {
let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await;
let codex_home = tempdir()?;
app.config.codex_home = codex_home.path().to_path_buf().abs();
app.config.sqlite = SqliteConfig::new_for_testing(codex_home.path().abs());
// Keep initial hydration within the inline scrollback budget so refill has work to do.
app.local_settings.transcript_mode = crate::transcript_mode::TranscriptMode::Terminal;
app.local_settings.tui.alternate_screen = codex_config::types::AltScreenMode::Never;
app.local_settings.tui.terminal_resize_reflow_max_rows = Some(8);
let thread_id = create_history_rollout(
&app.config,
ThreadHistoryMode::Paginated,
"scrollback pagination",
)?;
let path = rollout_path(
codex_home.path(),
"2026-01-02T00-00-00",
&thread_id.to_string(),
);
let mut records = std::fs::read_to_string(&path)?
.lines()
.map(serde_json::from_str::<serde_json::Value>)
.collect::<Result<Vec<_>, _>>()?;
let events = std::iter::once(EventMsg::TurnStarted(TurnStartedEvent {
turn_attribution: None,
turn_id: "scrollback-pagination-turn".to_string(),
root_turn_id: None,
trace_id: None,
started_at: None,
model_context_window: None,
collaboration_mode_kind: Default::default(),
}))
.chain((0..120).map(|index| {
EventMsg::ItemCompleted(ItemCompletedEvent {
thread_id,
turn_id: "scrollback-pagination-turn".to_string(),
item: TurnItem::AgentMessage(AgentMessageItem {
id: format!("scrollback-item-{index}"),
content: vec![AgentMessageContent::Text {
text: format!("scrollback output {index}"),
}],
phase: None,
memory_citation: None,
delivery: None,
questions: None,
}),
started_at_ms: None,
completed_at_ms: 0,
})
}));
for event in events {
records.push(serde_json::json!({
"timestamp": "2026-01-02T00:00:00Z",
"ordinal": records.len(),
"type": "event_msg",
"payload": serde_json::to_value(event)?,
}));
}
let records = records
.into_iter()
.map(|record| record.to_string())
.collect::<Vec<_>>()
.join("\n");
std::fs::write(path, format!("{records}\n"))?;
let (mut app_server, requests, proxy) = start_recording_app_server(
&app.config,
/*blocked_thread_list*/ None,
/*failed_thread_name*/ None,
)
.await?;
let started = app_server
.resume_thread(
&app.local_settings,
app.config.clone(),
thread_id,
crate::app_server_session::ResumeModelSettings::RestoreFromThread,
)
.await?;
let mut initial_cells = crate::thread_transcript::thread_items_to_transcript_cells(
Some(thread_id),
&app.config.cwd,
started.turns.iter().flat_map(|turn| turn.items.clone()),
crate::thread_transcript::RawReasoningVisibility::Hidden,
Some(&app.config),
);
initial_cells.insert(
/*index*/ 0,
Arc::new(crate::history_cell::new_session_info(
&app.config,
&app.local_settings,
started.session.model.as_str(),
started.session.model.as_str(),
&started.session,
/*is_first_event*/ false,
Some("This is a test announcement".to_string()),
/*auth_plan*/ None,
)),
);
app.enqueue_primary_thread_session(started.session, started.turns)
.await?;
app.transcript_cells = initial_cells;
app.scrollback_has_older_history = app_server.has_older_history(thread_id);
app.local_settings.tui.terminal_resize_reflow_max_rows = Some(32);
let initial_cell_count = app.transcript_cells.len();
let initial_page_requests = recorded_params(&requests, "thread/items/list").len();
let mut tui = crate::tui::test_support::make_test_tui()?;
app.scrollback_has_older_history = false;
app.handle_key_event(
&mut tui,
&mut app_server,
KeyEvent::new(KeyCode::Char('t'), KeyModifiers::CONTROL),
)
.await;
assert!(app.scrollback_has_older_history);
if let Some(Overlay::Transcript(overlay)) = app.overlay.as_mut() {
let area = Rect::new(
/*x*/ 0, /*y*/ 0, /*width*/ 100, /*height*/ 16,
);
let render_overlay = |overlay: &mut crate::pager_overlay::TranscriptOverlay| {
let mut buffer = Buffer::empty(area);
overlay.render(area, &mut buffer);
(area.y..area.bottom())
.map(|y| {
(area.x..area.right())
.map(|x| buffer[(x, y)].symbol())
.collect::<String>()
})
.collect::<Vec<_>>()
.join("\n")
};
// Inspect the loaded start without Home, which now requests all older pages.
render_overlay(overlay);
overlay.set_highlight_cell(Some(0));
let partial = render_overlay(overlay);
assert!(partial.contains("Earlier messages available."));
assert!(!partial.contains("OpenAI Codex"));
assert!(!partial.contains("This is a test announcement"));
assert!(!partial.contains('%'));
overlay.handle_event(
&mut tui,
TuiEvent::Key(KeyEvent::new(KeyCode::Home, KeyModifiers::NONE)),
)?;
let loading = render_overlay(overlay);
assert!(loading.contains("Loading earlier messages…"));
assert!(!loading.contains("OpenAI Codex"));
assert!(!loading.contains('%'));
} else {
panic!("expected transcript overlay");
}
app.close_transcript_overlay(&mut tui);
let terminal_width = tui.terminal.last_known_screen_size.into();
app.reflow_transcript_now(&mut tui, terminal_width)?;
let request = loop {
match app_event_rx.recv().await {
Some(event @ AppEvent::RequestOlderScrollbackHistory { .. }) => break event,
Some(_) => {}
None => panic!("scrollback refill request channel closed"),
}
};
// Keep the large dispatcher future off the Windows test thread's stack.
Box::pin(app.handle_event(&mut tui, &mut app_server, request)).await?;
let loaded = loop {
match app_event_rx.recv().await {
Some(event @ AppEvent::OlderThreadHistoryLoaded { .. }) => break event,
Some(_) => {}
None => panic!("older history page channel closed"),
}
};
Box::pin(app.handle_event(&mut tui, &mut app_server, loaded)).await?;
assert!(app.overlay.is_none());
assert!(app.transcript_cells.len() > initial_cell_count);
assert_eq!(
recorded_params(&requests, "thread/items/list").len(),
initial_page_requests + 1
);
assert_eq!(
app.render_transcript_lines_for_reflow(/*width*/ 80)
.lines
.len(),
32
);
app_server.shutdown().await?;
proxy.await??;
Ok(())
}
#[tokio::test]
async fn paginated_workflows_never_request_full_thread_history() -> Result<()> {
let (app, _codex_home) = make_history_test_app().await?;
let paginated_thread_id = create_history_rollout(
&app.config,
ThreadHistoryMode::Paginated,
"paginated visible history",
)?;
let legacy_thread_id = create_history_rollout(
&app.config,
ThreadHistoryMode::Legacy,
"legacy visible history",
)?;
let (mut app_server, requests, proxy) = start_recording_app_server(
&app.config,
/*blocked_thread_list*/ None,
/*failed_thread_name*/ None,
)
.await?;
app_server.remember_thread_history_mode(paginated_thread_id, ThreadHistoryMode::Legacy);
let resumed = Box::pin(app_server.resume_thread(
&app.local_settings,
app.config.clone(),
paginated_thread_id,
crate::app_server_session::ResumeModelSettings::RestoreFromThread,
))
.await?;
assert_eq!(resumed.session.thread_id, paginated_thread_id);
assert!(recorded_params(&requests, "thread/read").is_empty());
let resume_requests = recorded_params(&requests, "thread/resume");
assert_eq!(resume_requests.len(), 1);
assert_eq!(resume_requests[0]["excludeTurns"], true);
let cells = crate::thread_transcript::load_session_transcript(
&mut app_server,
paginated_thread_id,
crate::thread_transcript::RawReasoningVisibility::Hidden,
Some(&app.config),
)
.await?;
assert!(!cells.is_empty());
Box::pin(app_server.fork_thread(&app.local_settings, app.config.clone(), paginated_thread_id))
.await?;
let mut side_config = app.config.clone();
side_config.ephemeral = true;
Box::pin(app_server.fork_side_thread(
&crate::local_settings::LocalSettings::from(&side_config),
side_config,
paginated_thread_id,
/*selected_profile*/ None,
))
.await?;
let paginated_reads = recorded_params(&requests, "thread/read");
assert!(!paginated_reads.is_empty());
assert!(
paginated_reads
.iter()
.all(|params| params["includeTurns"] != true),
"paginated workflows requested full history: {paginated_reads:?}"
);
assert!(!recorded_params(&requests, "thread/turns/list").is_empty());
assert!(!recorded_params(&requests, "thread/items/list").is_empty());
let previous_read_count = paginated_reads.len();
let preview = crate::resume_picker::load_transcript_preview(
&mut app_server,
legacy_thread_id,
Some(&app.config),
)
.await?;
assert!(!preview.is_empty());
let preview_reads = recorded_params(&requests, "thread/read");
let preview_include_turns = preview_reads[previous_read_count..]
.iter()
.map(|params| params["includeTurns"].as_bool().unwrap_or(false))
.collect::<Vec<_>>();
assert_eq!(preview_include_turns, vec![false]);
let previous_read_count = preview_reads.len();
crate::thread_transcript::load_session_transcript(
&mut app_server,
legacy_thread_id,
crate::thread_transcript::RawReasoningVisibility::Hidden,
Some(&app.config),
)
.await?;
let legacy_reads = recorded_params(&requests, "thread/read");
let legacy_include_turns = legacy_reads[previous_read_count..]
.iter()
.map(|params| params["includeTurns"].as_bool().unwrap_or(false))
.collect::<Vec<_>>();
assert_eq!(legacy_include_turns, vec![false, true]);
app_server.shutdown().await?;
proxy.await??;
Ok(())
}
#[tokio::test]
async fn agents_overview_stop_uses_history_mode_for_turn_lookup() -> Result<()> {
let (mut app, _codex_home) = make_history_test_app().await?;
let paginated_thread_id = create_history_rollout(
&app.config,
ThreadHistoryMode::Paginated,
"paginated background task",
)?;
let cases = [
(paginated_thread_id, vec![false], 1),
(
create_history_rollout(
&app.config,
ThreadHistoryMode::Legacy,
"legacy background task",
)?,
vec![false, true],
0,
),
];
let (mut app_server, requests, proxy) = start_recording_app_server_with_history(
&app.config,
HistoryCapabilities::Current,
/*blocked_thread_list*/ None,
/*failed_thread_name*/ None,
crate::app_server_session::ThreadParamsMode::Embedded,
LoaderOverrides::default(),
)
.await?;
for (thread_id, expected_include_turns, expected_turn_page_count) in cases {
let previous_reads = recorded_params(&requests, "thread/read");
let previous_turn_page_count = recorded_params(&requests, "thread/turns/list").len();
app.stop_agents_overview_thread(&mut app_server, thread_id)
.await;
let reads = recorded_params(&requests, "thread/read");
let include_turns = reads[previous_reads.len()..]
.iter()
.map(|params| params["includeTurns"].as_bool().unwrap_or(false))
.collect::<Vec<_>>();
assert_eq!(include_turns, expected_include_turns);
assert_eq!(
recorded_params(&requests, "thread/turns/list").len() - previous_turn_page_count,
expected_turn_page_count
);
}
app_server.shutdown().await?;
proxy.await??;
Ok(())
}
#[tokio::test]
async fn agents_overview_seeds_loaded_threads_when_recent_listing_is_unavailable() -> Result<()> {
for (capabilities, expected_sort_keys) in [
(
HistoryCapabilities::LegacyOnly,
vec!["recency_at", "recency_at", "updated_at", "updated_at"],
),
(
HistoryCapabilities::ThreadListFails,
vec!["recency_at", "recency_at"],
),
] {
let (mut app, _codex_home) = make_history_test_app().await?;
let (mut app_server, requests, proxy) = start_recording_app_server_with_history(
&app.config,
capabilities,
/*blocked_thread_list*/ None,
/*failed_thread_name*/ None,
crate::app_server_session::ThreadParamsMode::Embedded,
LoaderOverrides::default(),
)
.await?;
let started = app_server.start_thread(&app.config).await?;
app.app_server_target = AppServerTarget::LocalDaemon {
allow_embedded_fallback: true,
endpoint: crate::RemoteAppServerEndpoint::UnixSocket {
socket_path: test_path_buf("/tmp/unused.sock").abs(),
},
};
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
app.app_event_tx = AppEventSender::new(tx);
for attempt in 0..2 {
if attempt == 0 {
app.refresh_agents_overview_threads(&app_server);
} else {
app.open_agents_overview(&app_server);
}
let Some(AppEvent::AgentsOverviewThreadsLoaded { request_id, result }) =
tokio::time::timeout(Duration::from_secs(10), rx.recv()).await?
else {
panic!("expected overview result")
};
app.apply_agents_overview_thread_refresh(&app_server, request_id, result);
assert_eq!(
app.agents_overview
.threads
.keys()
.copied()
.collect::<Vec<_>>(),
vec![started.session.thread_id]
);
assert!(app.agents_overview.initialized);
assert_eq!(
app.agents_overview.discovery.has_more(),
capabilities == HistoryCapabilities::ThreadListFails
);
if attempt == 0 {
app.handle_app_server_event(
&app_server,
AppServerEvent::ServerNotification(Box::new(
ServerNotification::ThreadStatusChanged(
codex_app_server_protocol::ThreadStatusChangedNotification {
thread_id: started.session.thread_id.to_string(),
status: codex_app_server_protocol::ThreadStatus::Idle,
},
),
)),
)
.await;
assert!(app.agents_overview.request_id.is_none());
}
}
let list_requests = recorded_params(&requests, "thread/list");
let mut sort_keys = list_requests
.iter()
.map(|params| params["sortKey"].as_str().unwrap())
.filter(|sort_key| *sort_key != "section_position")
.collect::<Vec<_>>();
sort_keys.sort_unstable();
assert_eq!(sort_keys, expected_sort_keys);
app_server.shutdown().await?;
proxy.await??;
}
Ok(())
}
#[tokio::test]
async fn agents_overview_stop_uses_full_history_after_legacy_negotiation() -> Result<()> {
let (mut app, _codex_home) = make_history_test_app().await?;
let thread_id = create_history_rollout(
&app.config,
ThreadHistoryMode::Paginated,
"paginated background task",
)?;
let (mut app_server, requests, proxy) = start_recording_app_server_with_history(
&app.config,
HistoryCapabilities::LegacyOnly,
/*blocked_thread_list*/ None,
/*failed_thread_name*/ None,
crate::app_server_session::ThreadParamsMode::Embedded,
LoaderOverrides::default(),
)
.await?;
app_server.start_thread(&app.config).await?;
app.stop_agents_overview_thread(&mut app_server, thread_id)
.await;
let include_turns = recorded_params(&requests, "thread/read")
.into_iter()
.map(|params| params["includeTurns"].as_bool().unwrap_or(false))
.collect::<Vec<_>>();
assert_eq!(include_turns, vec![false, true]);
assert!(recorded_params(&requests, "thread/turns/list").is_empty());
app_server.shutdown().await?;
proxy.await??;
Ok(())
}
#[tokio::test]
async fn cold_paginated_subagent_transcript_excludes_inherited_parent_history() -> Result<()> {
let (app, codex_home) = make_history_test_app().await?;
let parent_thread_id = create_history_rollout(
&app.config,
ThreadHistoryMode::Paginated,
"parent-only paginated history",
)?;
let child_timestamp = "2026-01-02T00-00-01";
let child_thread_id = ThreadId::from_string(
&create_fake_parented_rollout_with_source(
codex_home.path(),
child_timestamp,
"2026-01-02T00:00:01Z",
"child-only paginated history",
Some(app.config.model_provider_id.as_str()),
/*git_info*/ None,
RolloutSessionSource::SubAgent(SubAgentSource::ThreadSpawn {
parent_thread_id,
depth: 1,
agent_path: Some(
AgentPath::try_from("/root/worker").map_err(color_eyre::eyre::Report::msg)?,
),
agent_nickname: Some("worker".to_string()),
agent_role: Some("worker".to_string()),
}),
parent_thread_id.into(),
parent_thread_id,
)
.map_err(|err| color_eyre::eyre::eyre!("failed to create subagent rollout: {err}"))?,
)?;
let child_rollout_path = rollout_path(
codex_home.path(),
child_timestamp,
&child_thread_id.to_string(),
);
let mut child_lines = std::fs::read_to_string(&child_rollout_path)?
.lines()
.map(serde_json::from_str::<serde_json::Value>)
.collect::<Result<Vec<_>, _>>()?;
let mut meta = child_lines.remove(/*index*/ 0);
meta["payload"]["history_mode"] = serde_json::json!("paginated");
meta["payload"]["subagent_history_start_ordinal"] = serde_json::json!(3);
meta["ordinal"] = serde_json::json!(0);
for (index, line) in child_lines.iter_mut().enumerate() {
line["ordinal"] = serde_json::json!(index + 3);
}
let rollout_record = |ordinal: usize, kind: &str, payload: serde_json::Value| {
serde_json::json!({
"timestamp": "2026-01-02T00:00:01Z",
"ordinal": ordinal,
"type": kind,
"payload": payload,
})
};
let inherited_response = rollout_record(
/*ordinal*/ 1,
"response_item",
serde_json::json!({
"type": "message",
"role": "user",
"content": [{
"type": "input_text",
"text": "parent-only paginated history",
}],
}),
);
let inherited_event = rollout_record(
/*ordinal*/ 2,
"event_msg",
serde_json::json!({
"type": "user_message",
"message": "parent-only paginated history",
"kind": "plain",
}),
);
let lines = std::iter::once(meta)
.chain([inherited_response, inherited_event])
.chain(child_lines)
.chain([
rollout_record(
/*ordinal*/ 5,
"event_msg",
serde_json::json!({
"type": "task_started",
"turn_id": "child-visible-turn",
"model_context_window": null,
}),
),
rollout_record(
/*ordinal*/ 6,
"event_msg",
serde_json::json!({
"type": "item_completed",
"thread_id": child_thread_id,
"turn_id": "child-visible-turn",
"item": {
"type": "UserMessage",
"id": "child-visible-user",
"content": [{
"type": "text",
"text": "child-only paginated history",
}],
},
}),
),
])
.map(|line| line.to_string())
.collect::<Vec<_>>()
.join("\n");
std::fs::write(child_rollout_path, format!("{lines}\n"))?;
let (mut app_server, requests, proxy) = start_recording_app_server(
&app.config,
/*blocked_thread_list*/ None,
/*failed_thread_name*/ None,
)
.await?;
let resumed = app_server
.resume_thread(
&app.local_settings,
app.config.clone(),
child_thread_id,
crate::app_server_session::ResumeModelSettings::RestoreFromThread,
)
.await?;
let child_turn_page = app_server
.thread_turns_page(
child_thread_id,
/*cursor*/ None,
crate::app_server_session::INITIAL_HISTORY_TURN_LIMIT,
)
.await?;
let child_item_page = app_server
.thread_items_page(
child_thread_id,
/*turn_id*/ None,
/*cursor*/ None,
/*limit*/ 16,
)
.await?;
let [child_turn] = child_turn_page.data.as_slice() else {
panic!("paginated subagent should expose exactly one child turn");
};
let [child_entry] = child_item_page.data.as_slice() else {
panic!("paginated subagent should expose exactly one child message");
};
let ThreadItem::UserMessage { content, .. } = &child_entry.item else {
panic!("paginated subagent should expose its child user message");
};
assert_eq!(resumed.session.thread_id, child_thread_id);
assert_eq!(child_entry.turn_id, child_turn.id);
assert_eq!(
content,
&[UserInput::Text {
text: "child-only paginated history".to_string(),
text_elements: Vec::new(),
}],
);
assert_eq!(
resumed
.turns
.iter()
.flat_map(|turn| turn.items.iter())
.collect::<Vec<_>>(),
vec![&child_entry.item],
);
let cells = crate::thread_transcript::load_session_transcript(
&mut app_server,
child_thread_id,
crate::thread_transcript::RawReasoningVisibility::Hidden,
Some(&app.config),
)
.await?;
let visible_history = cells
.iter()
.map(|cell| lines_to_single_string(&cell.display_lines(/*width*/ 80)))
.collect::<Vec<_>>()
.join("\n");
assert!(visible_history.contains("child-only paginated history"));
assert!(!visible_history.contains("parent-only paginated history"));
assert!(
recorded_params(&requests, "thread/read")
.iter()
.all(|params| params["includeTurns"] != true)
);
app_server.shutdown().await?;
proxy.await??;
Ok(())
}
#[tokio::test]
async fn managed_worktree_transitions_bind_owner_and_preserve_only_fork_history() -> Result<()> {
use crate::app_event::ManagedWorktreeMode;
use std::fs;
use std::process::Command;
let (mut app, mut events, _op_rx) = make_test_app_with_channels().await;
let root = tempdir()?;
let home = dunce::canonicalize(root.path())?.join("home");
let source = dunce::canonicalize(root.path())?.join("source");
let project_pool = dunce::canonicalize(root.path())?.join("project-pool");
fs::create_dir_all(&home)?;
fs::create_dir_all(source.join(".codex"))?;
fs::write(home.join("config.toml"), "[features]\nworktrees = true\n")?;
crate::legacy_core::config::set_project_trust_level(
&home,
&source,
codex_protocol::config_types::TrustLevel::Trusted,
)
.map_err(|error| color_eyre::eyre::eyre!(error.to_string()))?;
let destination = format!(
r#"developer_instructions = "committed policy"
model = "gpt-5.2"
model_reasoning_effort = "high"
[desktop]
git-worktree-root = {}
"#,
toml::Value::String(project_pool.display().to_string()),
);
fs::write(source.join(".codex/config.toml"), destination)?;
fs::write(source.join("AGENTS.md"), "committed worktree instructions")?;
for args in [
vec!["init", "--quiet"],
vec!["add", "."],
vec!["commit", "--quiet", "--no-gpg-sign", "-m", "initial"],
] {
let result = Command::new("git")
.current_dir(&source)
.args([
"-c",
"user.name=Worktree Test",
"-c",
"[email protected]",
])
.args(args)
.output()?;
assert!(
result.status.success(),
"{}",
String::from_utf8_lossy(&result.stderr)
);
}
fs::write(
source.join(".codex/config.toml"),
r#"developer_instructions = "dirty policy"
model = "gpt-5.4"
model_reasoning_effort = "low"
"#,
)?;
fs::write(source.join("AGENTS.md"), "dirty source instructions")?;
app.config.codex_home = home.clone().abs();
app.config.sqlite = SqliteConfig::new_for_testing(home.clone().abs());
app.config.cwd = source.clone().abs();
app.harness_overrides.permission_profile = Some(PermissionProfile::workspace_write());
app.config = app.rebuild_config_for_cwd(source.clone()).await?;
app.chat_widget
.handle_thread_session_quiet(test_thread_session(ThreadId::new(), source.clone()));
let (mut server, requests, proxy) = start_recording_app_server(
&app.config,
/*blocked_thread_list*/ None,
/*failed_thread_name*/ None,
)
.await?;
let mut tui = crate::tui::test_support::make_test_tui()?;
app.start_fresh_session(
&mut tui,
&mut server,
/*session_start_source*/ None,
/*initial_user_message*/ None,
/*new_thread_name*/ None,
)
.await;
assert_eq!(
(
app.chat_widget.current_model(),
app.config.model_provider_id.as_str(),
app.chat_widget.current_reasoning_effort()
),
("gpt-5.4", "openai", Some(ReasoningEffortConfig::Low))
);
// Provider selection belongs to host config, not project config.
let host_config = home.join("config.toml");
let contents = fs::read_to_string(&host_config)?;
fs::write(
host_config,
format!("model_provider = \"ollama\"\n{contents}"),
)?;
let original = app.chat_widget.thread_id().expect("original thread");
server.thread_inject_items(original, vec![serde_json::from_value(serde_json::json!({
"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "managed fork history"}]
}))?]).await?;
let manager = codex_worktree::WorktreeManager::new(
codex_worktree::WorktreeSettings::for_cli(&home, /*desktop*/ None)
.map_err(|error| color_eyre::eyre::eyre!(error.to_string()))?,
);
let mut browser_entries = Vec::new();
requests.lock().expect("request recorder lock").clear();
app.handle_event(
&mut tui,
&mut server,
AppEvent::StartManagedWorktree {
mode: ManagedWorktreeMode::Fork,
name: None,
},
)
.await?;
complete_managed_worktree_creation(&mut app, &mut tui, &mut server, &mut events).await?;
assert_eq!(app.chat_widget.thread_id(), Some(original));
assert!(recorded_params(&requests, "thread/fork").is_empty());
let unused = manager
.list(&source)
.map_err(|error| color_eyre::eyre::eyre!(error.to_string()))?
.pop()
.expect("unused checkout");
browser_entries.push(crate::worktree_browser::Entry {
root: unused.root.clone(),
cwd: unused.cwd.clone(),
owner: crate::worktree_browser::Owner::None,
});
assert_eq!(
manager
.owner(&unused.root)
.map_err(|error| color_eyre::eyre::eyre!(error.to_string()))?,
None
);
let error = std::iter::from_fn(|| events.try_recv().ok())
.filter_map(|event| match event {
AppEvent::InsertHistoryCell(cell) => {
Some(lines_to_single_string(&cell.display_lines(/*width*/ 500)))
}
_ => None,
})
.find(|message| message.contains("Cannot fork into this worktree"))
.expect("fork refusal");
let (_, with_path) = error
.split_once("An unused checkout was created at ")
.expect("checkout marker");
let (path, _) = with_path
.split_once("; remove it with")
.expect("cleanup marker");
insta::assert_snapshot!(error.replace(path, "<CHECKOUT>"), @"■ Cannot fork into this worktree because developer instructions differ. Start a new conversation instead. An unused checkout was created at <CHECKOUT>; remove it with `git worktree remove <checkout-path>` from the source repository.");
let retained = std::iter::from_fn(|| events.try_recv().ok())
.filter_map(|event| match event {
AppEvent::InsertHistoryCell(cell) => {
Some(lines_to_single_string(&cell.display_lines(/*width*/ 500)))
}
_ => None,
})
.find(|message| message.contains("A checkout was retained at"))
.expect("post-allocation recovery message");
let (_, with_path) = retained
.split_once("A checkout was retained at ")
.expect("retained checkout marker");
let (path, _) = with_path
.split_once("; remove it with")
.expect("retained checkout cleanup marker");
assert_eq!(
dunce::canonicalize(path)?,
dunce::canonicalize(&unused.root)?
);
assert!(retained.contains("git worktree remove <checkout-path>"));
fs::write(
source.join(".codex/config.toml"),
r#"developer_instructions = "committed policy"
[features]
terminal_visualization_instructions = true
"#,
)?;
app.config = app.rebuild_config_for_cwd(source.clone()).await?;
requests.lock().expect("request recorder lock").clear();
app.handle_event(
&mut tui,
&mut server,
AppEvent::StartManagedWorktree {
mode: ManagedWorktreeMode::Fork,
name: None,
},
)
.await?;
complete_managed_worktree_creation(&mut app, &mut tui, &mut server, &mut events).await?;
assert_eq!(app.chat_widget.thread_id(), Some(original));
assert!(recorded_params(&requests, "thread/fork").is_empty());
let feature_mismatch_checkout = manager
.list(&source)
.map_err(|error| color_eyre::eyre::eyre!(error.to_string()))?
.into_iter()
.find(|checkout| checkout.cwd != unused.cwd)
.expect("feature mismatch leaves an unused checkout");
browser_entries.push(crate::worktree_browser::Entry {
root: feature_mismatch_checkout.root,
cwd: feature_mismatch_checkout.cwd,
owner: crate::worktree_browser::Owner::None,
});
while events.try_recv().is_ok() {}
app.handle_event(
&mut tui,
&mut server,
AppEvent::StartManagedWorktree {
mode: ManagedWorktreeMode::New,
name: None,
},
)
.await?;
assert_eq!(app.chat_widget.thread_id(), Some(original));
drain_managed_worktree_start(&mut app, &mut server).await;
assert!(app.pending_managed_worktree_creation);
let created = loop {
let event = tokio::time::timeout(Duration::from_secs(15), events.recv())
.await?
.ok_or_else(|| color_eyre::eyre::eyre!("worktree completion channel closed"))?;
if let AppEvent::ManagedWorktreeCreated(created) = event {
break created;
}
};
let stale_checkout = created
.result
.as_ref()
.expect("created checkout")
.1
.root
.clone();
let stale_cwd = created
.result
.as_ref()
.expect("created checkout")
.1
.cwd
.clone();
app.primary_thread_id = Some(ThreadId::new());
app.handle_event(
&mut tui,
&mut server,
AppEvent::ManagedWorktreeCreated(created),
)
.await?;
let created = app
.pending_managed_worktree_created
.take()
.expect("deferred checkout completion");
app.finish_managed_worktree(*created).await;
app.primary_thread_id = Some(original);
assert_eq!(app.chat_widget.thread_id(), Some(original));
assert!(!app.pending_managed_worktree_creation);
let stale_error = std::iter::from_fn(|| events.try_recv().ok())
.filter_map(|event| match event {
AppEvent::InsertHistoryCell(cell) => {
Some(lines_to_single_string(&cell.display_lines(/*width*/ 500)))
}
_ => None,
})
.find(|message| message.contains("A checkout was retained at"))
.expect("stale creation recovery message");
assert!(stale_error.contains(&stale_checkout.display().to_string()));
assert!(stale_error.contains("git worktree remove <checkout-path>"));
assert_eq!(
manager
.owner(&stale_checkout)
.map_err(|error| color_eyre::eyre::eyre!(error.to_string()))?,
None
);
browser_entries.push(crate::worktree_browser::Entry {
root: stale_checkout,
cwd: stale_cwd,
owner: crate::worktree_browser::Owner::None,
});
for mode in [ManagedWorktreeMode::New, ManagedWorktreeMode::Fork] {
requests.lock().expect("request recorder lock").clear();
let previous = app.chat_widget.thread_id();
let previous_rollout = app.chat_widget.rollout_path().expect("previous rollout");
app.handle_event(
&mut tui,
&mut server,
AppEvent::StartManagedWorktree {
mode,
name: Some(format!("{mode:?} worktree")),
},
)
.await?;
complete_managed_worktree_creation(&mut app, &mut tui, &mut server, &mut events).await?;
let replacement = app.chat_widget.thread_id().expect("replacement thread");
assert_ne!(Some(replacement), previous);
assert_eq!(
app.chat_widget.thread_name(),
Some(format!("{mode:?} worktree"))
);
let cwd = app.config.cwd.as_path().canonicalize()?;
let checkouts = manager
.list(&source)
.map_err(|error| color_eyre::eyre::eyre!(error.to_string()))?;
let checkout = checkouts
.iter()
.find(|checkout| checkout.cwd.canonicalize().ok().as_ref() == Some(&cwd))
.expect("managed checkout");
browser_entries.push(crate::worktree_browser::Entry {
root: checkout.root.clone(),
cwd: checkout.cwd.clone(),
owner: crate::worktree_browser::Owner::Unavailable(replacement),
});
assert!(checkout.root.starts_with(home.join("worktrees")));
assert!(!project_pool.exists());
assert_eq!(
manager
.owner(&checkout.root)
.map_err(|error| color_eyre::eyre::eyre!(error.to_string()))?,
Some(replacement.to_string())
);
assert_eq!(
app.config.developer_instructions.as_deref(),
Some("committed policy")
);
assert_eq!(
fs::read_to_string(checkout.cwd.join("AGENTS.md"))?,
"committed worktree instructions"
);
let fork = matches!(mode, ManagedWorktreeMode::Fork);
let method = if fork { "thread/fork" } else { "thread/start" };
let params = recorded_params(&requests, method);
assert_eq!(params.len(), 1);
assert_eq!(
[
params[0]["model"].as_str(),
params[0]["modelProvider"].as_str(),
params[0]["config"]["model_reasoning_effort"].as_str(),
],
[Some("gpt-5.2"), fork.then_some("ollama"), Some("high")]
);
assert_eq!(app.config.model_provider_id, "ollama");
// Injection flushes and materializes a new thread's otherwise lazy rollout.
server.thread_inject_items(replacement, vec![serde_json::from_value(serde_json::json!({
"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": format!("replacement persistence probe {mode:?}")}]
}))?]).await?;
let rollout = app.chat_widget.rollout_path().expect("replacement rollout");
let mut history = fs::read(&rollout)?;
let metadata = codex_rollout::read_session_meta_line(&rollout).await?;
assert_eq!(metadata.meta.history_base.is_some(), fork);
if let Some(base) = metadata.meta.history_base {
assert!(fork, "New must not inherit history");
assert_eq!(Some(base.thread_id), previous);
let parent = fs::read(&previous_rollout)?;
history.extend_from_slice(
parent
.get(..usize::try_from(base.end_byte_offset)?)
.expect("valid inherited prefix"),
);
}
let history = String::from_utf8(history)?;
assert!(!history.contains("managed fork history"));
if fork {
assert!(history.contains("replacement persistence probe New"));
}
let attached = server
.thread_read(replacement, /*include_turns*/ false)
.await?;
assert_eq!(attached.cwd.as_path().canonicalize()?, cwd);
}
browser_entries.sort_by(|left, right| left.cwd.cmp(&right.cwd));
let nested = source.join("browser-only");
fs::create_dir(&nested)?;
assert_eq!(
crate::worktree_browser::list(home.clone(), nested)
.await
.map_err(|error| color_eyre::eyre::eyre!(error.to_string()))?,
browser_entries
);
let unowned = manager
.create(&codex_worktree::CreateWorktree {
source_cwd: source.clone(),
base: None,
})
.map_err(|error| color_eyre::eyre::eyre!(error.to_string()))?;
browser_entries.push(crate::worktree_browser::Entry {
root: unowned.root.clone(),
cwd: unowned.cwd.clone(),
owner: crate::worktree_browser::Owner::None,
});
browser_entries.sort_by(|left, right| left.cwd.cmp(&right.cwd));
for owner in [None, Some("not-a-thread-uuid")] {
if let Some(owner) = owner {
manager
.bind_thread(&unowned.root, owner)
.map_err(|error| color_eyre::eyre::eyre!(error.to_string()))?;
}
assert_eq!(
crate::worktree_browser::list(home.clone(), source.clone())
.await
.map_err(|error| color_eyre::eyre::eyre!(error.to_string()))?,
browser_entries
);
}
let missing_owner = ThreadId::new();
let missing_checkout = manager
.create(&codex_worktree::CreateWorktree {
source_cwd: source.clone(),
base: None,
})
.map_err(|error| color_eyre::eyre::eyre!(error.to_string()))?;
manager
.bind_thread(&missing_checkout.root, &missing_owner.to_string())
.map_err(|error| color_eyre::eyre::eyre!(error.to_string()))?;
let (browser_tx, mut browser_rx) = tokio::sync::mpsc::unbounded_channel();
crate::worktree_browser::fetch(
crate::worktree_browser::Request {
id: uuid::Uuid::new_v4(),
cwd: source.clone(),
thread_id: Some(original),
},
home.clone(),
server.request_handle(),
crate::app_event_sender::AppEventSender::new(browser_tx),
);
let Some(AppEvent::ManagedWorktreesLoaded {
result: Ok(entries),
..
}) = tokio::time::timeout(
std::time::Duration::from_secs(/*secs*/ 5),
browser_rx.recv(),
)
.await?
else {
panic!("browser must return annotated worktrees");
};
assert_eq!(
entries
.iter()
.find(|entry| entry.root == missing_checkout.root)
.map(|entry| &entry.owner),
Some(&crate::worktree_browser::Owner::Unavailable(missing_owner))
);
app.start_fresh_session(
&mut tui,
&mut server,
/*session_start_source*/ None,
/*initial_user_message*/ None,
/*new_thread_name*/ None,
)
.await;
let unsaved = app.chat_widget.thread_id().expect("unsaved thread");
let path = app.chat_widget.rollout_path();
assert!(path.is_none_or(|path| !rollout_path_is_resumable(&path)));
let completed = test_turn("completed-unsaved-turn", TurnStatus::Completed, Vec::new());
app.thread_event_channels[&unsaved]
.store
.lock()
.await
.set_turns(vec![completed]);
for mode in [ManagedWorktreeMode::Fork, ManagedWorktreeMode::New] {
requests.lock().expect("request recorder lock").clear();
app.handle_event(
&mut tui,
&mut server,
AppEvent::StartManagedWorktree { mode, name: None },
)
.await?;
drain_managed_worktree_start(&mut app, &mut server).await;
let is_new = mode == ManagedWorktreeMode::New;
if is_new {
complete_managed_worktree_creation(&mut app, &mut tui, &mut server, &mut events)
.await?;
}
assert_eq!(app.chat_widget.thread_id() != Some(unsaved), is_new);
assert_eq!(recorded_params(&requests, "thread/fork").len(), 0);
}
let saved_owner = entries
.iter()
.find_map(|entry| match &entry.owner {
crate::worktree_browser::Owner::Resumable(thread) => Some(thread.clone()),
_ => None,
})
.expect("browser should resolve a saved owner");
// Archive stops the writer; unarchive leaves a stored thread eligible for compression.
server.thread_archive(saved_owner.id).await?;
let saved_path = server
.thread_unarchive(saved_owner.id)
.await?
.path
.expect("saved rollout path");
fs::OpenOptions::new()
.write(true)
.open(&saved_path)?
.set_times(std::fs::FileTimes::new().set_modified(
std::time::SystemTime::now() - std::time::Duration::from_secs(8 * 24 * 60 * 60),
))?;
codex_rollout::spawn_rollout_compression_worker(
home.clone(),
codex_rollout::RolloutCompressionTrigger::Startup,
);
tokio::time::timeout(std::time::Duration::from_secs(10), async {
while saved_path.exists() || !saved_path.with_extension("jsonl.zst").is_file() {
tokio::time::sleep(std::time::Duration::from_millis(50)).await;
}
})
.await?;
let (browser_tx, mut browser_rx) = tokio::sync::mpsc::unbounded_channel();
crate::worktree_browser::fetch(
crate::worktree_browser::Request {
id: uuid::Uuid::new_v4(),
cwd: source.clone(),
thread_id: Some(original),
},
home.clone(),
server.request_handle(),
crate::app_event_sender::AppEventSender::new(browser_tx),
);
let Some(AppEvent::ManagedWorktreesLoaded {
result: Ok(compressed_entries),
..
}) = tokio::time::timeout(std::time::Duration::from_secs(10), browser_rx.recv()).await?
else {
panic!("browser must return compressed owner metadata");
};
assert!(compressed_entries.iter().any(|entry| matches!(
&entry.owner,
crate::worktree_browser::Owner::Resumable(thread) if thread.id == saved_owner.id
)));
server.thread_archive(saved_owner.id).await?;
let (browser_tx, mut browser_rx) = tokio::sync::mpsc::unbounded_channel();
crate::worktree_browser::fetch(
crate::worktree_browser::Request {
id: uuid::Uuid::new_v4(),
cwd: source.clone(),
thread_id: Some(original),
},
home,
server.request_handle(),
crate::app_event_sender::AppEventSender::new(browser_tx),
);
let Some(AppEvent::ManagedWorktreesLoaded {
result: Ok(entries),
..
}) = tokio::time::timeout(
std::time::Duration::from_secs(/*secs*/ 10),
browser_rx.recv(),
)
.await?
else {
panic!("browser must return archived owner metadata");
};
assert!(entries.iter().any(|entry| matches!(
&entry.owner,
crate::worktree_browser::Owner::Archived(thread) if thread.id == saved_owner.id
)));
server.shutdown().await?;
proxy.await??;
Ok(())
}
#[tokio::test]
async fn changing_directory_preserves_project_trust_permissions_history_and_hooks() -> Result<()> {
use codex_protocol::config_types::TrustLevel as T;
use serde_json::json;
use std::fs;
let (mut app, mut events, _op_rx) = make_test_app_with_channels().await;
let codex_home = tempdir()?;
app.config.codex_home = codex_home.path().to_path_buf().abs();
app.config.sqlite = SqliteConfig::new_for_testing(codex_home.path().abs());
app.harness_overrides.permission_profile = Some(PermissionProfile::workspace_write());
let names = ["root", "trusted", "unknown", "untrusted", "p", "failure"];
let [current, trusted, unknown, untrusted, mismatch, failed] =
names.map(|name| codex_home.path().join(name));
fs::create_dir_all(¤t)?;
for directory in [&trusted, &unknown, &untrusted, &mismatch, &failed] {
fs::create_dir_all(directory.join(".codex"))?;
fs::write(directory.join(".codex/config.toml"), "")?;
}
let contents = "developer_instructions = \"destination policy\"\nmodel_reasoning_effort = \"high\"\napproval_policy = \"on-request\"\n[tui]\ntheme = \"dracula\"\n[tui.keymap.global]\nopen_transcript = \"f12\"";
fs::write(trusted.join(".codex/config.toml"), contents)?;
let agents = trusted.join("AGENTS.md");
fs::write(&agents, "Follow destination project instructions.")?;
let hooks = r#"{"hooks":{"SessionStart":[{"hooks":[{"type":"command","command":"x"}]}]}}"#;
fs::write(trusted.join(".codex/hooks.json"), hooks)?;
let contents = "default_permissions = \"dev\"\n[permissions.dev.filesystem]\n\":root\" = \"write\"\n[tui.keymap.global]\nopen_transcript = \"ctrl-l\"";
fs::write(mismatch.join(".codex/config.toml"), contents)?;
let requirements = codex_home.path().join("requirements.toml");
let rules = "allowed_approval_policies=[\"untrusted\"]\nallowed_sandbox_modes=[\"read-only\"]";
fs::write(&requirements, rules)?;
fs::create_dir_all(unknown.join(".codex"))?;
for dir in [&trusted, &untrusted, &mismatch, &failed] {
let trust = [T::Trusted, T::Untrusted][usize::from(dir == &untrusted)];
crate::legacy_core::config::set_project_trust_level(codex_home.path(), dir, trust)
.map_err(|error| color_eyre::eyre::eyre!(error.to_string()))?;
}
app.config.cwd = current.clone().abs();
app.chat_widget
.handle_thread_session_quiet(test_thread_session(ThreadId::new(), current.clone()));
let (no_list, nick, role, runtime, background) = (None, None, None, None, Some("background"));
let (mut server, requests, proxy) =
start_recording_app_server(&app.config, no_list, background).await?;
let (rec, plain, req) = (recorded_params, crate::key_hint::plain, &requests);
let mut tui = crate::tui::test_support::make_test_tui()?;
let (source, message, name) = (None, None, Some("Previous project".to_string()));
app.start_fresh_session(&mut tui, &mut server, source, message, name)
.await;
let original = app.chat_widget.thread_id().expect("original thread");
let rollout = app.chat_widget.rollout_path().expect("original rollout");
let json = r#"{"type":"message","role":"assistant","content":[{"type":"output_text","text":"saved history"}]}"#;
let item = serde_json::from_str(json)?;
server.thread_inject_items(original, vec![item]).await?;
let tracked = server.start_thread(&app.config).await?;
let (child, capacity) = (tracked.session.thread_id, THREAD_EVENT_CHANNEL_CAPACITY);
let channel = ThreadEventChannel::new_with_session(capacity, tracked.session, tracked.turns);
app.thread_event_channels.insert(child, channel);
app.agent_navigation
.upsert(child, nick, role, /*is_closed*/ false);
let store = app.thread_event_channels[&child].store.clone();
let config_path = codex_home.path().join("config.toml");
let original_user_config = fs::read_to_string(&config_path).ok();
let (local, url) = (app.environment_manager.clone(), Some("ws://[::1]".into()));
let remote = Arc::new(EnvironmentManager::create_for_tests(url, runtime).await);
let mut history = || {
std::iter::from_fn(|| events.try_recv().ok())
.filter_map(|event| match event {
AppEvent::InsertHistoryCell(cell) => Some(cell),
_ => None,
})
.map(|cell| lines_to_single_string(&cell.transcript_lines(/*width*/ 200)))
.collect::<Vec<_>>()
};
let change = |thread_id, path: &str| AppEvent::ChangeWorkingDirectory {
thread_id,
requested_cwd: path.into(),
};
let mut stale_config = app.rebuild_config_for_cwd(untrusted.clone()).await?;
stale_config.active_project.trust_level = None;
app.app_server_target = crate::AppServerTarget::LocalDaemon {
endpoint: crate::resolve_remote_addr("ws://127.0.0.1:8765")?,
allow_embedded_fallback: false,
};
history();
assert!(
app.confirm_directory_trust(
&mut tui,
&mut server,
&mut stale_config,
&untrusted,
crate::onboarding::DirectoryTrustOptions {
cancel: Some(crate::onboarding::TrustCancelAction::CurrentTask),
..Default::default()
},
/*startup_draft*/ None,
)
.await
.is_err()
);
assert_snapshot!(history().join(""), @"■ Unable to check folder trust: Folder trust changed. Reopen the destination with its restricted settings.");
app.app_server_target = crate::AppServerTarget::Embedded;
for (path, kind, expected) in [
("missing", "local", "Cannot access directory"),
("../config.toml", "local", "Not a directory"),
(r"C:\bad", "workspace", "not supported for remote"),
("~", "executor", "not supported for remote"),
("../trusted", "stale", "requires an idle primary session"),
("../trusted", "running", "another agent is running"),
("../trusted", "active", "another agent is running"),
("../trusted", "mcp", "inventory is still loading"),
("../unknown", "main", "background terminals"),
("../unknown", "child", "background terminals"),
("../trusted", "approval", "approval policy override"),
("../trusted", "profile", "permission profile override"),
("../trusted", "reviewer", "reviewer"),
("../trusted", "standalone_reviewer", "reviewer"),
("../p", "named", "different settings"),
(
"../trusted",
"restored",
"Permission profile cannot be preserved",
),
("../p", "keymap", "open_transcript"),
] {
app.config.approvals_reviewer = ApprovalsReviewer::User;
if matches!(kind, "reviewer" | "standalone_reviewer") {
app.config.approvals_reviewer = ApprovalsReviewer::AutoReview;
fs::write(&requirements, "allowed_approvals_reviewers = [\"user\"]")?;
}
app.agent_navigation.set_running(child, kind == "running");
store.lock().await.active_turn_id = (kind == "active").then(|| "active".into());
app.loader_overrides.system_requirements_path = matches!(
kind,
"approval" | "profile" | "reviewer" | "standalone_reviewer"
)
.then_some(requirements.clone());
app.runtime_approvals_reviewer_override =
matches!(kind, "reviewer" | "standalone_reviewer")
.then_some(ApprovalsReviewer::AutoReview);
app.harness_overrides.permission_profile =
(kind != "named").then_some(PermissionProfile::workspace_write());
app.runtime_approval_policy_override = (kind == "approval").then_some(
RuntimeApprovalPolicyOverride::Explicit(AskForApproval::OnRequest),
);
let mut profile = RuntimePermissionProfileOverride::from_config(&app.config);
profile.active_permission_profile =
(kind == "named").then(|| ActivePermissionProfile::new("dev"));
if kind == "restored" {
profile.permission_profile = PermissionProfile::workspace_write_with(
&[failed.clone().abs()],
codex_protocol::permissions::NetworkSandboxPolicy::Restricted,
/*exclude_tmpdir_env_var*/ false,
/*exclude_slash_tmp*/ false,
);
profile.turn_override = RuntimePermissionProfileTurnOverride::Preserve;
}
app.runtime_permission_profile_override =
matches!(kind, "profile" | "reviewer" | "named" | "restored").then_some(profile);
app.app_server_target = crate::AppServerTarget::Embedded;
if kind == "workspace" {
let endpoint = crate::resolve_remote_addr("ws://127.0.0.1:8765")?;
app.app_server_target = crate::AppServerTarget::Remote { endpoint };
}
app.environment_manager = [&local, &remote][usize::from(kind == "executor")].clone();
requests.lock().expect("request recorder lock").clear();
if kind == "mcp" {
let loading = history_cell::new_mcp_inventory_loading;
app.transcript_cells
.push(Arc::new(loading(/*animations_enabled*/ false)));
} else if kind == "child" {
app.thread_event_channels.remove(&child);
}
let thread_id = [original, ThreadId::new()][usize::from(kind == "stale")];
app.handle_event(&mut tui, &mut server, change(thread_id, path))
.await?;
if let Some(pending) = app.pending_working_directory_change.take() {
Box::pin(app.finish_working_directory_change(&mut tui, &mut server, pending)).await;
}
assert_eq!(app.chat_widget.thread_id(), Some(original));
assert_eq!(app.config.cwd, current.clone().abs());
assert!(app.runtime_working_directory_override.is_none());
assert!(
recorded_params(&requests, "thread/start").is_empty(),
"{kind}"
);
assert!(
recorded_params(&requests, "thread/fork").is_empty(),
"{kind}"
);
let listed = recorded_params(&requests, "thread/backgroundTerminals/list");
let mut ids = listed.iter().zip([original, child]);
assert!(ids.all(|(p, id)| p["threadId"] == id.to_string()));
assert_eq!(fs::read_to_string(&config_path).ok(), original_user_config);
let output = history().join("");
if kind == "mcp" {
assert_snapshot!(output, @"■ MCP inventory is still loading.");
} else if kind == "restored" {
assert_snapshot!(output, @"■ Permission profile cannot be preserved by /cd.");
}
assert!(output.contains(expected), "{path}");
app.clear_committed_mcp_inventory_loading();
}
let tracked = server.start_thread(&app.config).await?;
let closed = tracked.session.thread_id;
let channel = ThreadEventChannel::new_with_session(
THREAD_EVENT_CHANNEL_CAPACITY,
tracked.session,
tracked.turns,
);
app.thread_event_channels.insert(closed, channel);
app.agent_navigation.mark_closed(child);
for has_stale_replay_turn in [false, true] {
app.agent_navigation.upsert(
closed, /*agent_nickname*/ None, /*agent_role*/ None,
/*is_closed*/ false,
);
let channel = app.thread_event_channels.get_mut(&closed).expect("channel");
channel.store.lock().await.set_turns(vec![test_turn(
"stale-turn",
TurnStatus::InProgress,
Vec::new(),
)]);
if has_stale_replay_turn {
channel.mark_replay_only();
app.agent_navigation.mark_closed(closed);
} else {
app.enqueue_thread_notification(closed, thread_closed_notification(closed))
.await?;
}
requests.lock().expect("request recorder lock").clear();
app.change_working_directory(&mut tui, &mut server, failed.clone().abs())
.await;
assert_eq!(
recorded_params(&requests, "thread/backgroundTerminals/list"),
vec![json!({"threadId": original.to_string(), "cursor": null, "limit": 1})],
);
let output = history().join("");
insta::allow_duplicates! {
assert_snapshot!(output, @"■ Failed to change: thread/fork failed during TUI bootstrap: thread/fork failed: forced thread/name/set failure (code -32603)");
}
}
app.agent_navigation.upsert(
child, /*agent_nickname*/ None, /*agent_role*/ None, /*is_closed*/ false,
);
app.set_approvals_reviewer_in_app_and_widget(ApprovalsReviewer::AutoReview);
app.runtime_approvals_reviewer_override = Some(ApprovalsReviewer::AutoReview);
app.runtime_permission_profile_override =
Some(RuntimePermissionProfileOverride::from_config(&app.config));
for (path, expected) in [(&failed, 0), (&trusted, 2)] {
requests.lock().expect("request recorder lock").clear();
app.change_working_directory(&mut tui, &mut server, path.clone().abs())
.await;
assert_eq!(app.chat_widget.thread_id(), Some(original));
assert_eq!(app.config.cwd, current.clone().abs());
assert_eq!(rec(&requests, "thread/unsubscribe").len(), expected);
assert!(history().join("").contains("change"));
}
let removed = recorded_params(&requests, "thread/unsubscribe");
let archived = recorded_params(&requests, "thread/archive");
assert_eq!(removed[0]["threadId"], original.to_string());
assert_eq!(archived[0]["threadId"], removed[1]["threadId"]);
requests.lock().expect("request recorder lock").clear();
app.handle_event(&mut tui, &mut server, change(original, "../trusted"))
.await?;
// Dispatch only queues /cd: configuration loading happens on a fresh loop iteration.
assert_eq!(app.config.cwd, current.clone().abs());
let pending = app
.pending_working_directory_change
.take()
.expect("valid /cd queued");
Box::pin(app.finish_working_directory_change(&mut tui, &mut server, pending)).await;
let forked = app.chat_widget.thread_id().expect("forked thread");
assert_ne!(forked, original);
let forked_rollout = app.chat_widget.rollout_path().expect("forked rollout");
assert!(fs::read_to_string(&rollout)?.contains("saved history"));
let copied = fs::read_to_string(&forked_rollout)?;
let meta = codex_rollout::read_session_meta_line(&forked_rollout).await?;
let base = meta.meta.history_base;
assert!(copied.contains("saved history") || base.is_some_and(|h| h.thread_id == original));
assert_eq!(app.config.cwd, trusted.clone().abs());
let configured = app.primary_session_configured.as_ref().expect("session");
let source = codex_utils_path_uri::PathUri::from_abs_path(&agents.abs());
assert!(configured.instruction_source_paths.contains(&source));
assert_eq!(configured.approvals_reviewer, ApprovalsReviewer::AutoReview);
let earlier_skills_requests = recorded_params(&requests, "skills/list");
app.submit_active_thread_op(
&mut server,
AppCommand::list_skills(vec![current.clone()], /*force_reload*/ true),
)
.await?;
assert_eq!(
recorded_params(&requests, "skills/list"),
earlier_skills_requests
);
let (cwd, result) = (current.clone(), Err("stale skills".into()));
let skills = AppEvent::SkillsListLoaded { cwd, result };
let (cwd, plugins) = (current.clone(), Some(vec![]));
let plugins = AppEvent::PluginMentionsLoaded { cwd, plugins };
let diff = AppEvent::DiffResult(current.clone(), "stale diff".to_string());
let branch = AppEvent::SyncThreadGitBranch {
thread_id: original,
branch: "stale".to_string(),
cwd: current.clone(),
};
for event in [diff, skills, plugins, branch] {
app.handle_event(&mut tui, &mut server, event).await?;
}
let path = trusted.to_str().expect("trusted path");
let output = history().join("").replace(path, "<PROJECT>");
let message = &output[output.rfind('•').expect("change")..];
assert_snapshot!(message, @"• Working directory changed to: <PROJECT>");
assert!(!output.contains("stale skills"));
assert!(app.overlay.is_none());
assert_eq!(app.keymap.app.open_transcript, vec![plain(KeyCode::F(12))]);
let anchor = app.runtime_working_directory_override.as_deref();
assert_eq!(anchor, Some(trusted.as_path()));
let effort = app.chat_widget.current_reasoning_effort();
assert_eq!(effort, Some(ReasoningEffortConfig::High));
let approval = app.config.permissions.approval_policy.value();
assert_eq!(approval, AskForApproval::OnRequest.to_core());
let forks = recorded_params(&requests, "thread/fork");
assert_eq!(forks.len(), 1);
let params = &forks[0];
assert_eq!(params["threadId"], serde_json::json!(original.to_string()));
assert_eq!(params["cwd"], serde_json::json!(trusted));
assert_eq!(params["approvalsReviewer"].as_str(), Some("auto_review"));
assert_eq!(params["developerInstructions"], "destination policy");
assert_eq!(params["deferGoalContinuation"], serde_json::json!(true));
assert_eq!(¶ms["runtimeWorkspaceRoots"], &json!([trusted]));
assert_eq!(rec(&requests, "hooks/list")[0]["cwds"], json!([trusted]));
for suffix in "start resume settings/update archive".split(' ') {
assert!(recorded_params(&requests, &format!("thread/{suffix}")).is_empty());
}
assert!(rec(req, "thread/metadata/update")[0]["threadId"] == params["threadId"]);
let removed = recorded_params(&requests, "thread/unsubscribe");
assert_eq!(removed.len(), 2);
let found = |id: ThreadId| removed.iter().any(|p| p["threadId"] == id.to_string());
assert!([original, child].into_iter().all(found));
let retained = server.thread_read(original, /*include_turns*/ false);
assert_eq!(retained.await?.cwd, current.abs().canonicalize()?);
assert_eq!(app.chat_widget.config_ref().cwd, trusted.clone().abs());
assert!(render_bottom_popup(&app.chat_widget, /*width*/ 80).contains("SessionStart"));
app.chat_widget
.handle_key_event(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
app.harness_overrides.bypass_hook_trust = Some(true);
requests.lock().expect("request recorder lock").clear();
app.change_working_directory(&mut tui, &mut server, trusted.clone().abs())
.await;
assert!(app.config.bypass_hook_trust && !app.chat_widget.has_active_view());
assert!(recorded_params(&requests, "hooks/list").is_empty());
app.harness_overrides.bypass_hook_trust = None;
app.harness_overrides.permission_profile = None;
app.runtime_approval_policy_override = Some(RuntimeApprovalPolicyOverride::Restored(
AskForApproval::OnRequest,
));
app.runtime_permission_profile_override = Some(
RuntimePermissionProfileOverride::from_restored_config(&app.config),
);
requests.lock().expect("request recorder lock").clear();
app.change_working_directory(&mut tui, &mut server, untrusted.clone().abs())
.await;
assert_eq!(app.config.active_project.trust_level, Some(T::Untrusted));
let approval = app.config.permissions.approval_policy.value();
assert_eq!(approval, AskForApproval::UnlessTrusted.to_core());
assert_eq!(rec(req, "thread/fork")[0]["approvalPolicy"], "untrusted");
let warning = "Project-local config, hooks, and exec policies are disabled";
assert!(history().iter().any(|line| line.contains(warning)));
let untrusted_permissions = app.config.permissions.permission_profile().clone();
app.change_working_directory(&mut tui, &mut server, trusted.clone().abs())
.await;
assert_eq!(app.config.cwd, trusted.abs());
assert_eq!(
(
app.config.permissions.approval_policy.value(),
app.config.permissions.permission_profile()
),
(
AskForApproval::UnlessTrusted.to_core(),
&untrusted_permissions
)
);
server.shutdown().await?;
proxy.await??;
Ok(())
}
#[test]
fn fresh_session_applies_requested_name() -> Result<()> {
const TEST_STACK_SIZE_BYTES: usize = 8 * 1024 * 1024;
std::thread::Builder::new()
.name("tui-named-fresh-session".to_string())
.stack_size(TEST_STACK_SIZE_BYTES)
.spawn(|| {
let runtime = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()?;
runtime.block_on(async {
let mut app = make_test_app().await;
let codex_home = tempdir()?;
app.config.codex_home = codex_home.path().to_path_buf().abs();
app.config.sqlite = SqliteConfig::new_for_testing(codex_home.path().abs());
let (mut app_server, requests, proxy) = start_recording_app_server(
&app.config,
/*blocked_thread_list*/ None,
/*failed_thread_name*/ None,
)
.await?;
let mut tui = crate::tui::test_support::make_test_tui()?;
app.start_fresh_session(
&mut tui,
&mut app_server,
/*session_start_source*/ None,
/*initial_user_message*/ None,
/*new_thread_name*/ Some("Add User".to_string()),
)
.await;
let thread_id = app
.chat_widget
.thread_id()
.expect("fresh session should have a thread id");
assert_eq!(app.chat_widget.thread_name(), Some("Add User".to_string()));
assert!(
requests
.lock()
.expect("request recorder lock")
.iter()
.any(|request| request.method == "thread/name/set"),
"fresh session should be named through the app server"
);
let thread = app_server
.thread_read(thread_id, /*include_turns*/ false)
.await?;
assert_eq!(thread.name.as_deref(), Some("Add User"));
app_server.shutdown().await?;
proxy.await??;
Ok(())
})
})?
.join()
.expect("named fresh session test thread")
}
#[test]
fn session_lifecycle_avoids_redundant_subagent_metadata_reads() -> Result<()> {
const TEST_STACK_SIZE_BYTES: usize = 16 * 1024 * 1024;
std::thread::Builder::new()
.name("tui-session-lifecycle-requests".to_string())
.stack_size(TEST_STACK_SIZE_BYTES)
.spawn(|| {
let runtime = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()?;
runtime.block_on(async {
let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await;
let codex_home = tempdir()?;
app.config.codex_home = codex_home.path().to_path_buf().abs();
app.config.sqlite =
codex_state::SqliteConfig::new_for_testing(codex_home.path().abs());
let root_timestamp = "2026-01-01T00-00-00";
let root_thread_id = ThreadId::from_string(
&create_fake_rollout(
codex_home.path(),
root_timestamp,
"2026-01-01T00:00:00Z",
"Saved user message",
Some(app.config.model_provider_id.as_str()),
/*git_info*/ None,
)
.expect("create root rollout"),
)?;
let child_thread_id = ThreadId::from_string(
&create_fake_parented_rollout_with_source(
codex_home.path(),
"2026-01-01T00-00-01",
"2026-01-01T00:00:01Z",
"Saved child message",
Some(app.config.model_provider_id.as_str()),
/*git_info*/ None,
RolloutSessionSource::SubAgent(SubAgentSource::ThreadSpawn {
parent_thread_id: root_thread_id,
depth: 1,
agent_path: Some(
AgentPath::try_from("/root/worker").expect("valid agent path"),
),
agent_nickname: Some("worker".to_string()),
agent_role: Some("worker".to_string()),
}),
root_thread_id.into(),
root_thread_id,
)
.expect("create child rollout"),
)?;
let root_rollout_path = rollout_path(
codex_home.path(),
root_timestamp,
&root_thread_id.to_string(),
);
let (started_tx, started_rx) = oneshot::channel();
let (release_tx, release_rx) = oneshot::channel();
let (mut app_server, requests, proxy) = start_recording_app_server(
&app.config,
Some((root_thread_id, started_tx, release_rx)),
Some("Failed Fork"),
)
.await?;
let backend_id = app_server.backend_id();
let root = app_server
.resume_thread(
&app.local_settings,
app.config.clone(),
root_thread_id,
app.resume_model_settings(),
)
.await?;
app.enqueue_primary_thread_session(root.session, root.turns)
.await?;
app_server
.resume_thread(
&app.local_settings,
app.config.clone(),
child_thread_id,
app.resume_model_settings(),
)
.await?;
let mut tui = crate::tui::test_support::make_test_tui()?;
take_backfill_counts(&requests);
let control = Box::pin(app.handle_event(
&mut tui,
&mut app_server,
AppEvent::ForkCurrentSession {
name: Some("Add User Fork".to_string()),
},
))
.await?;
assert!(matches!(control, AppRunControl::Continue));
assert_ne!(app.chat_widget.thread_id(), Some(root_thread_id));
let named_fork_id = app
.chat_widget
.thread_id()
.expect("named fork should have a thread id");
assert_eq!(
app.chat_widget.thread_name(),
Some("Add User Fork".to_string())
);
// Forking may read the source metadata once when the response includes its parent
// id. It must not scan or backfill loaded threads for the newly created fork.
assert!(matches!(take_backfill_counts(&requests), (0, 0) | (0, 1)));
let named_fork = app_server
.thread_read(named_fork_id, /*include_turns*/ false)
.await?;
assert_eq!(named_fork.name.as_deref(), Some("Add User Fork"));
take_backfill_counts(&requests);
let control = Box::pin(app.handle_event(
&mut tui,
&mut app_server,
AppEvent::ForkCurrentSession {
name: Some("Failed Fork".to_string()),
},
))
.await?;
assert!(matches!(control, AppRunControl::Continue));
assert_ne!(app.chat_widget.thread_id(), Some(named_fork_id));
let name_error = std::iter::from_fn(|| app_event_rx.try_recv().ok())
.find_map(|event| match event {
AppEvent::InsertHistoryCell(cell) => {
let rendered =
lines_to_single_string(&cell.display_lines(/*width*/ 80));
rendered
.contains("Failed to name the forked session")
.then_some(rendered)
}
_ => None,
})
.expect("fork naming error history cell");
insta::assert_snapshot!(
name_error,
@"■ Failed to name the forked session: thread/name/set failed in TUI"
);
assert!(matches!(take_backfill_counts(&requests), (0, 0) | (0, 1)));
app.start_fresh_session(
&mut tui,
&mut app_server,
/*session_start_source*/ None,
/*initial_user_message*/ None,
/*new_thread_name*/ None,
)
.await;
assert_ne!(app.chat_widget.thread_id(), Some(root_thread_id));
assert_eq!(take_backfill_counts(&requests), (0, 0));
let loaded_threads = app_server
.thread_loaded_list(ThreadLoadedListParams {
cursor: None,
limit: None,
})
.await?
.data;
let expected_reads = loaded_threads
.iter()
.filter(|thread_id| *thread_id != &root_thread_id.to_string())
.count();
assert!(loaded_threads.contains(&child_thread_id.to_string()));
take_backfill_counts(&requests);
crate::legacy_core::config::set_project_trust_level(
app.config.codex_home.as_path(),
app.config.cwd.as_path(),
codex_protocol::config_types::TrustLevel::Trusted,
)
.map_err(std::io::Error::other)?;
app.harness_overrides.cwd = Some(app.config.cwd.to_path_buf());
let control = app
.resume_target_session(
&mut tui,
&mut app_server,
crate::resume_picker::SessionTarget {
backend_id,
path: Some(root_rollout_path),
thread_id: root_thread_id,
cwd: None,
history_mode: None,
},
)
.await?;
assert!(matches!(control, AppRunControl::Continue));
assert_eq!(app.chat_widget.thread_id(), Some(root_thread_id));
assert_eq!(take_backfill_counts(&requests), (1, expected_reads));
assert_eq!(
app.agent_navigation.get(&child_thread_id),
Some(&AgentPickerThreadEntry {
agent_nickname: Some("worker".to_string()),
agent_role: Some("worker".to_string()),
agent_path: Some("/root/worker".to_string()),
is_running: false,
is_closed: false,
})
);
let child_store = Arc::clone(
&app.thread_event_channels
.entry(child_thread_id)
.or_insert_with(|| ThreadEventChannel::new(/*capacity*/ 1))
.store,
);
let child_store_guard = child_store.lock().await;
futures::FutureExt::now_or_never(app.open_agent_picker(&mut app_server))
.expect("opening the agent picker waited for the app server");
drop(child_store_guard);
insta::assert_snapshot!(
render_bottom_popup(&app.chat_widget, /*width*/ 80)
.replace(&root_thread_id.to_string(), "[root]")
.replace(&child_thread_id.to_string(), "[child]"),
@r###"
Subagents
Select an agent to watch. ⌥← previous, ⌥→ next.
› 1. • Main [default] (current) [root]
2. • /root/worker [child]
enter select · esc back
"###
);
assert_eq!(take_backfill_counts(&requests), (0, 0));
tokio::time::timeout(Duration::from_secs(5), started_rx).await??;
app.chat_widget
.handle_key_event(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
futures::FutureExt::now_or_never(app.open_agent_picker(&mut app_server))
.expect("reopening the agent picker waited for the app server");
assert_eq!(
requests
.lock()
.expect("request recorder lock")
.iter()
.filter(|request| request.method == "thread/list")
.count(),
1
);
app.chat_widget
.handle_key_event(KeyEvent::new(KeyCode::Down, KeyModifiers::NONE));
app.chat_widget.handle_server_request(
exec_approval_request(
root_thread_id,
"turn",
"item",
/*approval_id*/ None,
),
/*replay_kind*/ None,
);
app.agent_navigation.mark_stopped(child_thread_id);
release_tx.send(()).expect("release blocked thread list");
let discovered_thread_id = ThreadId::new();
let mut completion = tokio::time::timeout(Duration::from_secs(5), async {
loop {
let event = app_event_rx.recv().await.expect("app event channel");
if matches!(event, AppEvent::AgentPickerThreadsLoaded { .. }) {
break event;
}
}
})
.await?;
if let AppEvent::AgentPickerThreadsLoaded {
result: Ok(refresh),
..
} = &mut completion
{
let child = refresh
.threads
.iter_mut()
.find(|thread| thread.id == child_thread_id.to_string())
.expect("root-scoped response includes the cached child");
let mut discovered = child.clone();
discovered.id = discovered_thread_id.to_string();
discovered.can_accept_direct_input = None;
child.status = ThreadStatus::Active {
active_flags: Vec::new(),
};
refresh.threads.push(discovered);
}
Box::pin(app.handle_event(&mut tui, &mut app_server, completion)).await?;
assert_eq!(
app.agent_navigation
.ordered_threads()
.last()
.map(|(thread_id, _)| *thread_id),
Some(discovered_thread_id)
);
assert!(!app.agent_navigation.is_parent_owned(discovered_thread_id));
assert_eq!(
app.chat_widget.selected_index_for_present_view(
super::super::agent_picker::AGENT_PICKER_VIEW_ID
),
Some(1)
);
assert!(render_bottom_popup(&app.chat_widget, /*width*/ 80).contains("echo hello"));
assert!(
app.agent_navigation
.get(&child_thread_id)
.is_some_and(|entry| !entry.is_running)
);
app_server.shutdown().await?;
proxy.await??;
Ok(())
})
})?
.join()
.expect("session lifecycle request test thread")
}
#[path = "new_session_tests.rs"]
mod new_session_tests;
#[path = "startup_defaults_tests.rs"]
mod startup_defaults_tests;
#[tokio::test]
async fn external_writer_escape_preserves_snapshot_and_explicit_quits() -> Result<()> {
let endpoint = crate::resolve_remote_addr("ws://127.0.0.1:4500")?;
for target in [
AppServerTarget::LocalDaemon {
allow_embedded_fallback: true,
endpoint: endpoint.clone(),
},
AppServerTarget::Remote { endpoint },
] {
let (mut app, _codex_home) = make_history_test_app().await?;
let thread_id =
create_history_rollout(&app.config, ThreadHistoryMode::Legacy, "owned elsewhere")?;
let (mut server, requests, proxy) = start_recording_app_server(
&app.config,
/*blocked_thread_list*/ None,
/*failed_thread_name*/ None,
)
.await?;
app.app_server_target = target;
app.active_thread_id = Some(thread_id);
app.primary_thread_id = Some(thread_id);
app.ensure_thread_channel(thread_id).mark_external_writer();
app.chat_widget.show_external_writer_thread();
app.chat_widget.insert_str("Retained draft");
let (tx, mut events) = tokio::sync::mpsc::unbounded_channel();
app.app_event_tx = AppEventSender::new(tx);
let mut tui = crate::tui::test_support::make_test_tui()?;
for key in [
KeyEvent::new(KeyCode::Char('q'), KeyModifiers::NONE),
KeyEvent::new(KeyCode::Char('Q'), KeyModifiers::SHIFT),
KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL),
] {
app.handle_key_event(&mut tui, &mut server, key).await;
assert_matches!(events.try_recv(), Ok(AppEvent::Exit(ExitMode::Immediate)));
}
app.handle_key_event(
&mut tui,
&mut server,
KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE),
)
.await;
assert!(app.chat_widget.has_active_view());
loop {
let event = tokio::time::timeout(Duration::from_secs(/*secs*/ 5), events.recv())
.await?
.expect("command center refresh");
let refreshed = matches!(&event, AppEvent::AgentsOverviewThreadsLoaded { .. });
Box::pin(app.handle_event(&mut tui, &mut server, event)).await?;
if refreshed {
break;
}
}
assert_matches!(
Box::pin(app.handle_event(
&mut tui,
&mut server,
AppEvent::SelectAgentsOverviewThread { thread_id },
))
.await?,
AppRunControl::Continue
);
assert!(!app.chat_widget.has_active_view());
assert_eq!(app.active_thread_id, Some(thread_id));
assert!(app.chat_widget.is_external_writer_view());
assert_eq!(
app.chat_widget.composer_text_with_pending(),
"Retained draft"
);
assert_eq!(
app.thread_event_channels[&thread_id].attachment(),
ThreadEventAttachment::ExternalWriter
);
assert!(requests.lock().unwrap().iter().all(|request| matches!(
request.method.as_str(),
"thread/read" | "thread/list" | "thread/loaded/list" | "thread/turns/list"
)));
server.shutdown().await?;
proxy.await??;
}
Ok(())
}
#[tokio::test]
async fn command_center_read_only_open_requests_and_failure_preservation() -> Result<()> {
for (history_capabilities, saved_turn_count) in [
(HistoryCapabilities::Current, 0usize),
(HistoryCapabilities::ReadAfterResumeFails, 0),
(HistoryCapabilities::ItemsListFails, 6),
(HistoryCapabilities::ItemsListFails, 101),
(HistoryCapabilities::ItemsAndSummaryTurnsFail, 6),
] {
let (mut app, _codex_home) = Box::pin(make_history_test_app()).await?;
std::fs::write(
app.config.codex_home.join("config.toml"),
"[tui]\nresume_cwd = \"current\"\n",
)?;
for cwd in [test_path_buf("/"), app.config.cwd.to_path_buf()] {
crate::legacy_core::config::set_project_trust_level(
app.config.codex_home.as_path(),
&cwd,
codex_protocol::config_types::TrustLevel::Trusted,
)
.map_err(std::io::Error::other)?;
}
let history_mode = if matches!(
history_capabilities,
HistoryCapabilities::ItemsListFails | HistoryCapabilities::ItemsAndSummaryTurnsFail
) {
ThreadHistoryMode::Paginated
} else {
ThreadHistoryMode::Legacy
};
let thread_id = create_history_rollout(&app.config, history_mode, "Locked task")?;
if history_mode == ThreadHistoryMode::Paginated {
let path = rollout_path(
app.config.codex_home.as_path(),
"2026-01-02T00-00-00",
&thread_id.to_string(),
);
let mut contents = std::fs::read_to_string(&path)?;
for index in 0..saved_turn_count {
let first_ordinal = contents.lines().count();
let events = [
EventMsg::TurnStarted(TurnStartedEvent {
turn_attribution: None,
turn_id: format!("saved-turn-{index}"),
root_turn_id: None,
trace_id: None,
started_at: None,
model_context_window: None,
collaboration_mode_kind: Default::default(),
}),
EventMsg::ItemCompleted(ItemCompletedEvent {
thread_id,
turn_id: format!("saved-turn-{index}"),
item: TurnItem::UserMessage(UserMessageItem::new(&[CoreUserInput::Text {
text: "Locked task".to_string(),
text_elements: Vec::new(),
}])),
started_at_ms: None,
completed_at_ms: 0,
}),
EventMsg::ItemCompleted(ItemCompletedEvent {
thread_id,
turn_id: format!("saved-turn-{index}"),
item: TurnItem::AgentMessage(AgentMessageItem {
id: format!("saved-answer-{index}"),
content: vec![AgentMessageContent::Text {
text: "Saved final answer".to_string(),
}],
phase: Some(codex_protocol::models::MessagePhase::FinalAnswer),
memory_citation: None,
delivery: None,
questions: None,
}),
started_at_ms: None,
completed_at_ms: 0,
}),
];
for (offset, event) in events.into_iter().enumerate() {
let record = serde_json::json!({
"timestamp": "2026-01-02T00:00:00Z",
"ordinal": first_ordinal + offset,
"type": "event_msg",
"payload": event,
});
contents.push_str(&format!("{record}\n"));
}
}
std::fs::write(path, contents)?;
}
let mut owner = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;
Box::pin(owner.resume_thread(
&app.local_settings,
app.config.clone(),
thread_id,
crate::app_server_session::ResumeModelSettings::PreserveExistingThread,
))
.await?;
let (mut server, requests, proxy) = start_recording_app_server_with_history(
&app.config,
history_capabilities,
/*blocked_thread_list*/ None,
/*failed_thread_name*/ None,
crate::app_server_session::ThreadParamsMode::Embedded,
LoaderOverrides::default(),
)
.await?;
app.app_server_target = AppServerTarget::LocalDaemon {
allow_embedded_fallback: true,
endpoint: crate::resolve_remote_addr("ws://127.0.0.1:4500")?,
};
let current = Box::pin(server.start_thread(&app.config)).await?;
let current_id = current.session.thread_id;
app.enqueue_primary_thread_session(current.session, current.turns)
.await?;
let mut thread = owner
.thread_read(thread_id, /*include_turns*/ false)
.await?;
// Keep the age label stable while the server exercises failure recovery.
thread.updated_at = chrono::Utc::now().timestamp() - 7 * 24 * 60 * 60;
let mut view = app.agents_overview_view(vec![thread], Some(thread_id));
view.handle_paste("Keep this draft".into());
app.chat_widget.show_bottom_pane_view(Box::new(view));
let before = render_bottom_popup(&app.chat_widget, /*width*/ 96);
requests.lock().unwrap().clear();
let mut tui = crate::tui::test_support::make_test_tui()?;
let (tx, mut events) = tokio::sync::mpsc::unbounded_channel();
app.app_event_tx = AppEventSender::new(tx);
app.runtime_approval_policy_override = Some(RuntimeApprovalPolicyOverride::Restored(
AskForApproval::Never,
));
app.runtime_permission_profile_override = Some(
RuntimePermissionProfileOverride::from_restored_config(&app.config),
);
Box::pin(app.select_agents_overview_thread(&mut tui, &mut server, thread_id)).await?;
assert_eq!(recorded_params(&requests, "thread/resume").len(), 1);
assert!(recorded_params(&requests, "turn/start").is_empty());
if matches!(
history_capabilities,
HistoryCapabilities::ReadAfterResumeFails
| HistoryCapabilities::ItemsAndSummaryTurnsFail
) {
let error = render_bottom_popup(&app.chat_widget, /*width*/ 96);
insta::allow_duplicates! {
insta::assert_snapshot!(error, @"
Unable to complete action
Couldn't load this conversation. Please try again.
› 1. Return to command center
enter select · esc back
");
}
assert_eq!(app.current_displayed_thread_id(), Some(current_id));
assert!(recorded_params(&requests, "thread/unsubscribe").is_empty());
app.chat_widget.handle_key_event(KeyCode::Esc.into());
assert_eq!(render_bottom_popup(&app.chat_widget, /*width*/ 96), before);
} else {
assert_eq!(app.current_displayed_thread_id(), Some(thread_id));
assert!(app.chat_widget.is_external_writer_view());
assert_eq!(
(
app.runtime_approval_policy_override,
app.runtime_permission_profile_override.as_ref()
),
(None, None)
);
assert_eq!(
app.thread_event_channels[&thread_id].attachment(),
ThreadEventAttachment::ExternalWriter
);
let turns = app.thread_event_channels[&thread_id]
.store
.lock()
.await
.snapshot()
.turns;
assert!(serde_json::to_string(&turns)?.contains("Locked task"));
if history_capabilities == HistoryCapabilities::ItemsListFails {
let notice = std::iter::from_fn(|| events.try_recv().ok())
.filter_map(|event| match event {
AppEvent::InsertHistoryCell(cell) => {
Some(lines_to_single_string(&cell.display_lines(/*width*/ 200)))
}
_ => None,
})
.find(|message| message.contains("Showing up to 100 recent prompts"))
.expect("summary history notice");
insta::allow_duplicates! {
insta::assert_snapshot!(notice, @"• Showing up to 100 recent prompts and final replies. Intermediate messages and tool activity are unavailable.");
}
assert!(serde_json::to_string(&turns)?.contains("Saved final answer"));
assert!(!recorded_params(&requests, "thread/items/list").is_empty());
assert_eq!(
turns.iter().map(|turn| turn.id.clone()).collect::<Vec<_>>(),
(saved_turn_count.saturating_sub(100)..saved_turn_count)
.map(|index| format!("saved-turn-{index}"))
.collect::<Vec<_>>()
);
assert_eq!(
recorded_params(&requests, "thread/turns/list")
.into_iter()
.filter(|params| params["itemsView"] == "summary")
.count(),
1
);
assert!(
recorded_params(&requests, "thread/read")
.iter()
.all(|params| !params["includeTurns"].as_bool().unwrap_or(false))
);
assert!(!server.has_older_history(thread_id));
}
}
owner.shutdown().await?;
server.shutdown().await?;
proxy.await??;
}
Ok(())
}
#[path = "backend_ownership_tests.rs"]
mod backend_ownership_tests;