Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Add `/presets` for reusable prompts and slash commands (#54380)

Felipe Courydcd9e954598c
diff --git a/codex-rs/tui/src/app.rs b/codex-rs/tui/src/app.rs
index 127651bd28..258944b15c 100644
--- a/codex-rs/tui/src/app.rs
+++ b/codex-rs/tui/src/app.rs
@@ -237,6 +237,7 @@ mod managed_worktree_creation;
mod misalignment_policy;
mod model_defaults;
mod new_session;
+mod quick_dials;
mod turn_tips;
pub(crate) use new_session::has_launch_setting;
mod clipboard;
diff --git a/codex-rs/tui/src/app/event_dispatch.rs b/codex-rs/tui/src/app/event_dispatch.rs
index 8efc33bdbc..ac4cff843a 100644
--- a/codex-rs/tui/src/app/event_dispatch.rs
+++ b/codex-rs/tui/src/app/event_dispatch.rs
@@ -2540,6 +2540,26 @@ impl App {
self.app_event_tx.send(AppEvent::FollowTranscript);
self.select_session_model(app_server, model, effort, service_tier).await;
}
+ AppEvent::OpenQuickDials(mode) => self.chat_widget.open_quick_dials_picker(mode),
+ AppEvent::OpenQuickDialEditor { target, dial } => {
+ self.chat_widget.open_quick_dial_editor(target, dial);
+ }
+ AppEvent::OpenQuickDialPrefills(target) => {
+ self.chat_widget.open_quick_dial_prefills(target);
+ }
+ AppEvent::OpenQuickDialSavePicker(dial) => {
+ self.chat_widget.open_quick_dial_save_picker(dial);
+ }
+ AppEvent::ConfirmQuickDial { slot, dial } => self.chat_widget.confirm_quick_dial(slot, dial),
+ AppEvent::SaveQuickDial { slot, dial } => {
+ self.app_event_tx.send(AppEvent::FollowTranscript);
+ self.save_quick_dial(slot, dial).await;
+ }
+ AppEvent::RecallQuickDial { slot, thread_id } => {
+ if self.chat_widget.thread_id() == thread_id {
+ self.chat_widget.recall_quick_dial(slot);
+ }
+ }
AppEvent::CyberModelAutoReviewNotice => {
self.chat_widget.add_warning_message(
"Cyber models default to \"Approve for me\" for safety reasons.".to_string(),
diff --git a/codex-rs/tui/src/app/model_defaults.rs b/codex-rs/tui/src/app/model_defaults.rs
index 21373a1489..c384559a89 100644
--- a/codex-rs/tui/src/app/model_defaults.rs
+++ b/codex-rs/tui/src/app/model_defaults.rs
@@ -23,8 +23,8 @@ impl App {
effort: Option<ReasoningEffort>,
service_tier: Option<String>,
) {
- let model_changed = self.chat_widget.current_model() != model
- || self.chat_widget.current_collaboration_mode().model() != model;
+ // Changing effort or speed for the effective model must preserve permissions.
+ let model_changed = self.chat_widget.current_model() != model;
let params = if model_changed {
self.active_thread_model_setting_update_params(model.clone())
} else {
@@ -57,7 +57,10 @@ impl App {
if app_server.thread_settings_update_supported {
return;
}
- if service_tier.is_some() {
+ if service_tier
+ .as_deref()
+ .is_some_and(|tier| tier != SERVICE_TIER_DEFAULT_REQUEST_VALUE)
+ {
self.chat_widget.add_error_message(
"Model selection requires an app server with thread/settings/update support."
.into(),
@@ -77,8 +80,13 @@ impl App {
let clear_plan_ultra = self.chat_widget.config_ref().plan_mode_reasoning_effort
== Some(ReasoningEffort::Ultra)
&& self.config.plan_mode_reasoning_effort != Some(ReasoningEffort::Ultra);
- self.chat_widget.set_model(&model);
- if !in_plan_mode || ultra || clear_default_ultra {
+ if model_changed {
+ self.chat_widget.set_model(&model);
+ }
+ if !in_plan_mode
+ || (self.chat_widget.current_collaboration_mode().model() == model
+ && (ultra || clear_default_ultra))
+ {
self.chat_widget.set_reasoning_effort(effort.clone());
}
if in_plan_mode || ultra || clear_plan_ultra {
diff --git a/codex-rs/tui/src/app/quick_dials.rs b/codex-rs/tui/src/app/quick_dials.rs
new file mode 100644
index 0000000000..41414d5e69
--- /dev/null
+++ b/codex-rs/tui/src/app/quick_dials.rs
@@ -0,0 +1,101 @@
+//! Persist numbered prompts and slash commands in the active user configuration.
+//! Replace slots owned by the active user config. Clearing must not reveal a
+//! shadowed slot from another configuration layer.
+
+use super::App;
+use crate::chatwidget::quick_dials::QuickDialEditorTarget;
+use crate::config_update::format_config_error;
+use crate::legacy_core::config::edit::ConfigEdit;
+use crate::legacy_core::config::edit::ConfigEditsBuilder;
+use codex_config::ConfigLayerSource;
+use codex_config::types::QuickDial;
+
+impl App {
+ pub(super) async fn save_quick_dial(&mut self, slot: u8, dial: Option<QuickDial>) {
+ let key = slot.to_string();
+ let read_only = {
+ let mut slot_sources = self
+ .config
+ .config_layer_stack
+ .layers_high_to_low()
+ .filter(|layer| {
+ layer
+ .config
+ .get("tui")
+ .and_then(|tui| tui.get("presets"))
+ .and_then(|dials| dials.get(&key))
+ .is_some()
+ })
+ .map(|layer| &layer.name);
+ let outside_user_config = |source: &ConfigLayerSource| {
+ !matches!(source, ConfigLayerSource::User { file, .. }
+ if file == &self.local_settings.user_config_path)
+ };
+ if dial.is_some() {
+ slot_sources.next().is_some_and(outside_user_config)
+ } else {
+ slot_sources.any(outside_user_config)
+ }
+ };
+ if read_only {
+ self.chat_widget.add_error_message(format!(
+ "Preset {slot} is defined outside your user config. Edit its source configuration instead."
+ ));
+ self.restore_quick_dial_editor(slot, &dial);
+ return;
+ }
+ let segments = vec!["tui".into(), "presets".into(), key.clone()];
+ let edit = match &dial {
+ Some(candidate) => {
+ if let Err(reason) = candidate.validate() {
+ self.chat_widget.add_error_message(reason.into());
+ self.restore_quick_dial_editor(slot, &dial);
+ return;
+ }
+ let mut table = toml_edit::Table::new();
+ table["input"] = toml_edit::value(&candidate.input);
+ // An explicit empty label masks labels inherited from lower layers.
+ table["label"] = toml_edit::value(candidate.label.as_deref().unwrap_or_default());
+ ConfigEdit::SetPath {
+ segments,
+ value: toml_edit::Item::Table(table),
+ }
+ }
+ None => ConfigEdit::ClearPath { segments },
+ };
+ if let Err(error) =
+ ConfigEditsBuilder::for_config_path(self.local_settings.user_config_path.as_path())
+ .with_edits([edit])
+ .apply()
+ .await
+ {
+ self.chat_widget.add_error_message(format!(
+ "Failed to update preset {slot}: {}",
+ format_config_error(&error)
+ ));
+ self.restore_quick_dial_editor(slot, &dial);
+ return;
+ }
+ let message = match dial {
+ Some(mut dial) => {
+ dial.label.get_or_insert_default();
+ self.local_settings.tui.quick_dials.insert(key, dial);
+ format!("Saved preset {slot}.")
+ }
+ None => {
+ self.local_settings.tui.quick_dials.remove(&key);
+ format!("Deleted preset {slot}.")
+ }
+ };
+ self.chat_widget.local_settings.tui.quick_dials =
+ self.local_settings.tui.quick_dials.clone();
+ self.chat_widget.add_info_message(message, /*hint*/ None);
+ }
+
+ fn restore_quick_dial_editor(&mut self, slot: u8, dial: &Option<QuickDial>) {
+ if let Some(dial) = dial {
+ self.chat_widget
+ .open_quick_dial_editor(QuickDialEditorTarget::Slot(slot), Some(dial.clone()));
+ }
+ }
+}
diff --git a/codex-rs/tui/src/app/tests.rs b/codex-rs/tui/src/app/tests.rs
index 5d85e384e5..1c9f52cd85 100644
--- a/codex-rs/tui/src/app/tests.rs
+++ b/codex-rs/tui/src/app/tests.rs
@@ -66,6 +66,8 @@ mod patch_approval_tests;
mod permission_selection_tests;
#[path = "tests/projectless_tests.rs"]
mod projectless_tests;
+#[path = "tests/quick_dials_tests.rs"]
+mod quick_dials_tests;
#[path = "tests/unavailable_commands_tests.rs"]
mod unavailable_commands;
@@ -9722,7 +9724,20 @@ async fn changing_cyber_model_reasoning_preserves_selected_permissions() {
(ReasoningEffortConfig::High, true),
(ReasoningEffortConfig::Ultra, true),
] {
+ app.chat_widget.set_model(&model_name);
if session_only {
+ app.chat_widget.set_model("different-base-model");
+ let default_mode = app.chat_widget.current_collaboration_mode().clone();
+ app.chat_widget
+ .set_feature_enabled(Feature::CollaborationModes, /*enabled*/ true);
+ app.chat_widget
+ .set_collaboration_mask(CollaborationModeMask {
+ name: "Plan".to_string(),
+ mode: Some(ModeKind::Plan),
+ model: Some(model_name.clone()),
+ reasoning_effort: Some(Some(effort.clone())),
+ developer_instructions: None,
+ });
app.handle_event(
&mut tui,
&mut app_server,
@@ -9734,6 +9749,7 @@ async fn changing_cyber_model_reasoning_preserves_selected_permissions() {
)
.await
.expect("session-only reasoning selection should succeed");
+ assert_eq!(app.chat_widget.current_collaboration_mode(), &default_mode);
} else if effort == ReasoningEffortConfig::Ultra {
app.chat_widget
.set_feature_enabled(Feature::CollaborationModes, /*enabled*/ true);
diff --git a/codex-rs/tui/src/app/tests/model_defaults_tests.rs b/codex-rs/tui/src/app/tests/model_defaults_tests.rs
index 5841fd45bf..cdd5ac657b 100644
--- a/codex-rs/tui/src/app/tests/model_defaults_tests.rs
+++ b/codex-rs/tui/src/app/tests/model_defaults_tests.rs
@@ -2,6 +2,7 @@ use super::*;
use crate::collaboration_modes;
use codex_app_server_client::AppServerClient;
use codex_config::LoaderOverrides;
+use codex_protocol::config_types::SERVICE_TIER_DEFAULT_REQUEST_VALUE;
use crossterm::event::KeyCode;
use pretty_assertions::assert_eq;
@@ -115,6 +116,44 @@ async fn session_model_selection_preserves_defaults_and_updates_active_thread()
Ok(())
}
+#[tokio::test]
+async fn standard_speed_selection_falls_back_for_older_app_servers() -> Result<()> {
+ let (mut app, mut events, mut ops) = make_test_app_with_channels().await;
+ app.config.service_tier = Some("flex".into());
+ let mut server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;
+ let started = server.start_thread(&app.config).await?;
+ app.enqueue_primary_thread_session(started.session, started.turns)
+ .await?;
+ app.chat_widget.set_service_tier(Some("flex".into()));
+ server.thread_settings_update_supported = false;
+ while events.try_recv().is_ok() {}
+ while ops.try_recv().is_ok() {}
+
+ app.select_session_model(
+ &mut server,
+ "gpt-5.6-terra".into(),
+ Some(ReasoningEffortConfig::High),
+ Some(SERVICE_TIER_DEFAULT_REQUEST_VALUE.into()),
+ )
+ .await;
+
+ assert_eq!(
+ app.chat_widget.current_service_tier(),
+ Some(SERVICE_TIER_DEFAULT_REQUEST_VALUE)
+ );
+ assert_eq!(app.config.service_tier.as_deref(), Some("flex"));
+ app.chat_widget.apply_external_edit("continue".into());
+ app.chat_widget.handle_key_event(KeyCode::Esc.into());
+ app.chat_widget.handle_key_event(KeyCode::Enter.into());
+ assert_matches!(
+ next_user_turn_op(&mut ops),
+ Op::UserTurn { service_tier, .. }
+ if service_tier == Some(Some(SERVICE_TIER_DEFAULT_REQUEST_VALUE.into()))
+ );
+ server.shutdown().await?;
+ Ok(())
+}
+
#[tokio::test]
async fn model_default_saves_report_server_outcomes_and_target_server_profile() -> Result<()> {
for outcome in ["saved", "overridden", "rejected"] {
diff --git a/codex-rs/tui/src/app/tests/quick_dials_tests.rs b/codex-rs/tui/src/app/tests/quick_dials_tests.rs
new file mode 100644
index 0000000000..c18e16e858
--- /dev/null
+++ b/codex-rs/tui/src/app/tests/quick_dials_tests.rs
@@ -0,0 +1,195 @@
+//! Preset persistence tests for file writes, layer ownership, and failure atomicity.
+
+use super::*;
+use codex_config::LoaderOverrides;
+use codex_config::types::QuickDial;
+use pretty_assertions::assert_eq;
+
+#[tokio::test]
+async fn quick_dials_persist_save_replace_and_delete() -> Result<()> {
+ let (mut app, _events, _ops) = make_test_app_with_channels().await;
+ let config_path = app.local_settings.user_config_path.clone();
+ std::fs::write(
+ config_path.as_path(),
+ "# Keep this setting.\n[tui]\nshow_tooltips = false\n",
+ )?;
+
+ let first = QuickDial {
+ input: "Review the current changes".into(),
+ label: None,
+ };
+ app.save_quick_dial(/*slot*/ 3, Some(first)).await;
+ let saved = QuickDial {
+ input: "Review the current changes".into(),
+ label: Some(String::new()),
+ };
+ assert_eq!(
+ (
+ app.local_settings.tui.quick_dials.get("3"),
+ app.chat_widget.local_settings.tui.quick_dials.get("3"),
+ ),
+ (Some(&saved), Some(&saved))
+ );
+
+ let replacement = QuickDial {
+ input: "/model gpt-5.6-terra --reasoning=high --speed=fast".into(),
+ label: Some("deep review".into()),
+ };
+ app.save_quick_dial(/*slot*/ 3, Some(replacement.clone()))
+ .await;
+ let reloaded = ConfigBuilder::default()
+ .codex_home(app.config.codex_home.to_path_buf())
+ .loader_overrides(LoaderOverrides::without_managed_config_for_tests())
+ .build()
+ .await?;
+ assert_eq!(reloaded.tui_quick_dials, [("3".into(), replacement)].into());
+ assert!(!reloaded.show_tooltips);
+
+ app.save_quick_dial(/*slot*/ 3, /*dial*/ None).await;
+ let reloaded = ConfigBuilder::default()
+ .codex_home(app.config.codex_home.to_path_buf())
+ .loader_overrides(LoaderOverrides::without_managed_config_for_tests())
+ .build()
+ .await?;
+ assert!(reloaded.tui_quick_dials.is_empty());
+ assert!(app.local_settings.tui.quick_dials.is_empty());
+ assert!(app.chat_widget.local_settings.tui.quick_dials.is_empty());
+ assert!(!reloaded.show_tooltips);
+ Ok(())
+}
+
+#[tokio::test]
+async fn quick_dials_respect_profile_and_external_ownership() -> Result<()> {
+ let (mut app, mut events, _ops) = make_test_app_with_channels().await;
+ let codex_home = app.config.codex_home.to_path_buf();
+ let base_path = app.local_settings.user_config_path.clone();
+ let profile_path = AbsolutePathBuf::from_absolute_path(codex_home.join("work.config.toml"))?;
+ std::fs::write(
+ base_path.as_path(),
+ "[tui.presets.1]\ninput = 'base prompt'\nlabel = 'base label'\n",
+ )?;
+ std::fs::write(
+ profile_path.as_path(),
+ "[tui.presets.1]\ninput = 'profile prompt'\n",
+ )?;
+ let mut loader_overrides = LoaderOverrides::without_managed_config_for_tests();
+ loader_overrides.user_config_path = Some(profile_path.clone());
+ loader_overrides.user_config_profile = Some("work".parse()?);
+ let external =
+ toml::from_str::<toml::Value>("input = 'externally managed prompt'\nlabel = 'external'\n")?;
+ let config = ConfigBuilder::default()
+ .codex_home(codex_home)
+ .loader_overrides(loader_overrides)
+ .cli_overrides(vec![("tui.presets.2".into(), external)])
+ .build()
+ .await?;
+ app.config.config_layer_stack = config.config_layer_stack.clone();
+ app.local_settings = crate::local_settings::LocalSettings::from(&config);
+ app.chat_widget.local_settings = app.local_settings.clone();
+
+ let replacement = QuickDial {
+ input: "replacement prompt".into(),
+ label: None,
+ };
+ app.save_quick_dial(/*slot*/ 1, Some(replacement.clone()))
+ .await;
+ assert_eq!(
+ toml::from_str::<toml::Value>(&std::fs::read_to_string(profile_path.as_path())?)?,
+ toml::from_str::<toml::Value>(
+ "[tui.presets.1]\ninput = 'replacement prompt'\nlabel = ''\n"
+ )?
+ );
+ assert_eq!(
+ std::fs::read_to_string(base_path.as_path())?,
+ "[tui.presets.1]\ninput = 'base prompt'\nlabel = 'base label'\n"
+ );
+
+ while events.try_recv().is_ok() {}
+ let profile_before_rejections = std::fs::read(profile_path.as_path())?;
+ let dials_before_rejections = app.local_settings.tui.quick_dials.clone();
+ app.save_quick_dial(/*slot*/ 1, /*dial*/ None).await;
+ app.save_quick_dial(
+ /*slot*/ 2,
+ Some(QuickDial {
+ input: "local replacement".into(),
+ label: None,
+ }),
+ )
+ .await;
+ assert_eq!(
+ (
+ std::fs::read(profile_path.as_path())?,
+ &app.local_settings.tui.quick_dials,
+ &app.chat_widget.local_settings.tui.quick_dials,
+ ),
+ (
+ profile_before_rejections,
+ &dials_before_rejections,
+ &dials_before_rejections,
+ )
+ );
+ let errors = std::iter::from_fn(|| events.try_recv().ok())
+ .filter_map(|event| match event {
+ AppEvent::InsertHistoryCell(cell) => {
+ Some(lines_to_single_string(
+ &cell.transcript_lines(/*width*/ 200),
+ ))
+ }
+ _ => None,
+ })
+ .filter(|message| message.contains("defined outside your user config"))
+ .count();
+ assert_eq!(errors, 2);
+ Ok(())
+}
+
+#[tokio::test]
+async fn quick_dial_write_failure_leaves_file_and_memory_unchanged() -> Result<()> {
+ let (mut app, mut events, _ops) = make_test_app_with_channels().await;
+ let config_path = app.local_settings.user_config_path.clone();
+ let existing = QuickDial {
+ input: "existing prompt".into(),
+ label: Some("existing".into()),
+ };
+ app.local_settings
+ .tui
+ .quick_dials
+ .insert("4".into(), existing);
+ app.chat_widget.local_settings = app.local_settings.clone();
+ std::fs::write(config_path.as_path(), "[broken")?;
+ let file_before = std::fs::read(config_path.as_path())?;
+ let dials_before = app.local_settings.tui.quick_dials.clone();
+ while events.try_recv().is_ok() {}
+
+ app.save_quick_dial(
+ /*slot*/ 4,
+ Some(QuickDial {
+ input: "replacement prompt".into(),
+ label: None,
+ }),
+ )
+ .await;
+
+ assert_eq!(
+ (
+ std::fs::read(config_path.as_path())?,
+ &app.local_settings.tui.quick_dials,
+ &app.chat_widget.local_settings.tui.quick_dials,
+ ),
+ (file_before, &dials_before, &dials_before)
+ );
+ let messages = std::iter::from_fn(|| events.try_recv().ok())
+ .filter_map(|event| match event {
+ AppEvent::InsertHistoryCell(cell) => {
+ Some(lines_to_single_string(
+ &cell.transcript_lines(/*width*/ 200),
+ ))
+ }
+ _ => None,
+ })
+ .collect::<Vec<_>>()
+ .join("\n");
+ assert!(messages.contains("Failed to update preset 4"));
+ assert!(!messages.contains("Saved preset 4"));
+ Ok(())
+}
diff --git a/codex-rs/tui/src/app_event.rs b/codex-rs/tui/src/app_event.rs
index 613178d0c1..04af70635f 100644
--- a/codex-rs/tui/src/app_event.rs
+++ b/codex-rs/tui/src/app_event.rs
@@ -1276,6 +1276,26 @@ pub(crate) enum AppEvent {
service_tier: Option<String>,
},
+ OpenQuickDials(crate::chatwidget::quick_dials::QuickDialPickerMode),
+ OpenQuickDialEditor {
+ target: crate::chatwidget::quick_dials::QuickDialEditorTarget,
+ dial: Option<codex_config::types::QuickDial>,
+ },
+ OpenQuickDialPrefills(crate::chatwidget::quick_dials::QuickDialEditorTarget),
+ OpenQuickDialSavePicker(codex_config::types::QuickDial),
+ ConfirmQuickDial {
+ slot: u8,
+ dial: Option<codex_config::types::QuickDial>,
+ },
+ SaveQuickDial {
+ slot: u8,
+ dial: Option<codex_config::types::QuickDial>,
+ },
+ RecallQuickDial {
+ slot: u8,
+ thread_id: Option<ThreadId>,
+ },
+
/// Show the cyber auto-review notice after the model selection confirmation.
CyberModelAutoReviewNotice,
diff --git a/codex-rs/tui/src/bottom_pane/custom_prompt_view.rs b/codex-rs/tui/src/bottom_pane/custom_prompt_view.rs
index 061fec4ff4..4c53bb2481 100644
--- a/codex-rs/tui/src/bottom_pane/custom_prompt_view.rs
+++ b/codex-rs/tui/src/bottom_pane/custom_prompt_view.rs
@@ -49,6 +49,9 @@ pub(crate) struct CustomPromptView {
placeholder: String,
context_label: Option<String>,
on_submit: PromptSubmitted,
+ submit_label: &'static str,
+ preserve_whitespace: bool,
+ dismiss_after_child_accept: bool,
// UI state
textarea: TextArea,
@@ -78,6 +81,9 @@ impl CustomPromptView {
placeholder,
context_label,
on_submit,
+ submit_label: "submit",
+ preserve_whitespace: false,
+ dismiss_after_child_accept: false,
textarea,
textarea_state: RefCell::new(TextAreaState::default()),
paste_burst: PasteBurst::default(),
@@ -87,6 +93,19 @@ impl CustomPromptView {
}
}
+ /// Keep the prompt open while its submission opens a child view.
+ pub(crate) fn with_child_flow(mut self, submit_label: &'static str) -> Self {
+ self.submit_label = submit_label;
+ self.dismiss_after_child_accept = true;
+ self
+ }
+
+ /// Submit the editor contents without trimming their surrounding whitespace.
+ pub(crate) fn preserve_whitespace(mut self) -> Self {
+ self.preserve_whitespace = true;
+ self
+ }
+
/// Apply the same editor and Vim bindings used by the main composer.
pub(crate) fn set_keymap_bindings(&mut self, keymap: &RuntimeKeymap) {
self.textarea.set_keymap_bindings(keymap);
@@ -151,10 +170,17 @@ impl CustomPromptView {
return;
}
if modifiers == KeyModifiers::NONE {
- let text = self.textarea.text().trim().to_string();
- if !text.is_empty() {
+ let text = self.textarea.text();
+ if !text.trim().is_empty() {
+ let text = if self.preserve_whitespace {
+ text.to_string()
+ } else {
+ text.trim().to_string()
+ };
(self.on_submit)(text);
- self.completion = Some(ViewCompletion::Accepted);
+ if !self.dismiss_after_child_accept {
+ self.completion = Some(ViewCompletion::Accepted);
+ }
}
} else {
self.textarea.input(key_event);
@@ -219,6 +245,10 @@ impl BottomPaneView for CustomPromptView {
self.completion
}
+ fn dismiss_after_child_accept(&self) -> bool {
+ self.dismiss_after_child_accept
+ }
+
fn handle_paste(&mut self, pasted: String) -> bool {
if pasted.is_empty() {
return false;
diff --git a/codex-rs/tui/src/bottom_pane/custom_prompt_view/picker.rs b/codex-rs/tui/src/bottom_pane/custom_prompt_view/picker.rs
index 947e864d58..5d5f734b14 100644
--- a/codex-rs/tui/src/bottom_pane/custom_prompt_view/picker.rs
+++ b/codex-rs/tui/src/bottom_pane/custom_prompt_view/picker.rs
@@ -100,7 +100,7 @@ impl CustomPromptView {
};
let hint = Line::from(vec![
key_hint::plain(KeyCode::Enter).into(),
- " submit · ".dim(),
+ format!(" {} · ", self.submit_label).dim(),
key_hint::plain(KeyCode::Esc).into(),
cancel_label.dim(),
]);
diff --git a/codex-rs/tui/src/bottom_pane/list_selection_view.rs b/codex-rs/tui/src/bottom_pane/list_selection_view.rs
index 19f365028c..a5f5458ed3 100644
--- a/codex-rs/tui/src/bottom_pane/list_selection_view.rs
+++ b/codex-rs/tui/src/bottom_pane/list_selection_view.rs
@@ -235,6 +235,8 @@ pub(crate) struct SelectionViewParams {
/// Optional non-text key that can toggle a row while printable keys edit the search query.
pub search_toggle_key: Option<KeyBinding>,
pub search_mode: SearchMode,
+ /// Use ordinal digits in the gutter; when false, use only each row's explicit shortcut.
+ pub auto_number_shortcuts: bool,
pub search_placeholder: Option<String>,
pub col_width_mode: ColumnWidthMode,
pub row_display: SelectionRowDisplay,
@@ -301,6 +303,7 @@ impl Default for SelectionViewParams {
is_searchable: false,
search_toggle_key: None,
search_mode: SearchMode::default(),
+ auto_number_shortcuts: true,
search_placeholder: None,
col_width_mode: ColumnWidthMode::AutoVisible,
row_display: SelectionRowDisplay::Wrapped,
@@ -358,6 +361,7 @@ pub(crate) struct ListSelectionView {
search_toggle_key: Option<KeyBinding>,
search_mode: SearchMode,
search_active: bool,
+ auto_number_shortcuts: bool,
search_query: String,
search_placeholder: Option<String>,
col_width_mode: ColumnWidthMode,
@@ -515,6 +519,7 @@ impl ListSelectionView {
search_mode: params.search_mode,
search_active,
search_query,
+ auto_number_shortcuts: params.auto_number_shortcuts,
search_placeholder: if params.is_searchable {
params.search_placeholder
} else {
@@ -764,6 +769,11 @@ impl ListSelectionView {
// The number keys don't work when search is enabled (since we let the
// numbers be used for the search query).
format!("{prefix} ")
+ } else if !self.auto_number_shortcuts {
+ item.display_shortcut.map_or_else(
+ || format!("{prefix} "),
+ |shortcut| format!("{prefix} {}. ", shortcut.display_label()),
+ )
} else if is_disabled {
if let Some(disabled_gutter_marker) = item.disabled_gutter_marker {
let marker_width = UnicodeWidthStr::width(disabled_gutter_marker);
@@ -798,7 +808,10 @@ impl ListSelectionView {
selection_style: row_selection_style,
name: name_with_marker,
name_prefix_spans,
- display_shortcut: item.display_shortcut,
+ display_shortcut: self
+ .auto_number_shortcuts
+ .then_some(item.display_shortcut)
+ .flatten(),
match_indices: None,
description,
wrap_indent,
@@ -1419,10 +1432,11 @@ impl BottomPaneView for ListSelectionView {
self.select_shortcut(idx);
return;
}
- if let Some(idx) = c
- .to_digit(10)
- .map(|d| d as usize)
- .and_then(|number| self.actual_idx_for_enabled_number(number))
+ if self.auto_number_shortcuts
+ && let Some(idx) = c
+ .to_digit(/*radix*/ 10)
+ .map(|d| d as usize)
+ .and_then(|number| self.actual_idx_for_enabled_number(number))
{
self.select_shortcut(idx);
}
diff --git a/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__vim_empty_normal_slash.snap b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__vim_empty_normal_slash.snap
index d7125e250d..2ad183893b 100644
--- a/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__vim_empty_normal_slash.snap
+++ b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__vim_empty_normal_slash.snap
@@ -1,13 +1,12 @@
---
source: tui/src/bottom_pane/chat_composer.rs
-assertion_line: 5217
expression: terminal.backend()
---
"› /model choose what model and reasoning effort to "
" use "
+" /presets run or save reusable prompts and slash "
+" commands "
" /ide include current selection, open files, and"
-" other context from your IDE "
-" /permissions choose what Codex is allowed to do "
" "
"› / "
" "
diff --git a/codex-rs/tui/src/chatwidget.rs b/codex-rs/tui/src/chatwidget.rs
index ab13bba827..06aa1abc66 100644
--- a/codex-rs/tui/src/chatwidget.rs
+++ b/codex-rs/tui/src/chatwidget.rs
@@ -326,6 +326,7 @@ mod model_command;
mod model_popup_state;
mod model_popups;
mod notifications;
+pub(crate) mod quick_dials;
mod session_model_selection;
use self::notifications::Notification;
pub(crate) use self::session_model_selection::AstraModelPickerAction;
diff --git a/codex-rs/tui/src/chatwidget/input_flow.rs b/codex-rs/tui/src/chatwidget/input_flow.rs
index 5b44cac1b0..6a089a0039 100644
--- a/codex-rs/tui/src/chatwidget/input_flow.rs
+++ b/codex-rs/tui/src/chatwidget/input_flow.rs
@@ -28,6 +28,7 @@ impl ChatWidget {
// Inline commands still follow so their output (including usage errors) is visible.
InputResult::Command(
SlashCommand::Model
+ | SlashCommand::Presets
| SlashCommand::Keymap
| SlashCommand::Memories
| SlashCommand::Config
diff --git a/codex-rs/tui/src/chatwidget/quick_dials.rs b/codex-rs/tui/src/chatwidget/quick_dials.rs
new file mode 100644
index 0000000000..e731623a50
--- /dev/null
+++ b/codex-rs/tui/src/chatwidget/quick_dials.rs
@@ -0,0 +1,458 @@
+//! Numbered reusable inputs using the existing picker and queued submission path.
+//! Saving leaves the draft untouched; recall preserves drafts and obeys normal command gates.
+
+use super::*;
+use crate::wrapping::word_wrap_lines;
+use codex_config::types::QuickDial;
+use codex_protocol::config_types::SERVICE_TIER_DEFAULT_REQUEST_VALUE;
+
+struct QuickDialConfirmationHeader(Vec<Line<'static>>);
+
+impl Renderable for QuickDialConfirmationHeader {
+ fn render(&self, area: Rect, buf: &mut Buffer) {
+ Renderable::render(
+ &Paragraph::new(word_wrap_lines(&self.0, usize::from(area.width))),
+ area,
+ buf,
+ );
+ }
+ fn desired_height(&self, width: u16) -> u16 {
+ word_wrap_lines(&self.0, usize::from(width)).len() as u16
+ }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum QuickDialPickerMode {
+ Recall,
+ Save,
+ Edit,
+ Clear,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum QuickDialEditorTarget {
+ PickSlot,
+ Slot(u8),
+}
+
+#[derive(Clone, Copy)]
+enum QuickDialMenuAction {
+ New,
+ Edit,
+ Prefill,
+ Clear,
+}
+
+fn quick_dial_label(dial: &QuickDial) -> String {
+ dial.label
+ .as_deref()
+ .filter(|label| !label.trim().is_empty())
+ .unwrap_or(&dial.input)
+ .trim_start()
+ .lines()
+ .next()
+ .unwrap_or_default()
+ .to_string()
+}
+
+impl ChatWidget {
+ fn composer_quick_dial_text(&mut self) -> String {
+ if !self.bottom_pane.composer_local_images().is_empty()
+ || !self.bottom_pane.remote_image_urls().is_empty()
+ {
+ self.add_info_message(
+ "Images cannot be copied into a preset. Starting with empty text.".into(),
+ /*hint*/ None,
+ );
+ return String::new();
+ }
+ if !self
+ .bottom_pane
+ .composer_draft_snapshot()
+ .mention_bindings
+ .is_empty()
+ {
+ self.add_info_message(
+ "Linked mentions cannot be copied into a preset. Starting with empty text.".into(),
+ /*hint*/ None,
+ );
+ return String::new();
+ }
+ self.bottom_pane.composer_text_with_pending()
+ }
+
+ pub(super) fn current_model_quick_dial(&self) -> Result<QuickDial, &'static str> {
+ let Some(model) = self
+ .model_catalog
+ .models
+ .iter()
+ .find(|model| model.model == self.current_model() && model.show_in_picker)
+ .filter(|_| !self.restrict_model_picker_to_luna_reserve())
+ else {
+ return Err("The current model cannot be recalled with /model.");
+ };
+ let mut input = format!("/model {}", self.current_model());
+ if let Some(effort) = self.current_reasoning_effort() {
+ let supported = if model.supported_reasoning_efforts.is_empty() {
+ effort == model.default_reasoning_effort
+ } else {
+ model
+ .supported_reasoning_efforts
+ .iter()
+ .any(|option| option.effort == effort)
+ };
+ if !supported {
+ return Err("Choose an available reasoning effort with /model before saving.");
+ }
+ input.push_str(&format!(" --reasoning={effort}"));
+ }
+ let speed = self
+ .current_service_tier()
+ .filter(|tier| *tier != SERVICE_TIER_DEFAULT_REQUEST_VALUE)
+ .unwrap_or("standard");
+ if !matches!(speed, "standard" | "flex")
+ && !model
+ .service_tiers
+ .iter()
+ .any(|tier| tier.id == speed && self.config.features.service_tier_enabled(&tier.id))
+ {
+ return Err("Choose an available speed with /model before saving.");
+ }
+ input.push_str(&format!(" --speed={speed}"));
+ let dial = QuickDial { input, label: None };
+ dial.validate()?;
+ Ok(dial)
+ }
+
+ fn quick_dials_available(&mut self) -> bool {
+ if self.blocks_direct_input
+ || self.active_side_conversation
+ || !self.bottom_pane.composer_input_enabled()
+ {
+ self.add_error_message("Presets are unavailable in this conversation.".into());
+ return false;
+ }
+ if !self.is_session_configured() {
+ self.add_info_message(
+ "Presets are available after startup completes.".into(),
+ /*hint*/ None,
+ );
+ return false;
+ }
+ true
+ }
+
+ pub(crate) fn recall_quick_dial(&mut self, slot: u8) {
+ if !self.quick_dials_available() {
+ return;
+ }
+ let Some(dial) = self
+ .local_settings
+ .tui
+ .quick_dials
+ .get(&slot.to_string())
+ .cloned()
+ else {
+ return;
+ };
+ if let Err(reason) = dial.validate() {
+ self.add_error_message(format!("Preset {slot}: {reason}"));
+ return;
+ }
+ self.app_event_tx.send(AppEvent::FollowTranscript);
+ self.queue_user_message_with_options(
+ dial.input.into(),
+ QueuedInputAction::ParseSlash,
+ Vec::new(),
+ );
+ }
+
+ pub(crate) fn open_quick_dials_picker(&mut self, mode: QuickDialPickerMode) {
+ if !self.quick_dials_available() {
+ return;
+ }
+ self.show_quick_dials_picker(mode, /*current*/ None);
+ }
+
+ pub(crate) fn open_quick_dial_save_picker(&mut self, dial: QuickDial) {
+ if let Err(reason) = dial.validate() {
+ self.add_error_message(reason.into());
+ return;
+ }
+ self.show_quick_dials_picker(QuickDialPickerMode::Save, Some(dial));
+ }
+
+ fn show_quick_dials_picker(&mut self, mode: QuickDialPickerMode, current: Option<QuickDial>) {
+ let thread_id = self.thread_id();
+ let mut items = Vec::new();
+ for slot in (1..=9).chain(std::iter::once(/*value*/ 0)) {
+ let saved = self.local_settings.tui.quick_dials.get(&slot.to_string());
+ if mode == QuickDialPickerMode::Edit && saved.is_none() {
+ continue;
+ }
+ let dial = current.clone();
+ let saved_for_edit = saved.cloned();
+ let has_saved = saved.is_some();
+ let (is_disabled, dismiss_on_select, dismiss_parent_on_child_accept) = match mode {
+ QuickDialPickerMode::Recall => (!has_saved, true, false),
+ QuickDialPickerMode::Save => (dial.is_none(), !has_saved, has_saved),
+ QuickDialPickerMode::Edit => (false, false, true),
+ QuickDialPickerMode::Clear => (!has_saved, false, true),
+ };
+ items.push(SelectionItem {
+ name: saved.map(quick_dial_label).unwrap_or_default(),
+ name_prefix_spans: if saved.is_none() {
+ vec!["empty".dim()]
+ } else {
+ Vec::new()
+ },
+ description: saved
+ .filter(|dial| {
+ dial.label
+ .as_deref()
+ .is_some_and(|label| !label.trim().is_empty())
+ })
+ .map(|dial| dial.input.clone()),
+ display_shortcut: Some(
+ key_hint::plain(KeyCode::Char(char::from(b'0' + slot))).into(),
+ ),
+ is_disabled,
+ actions: vec![Box::new(move |tx| {
+ let event = match mode {
+ QuickDialPickerMode::Recall => {
+ AppEvent::RecallQuickDial { slot, thread_id }
+ }
+ QuickDialPickerMode::Save if has_saved => AppEvent::ConfirmQuickDial {
+ slot,
+ dial: dial.clone(),
+ },
+ QuickDialPickerMode::Save => AppEvent::SaveQuickDial {
+ slot,
+ dial: dial.clone(),
+ },
+ QuickDialPickerMode::Edit => AppEvent::OpenQuickDialEditor {
+ target: QuickDialEditorTarget::Slot(slot),
+ dial: saved_for_edit.clone(),
+ },
+ QuickDialPickerMode::Clear => {
+ AppEvent::ConfirmQuickDial { slot, dial: None }
+ }
+ };
+ tx.send(event);
+ })],
+ dismiss_on_select,
+ dismiss_parent_on_child_accept,
+ ..Default::default()
+ });
+ }
+ if mode == QuickDialPickerMode::Recall {
+ for (key, name, action) in [
+ (Some('s'), "New preset…", QuickDialMenuAction::New),
+ (Some('e'), "Edit a preset…", QuickDialMenuAction::Edit),
+ (
+ None,
+ "Start from current settings…",
+ QuickDialMenuAction::Prefill,
+ ),
+ (Some('d'), "Delete a preset…", QuickDialMenuAction::Clear),
+ ] {
+ let is_disabled = matches!(
+ action,
+ QuickDialMenuAction::Edit | QuickDialMenuAction::Clear
+ ) && self.local_settings.tui.quick_dials.is_empty();
+ items.push(SelectionItem {
+ name: name.into(),
+ display_shortcut: key.map(|key| key_hint::plain(KeyCode::Char(key)).into()),
+ actions: vec![Box::new(move |tx| {
+ tx.send(match action {
+ QuickDialMenuAction::New => AppEvent::OpenQuickDialEditor {
+ target: QuickDialEditorTarget::PickSlot,
+ dial: None,
+ },
+ QuickDialMenuAction::Edit => {
+ AppEvent::OpenQuickDials(QuickDialPickerMode::Edit)
+ }
+ QuickDialMenuAction::Prefill => {
+ AppEvent::OpenQuickDialPrefills(QuickDialEditorTarget::PickSlot)
+ }
+ QuickDialMenuAction::Clear => {
+ AppEvent::OpenQuickDials(QuickDialPickerMode::Clear)
+ }
+ })
+ })],
+ is_disabled,
+ dismiss_parent_on_child_accept: true,
+ ..Default::default()
+ });
+ }
+ }
+ let title = match mode {
+ QuickDialPickerMode::Recall => "Presets",
+ QuickDialPickerMode::Save => "Save preset to slot",
+ QuickDialPickerMode::Edit => "Edit a preset",
+ QuickDialPickerMode::Clear => "Delete a preset",
+ };
+ let initial_selected_idx = (mode == QuickDialPickerMode::Save).then(|| {
+ (1..=9)
+ .chain(std::iter::once(/*value*/ 0))
+ .position(|slot| {
+ !self
+ .local_settings
+ .tui
+ .quick_dials
+ .contains_key(&slot.to_string())
+ })
+ .unwrap_or(/*default*/ 0)
+ });
+ self.bottom_pane.show_selection_view(SelectionViewParams {
+ view_id: Some("quick-dials"),
+ auto_number_shortcuts: false,
+ initial_selected_idx,
+ max_visible_rows: 14,
+ title: Some(title.into()),
+ subtitle: (mode == QuickDialPickerMode::Save)
+ .then(|| current.as_ref().map(quick_dial_label))
+ .flatten(),
+ items,
+ ..SelectionViewParams::picker()
+ });
+ self.defer_input_until_settings_applied();
+ }
+
+ pub(crate) fn open_quick_dial_editor(
+ &mut self,
+ target: QuickDialEditorTarget,
+ dial: Option<QuickDial>,
+ ) {
+ if !self.quick_dials_available() {
+ return;
+ }
+ let slot = match target {
+ QuickDialEditorTarget::PickSlot => None,
+ QuickDialEditorTarget::Slot(slot) => Some(slot),
+ };
+ let dial = dial.unwrap_or_else(|| QuickDial {
+ input: self.composer_quick_dial_text(),
+ label: None,
+ });
+ let title = slot
+ .filter(|slot| {
+ self.local_settings
+ .tui
+ .quick_dials
+ .contains_key(&slot.to_string())
+ })
+ .map_or_else(
+ || "New preset".to_string(),
+ |slot| format!("Edit preset {slot}"),
+ );
+ let submit_label = if slot.is_some() {
+ "review changes"
+ } else {
+ "choose slot"
+ };
+ let tx = self.app_event_tx.clone();
+ let label = dial.label;
+ let view = CustomPromptView::new(
+ title,
+ "Write a prompt or slash command".to_string(),
+ dial.input,
+ /*context_label*/ None,
+ Box::new(move |input| {
+ let dial = QuickDial {
+ input,
+ label: label.clone(),
+ };
+ tx.send(match target {
+ QuickDialEditorTarget::PickSlot => AppEvent::OpenQuickDialSavePicker(dial),
+ QuickDialEditorTarget::Slot(slot) => AppEvent::ConfirmQuickDial {
+ slot,
+ dial: Some(dial),
+ },
+ });
+ }),
+ )
+ .with_child_flow(submit_label)
+ .preserve_whitespace();
+ self.bottom_pane.show_text_prompt(view);
+ self.defer_input_until_settings_applied();
+ }
+
+ pub(crate) fn open_quick_dial_prefills(&mut self, target: QuickDialEditorTarget) {
+ if !self.quick_dials_available() {
+ return;
+ }
+ let model = self.current_model_quick_dial();
+ let (description, is_disabled, actions) = match model {
+ Ok(dial) => {
+ let description = Some(dial.input.clone());
+ let actions = vec![Box::new(move |tx: &AppEventSender| {
+ tx.send(AppEvent::OpenQuickDialEditor {
+ target,
+ dial: Some(dial.clone()),
+ })
+ }) as SelectionAction];
+ (description, false, actions)
+ }
+ Err(reason) => (Some(reason.into()), true, Vec::new()),
+ };
+ self.bottom_pane.show_selection_view(SelectionViewParams {
+ view_id: Some("quick-dial-prefills"),
+ max_visible_rows: 1,
+ title: Some("Start preset from current settings".into()),
+ items: vec![SelectionItem {
+ name: "Current model".into(),
+ description,
+ is_disabled,
+ actions,
+ dismiss_parent_on_child_accept: true,
+ ..Default::default()
+ }],
+ ..SelectionViewParams::picker()
+ });
+ self.defer_input_until_settings_applied();
+ }
+
+ pub(crate) fn confirm_quick_dial(&mut self, slot: u8, dial: Option<QuickDial>) {
+ if let Some(dial) = &dial
+ && let Err(reason) = dial.validate()
+ {
+ self.add_error_message(reason.into());
+ return;
+ }
+ let saved = self.local_settings.tui.quick_dials.get(&slot.to_string());
+ let (action, description) = match (saved, &dial) {
+ (Some(old), Some(new)) => (
+ "Replace",
+ format!("{}\n→ {}", old.input.trim(), new.input.trim()),
+ ),
+ (Some(old), None) => ("Delete", quick_dial_label(old)),
+ (None, Some(new)) => ("Save", new.input.trim().to_string()),
+ (None, None) => return,
+ };
+ self.bottom_pane.show_selection_view(SelectionViewParams {
+ header: Box::new(QuickDialConfirmationHeader(
+ std::iter::once(Line::from(format!("{action} preset {slot}?").bold()))
+ .chain(
+ description
+ .lines()
+ .map(|line| Line::from(line.to_string().dim())),
+ )
+ .collect(),
+ )),
+ items: vec![SelectionItem {
+ name: format!("{action} preset {slot}"),
+ require_explicit_confirmation: true,
+ actions: vec![Box::new(move |tx| {
+ tx.send(AppEvent::SaveQuickDial {
+ slot,
+ dial: dial.clone(),
+ })
+ })],
+ dismiss_on_select: true,
+ ..Default::default()
+ }],
+ ..SelectionViewParams::picker()
+ });
+ }
+}
diff --git a/codex-rs/tui/src/chatwidget/slash_dispatch.rs b/codex-rs/tui/src/chatwidget/slash_dispatch.rs
index 1664e493eb..46fe775d17 100644
--- a/codex-rs/tui/src/chatwidget/slash_dispatch.rs
+++ b/codex-rs/tui/src/chatwidget/slash_dispatch.rs
@@ -378,6 +378,9 @@ impl ChatWidget {
self.open_model_popup();
self.defer_input_until_settings_applied();
}
+ SlashCommand::Presets => {
+ self.open_quick_dials_picker(quick_dials::QuickDialPickerMode::Recall);
+ }
SlashCommand::Plan => {
self.apply_plan_slash_command();
}
@@ -1318,6 +1321,7 @@ impl ChatWidget {
| SlashCommand::Compact
| SlashCommand::Review
| SlashCommand::Model
+ | SlashCommand::Presets
| SlashCommand::Plan
| SlashCommand::Goal
| SlashCommand::Side
diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__custom_model_display_name_all_models.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__custom_model_display_name_all_models.snap
index 509a75dd8a..dfe817667c 100644
--- a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__custom_model_display_name_all_models.snap
+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__custom_model_display_name_all_models.snap
@@ -1,6 +1,5 @@
---
source: tui/src/chatwidget/tests/model_display_name_tests.rs
-assertion_line: 40
expression: "render_bottom_popup(&chat, 80)"
---
Select Model and Effort
diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__custom_model_display_name_quick_picker.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__custom_model_display_name_quick_picker.snap
index 8ae33f16b5..0b466ec609 100644
--- a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__custom_model_display_name_quick_picker.snap
+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__custom_model_display_name_quick_picker.snap
@@ -1,6 +1,5 @@
---
source: tui/src/chatwidget/tests/model_display_name_tests.rs
-assertion_line: 33
expression: "render_bottom_popup(&chat, 80)"
---
Select Model
diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__model_picker_refreshes_auto_models.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__model_picker_refreshes_auto_models.snap
index 31485205ed..a090ec159f 100644
--- a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__model_picker_refreshes_auto_models.snap
+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__model_picker_refreshes_auto_models.snap
@@ -1,6 +1,5 @@
---
source: tui/src/chatwidget/tests/popups_and_settings.rs
-assertion_line: 3393
expression: "render_bottom_popup(&chat, 80)"
---
Select Model
diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__model_selection_popup.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__model_selection_popup.snap
index 3f9740b88f..e048e7ff70 100644
--- a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__model_selection_popup.snap
+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__model_selection_popup.snap
@@ -1,6 +1,6 @@
---
source: tui/src/chatwidget/tests/popups_and_settings.rs
-expression: popup
+expression: "render_bottom_popup(&chat, 80)"
---
Select Model and Effort
diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__saved_quick_dials_clear.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__saved_quick_dials_clear.snap
new file mode 100644
index 0000000000..7b0955a079
--- /dev/null
+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__saved_quick_dials_clear.snap
@@ -0,0 +1,19 @@
+---
+source: tui/src/chatwidget/tests/quick_dials_tests.rs
+expression: "render_bottom_popup(&chat, 80)"
+---
+ Delete a preset
+
+
+› 1. coding /model gpt-5.5 --reasoning=high --speed=fast
+ 2. empty
+ 3. empty
+ 4. empty
+ 5. empty
+ 6. empty
+ 7. empty
+ 8. empty
+ 9. empty
+ 0. empty
+
+ enter select · esc back
diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__saved_quick_dials_confirm_delete.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__saved_quick_dials_confirm_delete.snap
new file mode 100644
index 0000000000..109c5f561d
--- /dev/null
+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__saved_quick_dials_confirm_delete.snap
@@ -0,0 +1,11 @@
+---
+source: tui/src/chatwidget/tests/quick_dials_tests.rs
+expression: "render_bottom_popup(&chat, 80)"
+---
+ Delete preset 1?
+ coding
+
+
+› 1. Delete preset 1
+
+ enter select · esc back
diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__saved_quick_dials_confirm_replace.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__saved_quick_dials_confirm_replace.snap
new file mode 100644
index 0000000000..9f5b01af0f
--- /dev/null
+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__saved_quick_dials_confirm_replace.snap
@@ -0,0 +1,13 @@
+---
+source: tui/src/chatwidget/tests/quick_dials_tests.rs
+expression: "render_bottom_popup(&chat, 52)"
+---
+ Replace preset 1?
+ /model gpt-5.5 --reasoning=high --speed=fast
+ → /model gpt-5.6-terra --reasoning=high
+ --speed=fast
+
+
+› 1. Replace preset 1
+
+ enter select · esc back
diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__saved_quick_dials_confirm_save.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__saved_quick_dials_confirm_save.snap
new file mode 100644
index 0000000000..a7615426b7
--- /dev/null
+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__saved_quick_dials_confirm_save.snap
@@ -0,0 +1,12 @@
+---
+source: tui/src/chatwidget/tests/quick_dials_tests.rs
+expression: "render_bottom_popup(&chat, 52)"
+---
+ Save preset 2?
+ /model gpt-5.6-terra --reasoning=high
+ --speed=fast
+
+
+› 1. Save preset 2
+
+ enter select · esc back
diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__saved_quick_dials_editor.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__saved_quick_dials_editor.snap
new file mode 100644
index 0000000000..3b9dc66e66
--- /dev/null
+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__saved_quick_dials_editor.snap
@@ -0,0 +1,10 @@
+---
+source: tui/src/chatwidget/tests/quick_dials_tests.rs
+expression: editor.clone()
+---
+ New preset
+
+› Review the current changes
+ for safety
+
+ enter choose slot · esc back
diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__saved_quick_dials_recall.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__saved_quick_dials_recall.snap
new file mode 100644
index 0000000000..0a02e68f47
--- /dev/null
+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__saved_quick_dials_recall.snap
@@ -0,0 +1,23 @@
+---
+source: tui/src/chatwidget/tests/quick_dials_tests.rs
+expression: "render_bottom_popup(&chat, 80)"
+---
+ Presets
+
+
+› 1. coding /model gpt-5.5 --reasoning=high --speed=fast
+ 2. empty
+ 3. empty
+ 4. empty
+ 5. empty
+ 6. empty
+ 7. empty
+ 8. empty
+ 9. empty
+ 0. empty
+ s. New preset…
+ e. Edit a preset…
+ Start from current settings…
+ d. Delete a preset…
+
+ enter select · esc back
diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__saved_quick_dials_save.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__saved_quick_dials_save.snap
new file mode 100644
index 0000000000..eb3b518d9b
--- /dev/null
+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__saved_quick_dials_save.snap
@@ -0,0 +1,20 @@
+---
+source: tui/src/chatwidget/tests/quick_dials_tests.rs
+expression: "render_bottom_popup(&chat, 80)"
+---
+ Save preset to slot
+ Review the current changes
+
+
+ 1. coding /model gpt-5.5 --reasoning=high --speed=fast
+› 2. empty
+ 3. empty
+ 4. empty
+ 5. empty
+ 6. empty
+ 7. empty
+ 8. empty
+ 9. empty
+ 0. empty
+
+ enter select · esc back
diff --git a/codex-rs/tui/src/chatwidget/tests.rs b/codex-rs/tui/src/chatwidget/tests.rs
index ee79aeffb4..1e5dade887 100644
--- a/codex-rs/tui/src/chatwidget/tests.rs
+++ b/codex-rs/tui/src/chatwidget/tests.rs
@@ -328,3 +328,6 @@ mod question_notifications_tests;
#[path = "tests/security_setup_tests.rs"]
mod security_setup_tests;
+
+#[path = "tests/quick_dials_tests.rs"]
+mod quick_dials_tests;
diff --git a/codex-rs/tui/src/chatwidget/tests/quick_dials_tests.rs b/codex-rs/tui/src/chatwidget/tests/quick_dials_tests.rs
new file mode 100644
index 0000000000..649580621a
--- /dev/null
+++ b/codex-rs/tui/src/chatwidget/tests/quick_dials_tests.rs
@@ -0,0 +1,155 @@
+//! Save, Clear, and confirmation layouts keep destructive preset actions explicit.
+
+use super::*;
+use crate::chatwidget::quick_dials::QuickDialEditorTarget;
+use crate::chatwidget::quick_dials::QuickDialPickerMode;
+use codex_config::types::QuickDial;
+
+#[tokio::test]
+async fn saved_quick_dials_save_and_clear_picker_snapshots() {
+ const DRAFT: &str = "Review the current changes\nfor safety ";
+ let (mut chat, mut events, _ops) =
+ make_chatwidget_manual(/*model_override*/ Some("gpt-5.5")).await;
+ chat.thread_id = Some(ThreadId::new());
+ chat.local_settings.tui.quick_dials = [(
+ "1".into(),
+ QuickDial {
+ input: "/model gpt-5.5 --reasoning=high --speed=fast".into(),
+ label: Some("coding".into()),
+ },
+ )]
+ .into();
+ chat.bottom_pane.apply_external_edit(DRAFT.into());
+ chat.dispatch_command(SlashCommand::Presets);
+ assert_chatwidget_snapshot!(
+ "saved_quick_dials_recall",
+ render_bottom_popup(&chat, /*width*/ 80)
+ );
+ chat.handle_key_event(KeyCode::Esc.into());
+ while events.try_recv().is_ok() {}
+ chat.open_quick_dial_editor(QuickDialEditorTarget::PickSlot, /*dial*/ None);
+ let editor = render_bottom_popup(&chat, /*width*/ 80);
+ assert_chatwidget_snapshot!("saved_quick_dials_editor", editor.clone());
+ chat.handle_key_event(KeyCode::Enter.into());
+ let edited = std::iter::from_fn(|| events.try_recv().ok())
+ .find_map(|event| match event {
+ AppEvent::OpenQuickDialSavePicker(dial) => Some(dial),
+ _ => None,
+ })
+ .expect("editor submits a preset draft");
+ assert_eq!(
+ edited,
+ QuickDial {
+ input: DRAFT.into(),
+ label: None,
+ }
+ );
+ chat.open_quick_dial_save_picker(edited);
+ assert_chatwidget_snapshot!(
+ "saved_quick_dials_save",
+ render_bottom_popup(&chat, /*width*/ 80)
+ );
+ chat.handle_key_event(KeyCode::Esc.into());
+ assert_eq!(render_bottom_popup(&chat, /*width*/ 80), editor);
+ chat.handle_key_event(KeyCode::Esc.into());
+
+ let saved = chat.local_settings.tui.quick_dials["1"].clone();
+ chat.open_quick_dial_editor(QuickDialEditorTarget::Slot(/*slot*/ 1), Some(saved.clone()));
+ chat.handle_key_event(KeyCode::Enter.into());
+ assert_matches!(
+ std::iter::from_fn(|| events.try_recv().ok())
+ .find(|event| matches!(event, AppEvent::ConfirmQuickDial { .. })),
+ Some(AppEvent::ConfirmQuickDial {
+ slot: 1,
+ dial: Some(actual),
+ }) if actual == saved
+ );
+ chat.handle_key_event(KeyCode::Esc.into());
+
+ chat.open_quick_dials_picker(QuickDialPickerMode::Clear);
+ assert_chatwidget_snapshot!(
+ "saved_quick_dials_clear",
+ render_bottom_popup(&chat, /*width*/ 80)
+ );
+ chat.handle_key_event(KeyCode::Esc.into());
+ while events.try_recv().is_ok() {}
+ let replacement = QuickDial {
+ input: "/model gpt-5.6-terra --reasoning=high --speed=fast".into(),
+ label: None,
+ };
+ chat.confirm_quick_dial(/*slot*/ 2, Some(replacement.clone()));
+ assert_chatwidget_snapshot!(
+ "saved_quick_dials_confirm_save",
+ render_bottom_popup(&chat, /*width*/ 52)
+ );
+ chat.handle_key_event(KeyCode::Esc.into());
+ assert!(
+ !std::iter::from_fn(|| events.try_recv().ok())
+ .any(|event| matches!(event, AppEvent::SaveQuickDial { .. }))
+ );
+
+ chat.confirm_quick_dial(/*slot*/ 1, Some(replacement.clone()));
+ assert_chatwidget_snapshot!(
+ "saved_quick_dials_confirm_replace",
+ render_bottom_popup(&chat, /*width*/ 52)
+ );
+ chat.handle_key_event(KeyCode::Enter.into());
+ assert_matches!(
+ events.try_recv(),
+ Ok(AppEvent::SaveQuickDial {
+ slot: 1,
+ dial: Some(actual),
+ }) if actual == replacement
+ );
+
+ chat.confirm_quick_dial(/*slot*/ 1, /*dial*/ None);
+ assert_chatwidget_snapshot!(
+ "saved_quick_dials_confirm_delete",
+ render_bottom_popup(&chat, /*width*/ 80)
+ );
+ chat.handle_key_event(KeyCode::Esc.into());
+ assert!(
+ !std::iter::from_fn(|| events.try_recv().ok())
+ .any(|event| matches!(event, AppEvent::SaveQuickDial { .. }))
+ );
+
+ chat.recall_quick_dial(/*slot*/ 1);
+ assert_eq!(chat.bottom_pane.composer_text(), DRAFT);
+ assert_eq!(
+ chat.queued_user_message_texts(),
+ ["/model gpt-5.5 --reasoning=high --speed=fast"]
+ );
+
+ chat.set_reasoning_effort(Some(ReasoningEffortConfig::High));
+ chat.effective_service_tier = Some(SERVICE_TIER_DEFAULT_REQUEST_VALUE.into());
+ assert_eq!(
+ chat.current_model_quick_dial(),
+ Ok(QuickDial {
+ input: "/model gpt-5.5 --reasoning=high --speed=standard".into(),
+ label: None,
+ })
+ );
+ let expected_model = chat.current_model_quick_dial().expect("model command");
+ chat.open_quick_dial_prefills(QuickDialEditorTarget::PickSlot);
+ chat.handle_key_event(KeyCode::Enter.into());
+ assert_matches!(
+ std::iter::from_fn(|| events.try_recv().ok())
+ .find(|event| matches!(event, AppEvent::OpenQuickDialEditor { .. })),
+ Some(AppEvent::OpenQuickDialEditor {
+ target: QuickDialEditorTarget::PickSlot,
+ dial: Some(actual),
+ }) if actual == expected_model
+ );
+ chat.handle_key_event(KeyCode::Esc.into());
+ chat.set_reasoning_effort(Some(ReasoningEffortConfig::Custom("removed-effort".into())));
+ assert_eq!(
+ chat.current_model_quick_dial(),
+ Err("Choose an available reasoning effort with /model before saving.")
+ );
+ chat.set_reasoning_effort(/*effort*/ None);
+ chat.effective_service_tier = Some("removed-speed".into());
+ assert_eq!(
+ chat.current_model_quick_dial(),
+ Err("Choose an available speed with /model before saving.")
+ );
+}
diff --git a/codex-rs/tui/src/slash_command.rs b/codex-rs/tui/src/slash_command.rs
index 65d7965236..d7b0e99d06 100644
--- a/codex-rs/tui/src/slash_command.rs
+++ b/codex-rs/tui/src/slash_command.rs
@@ -13,6 +13,7 @@ pub enum SlashCommand {
// DO NOT ALPHA-SORT! Enum order is presentation order in the popup, so
// more frequently used commands should be listed first.
Model,
+ Presets,
Daybreak,
Ide,
Permissions,
@@ -132,6 +133,7 @@ impl SlashCommand {
SlashCommand::MemoryDrop => "DO NOT USE",
SlashCommand::MemoryUpdate => "DO NOT USE",
SlashCommand::Model => "choose what model and reasoning effort to use",
+ SlashCommand::Presets => "run or save reusable prompts and slash commands",
SlashCommand::Daybreak => "turn Daybreak on or off",
SlashCommand::Ide => {
"include current selection, open files, and other context from your IDE"
@@ -269,6 +271,7 @@ impl SlashCommand {
| SlashCommand::Archive
| SlashCommand::Resume
| SlashCommand::Model
+ | SlashCommand::Presets
| SlashCommand::Daybreak
| SlashCommand::Permissions
| SlashCommand::Copy