Add session automation scheduling

.bazelignore

@@ -1,3 +0,0 @@
-# Without this, Bazel will consider BUILD.bazel files in
-# .git/sl/origbackups (which can be populated by Sapling SCM).
-.git

.github/workflows/Dockerfile.bazel

@@ -4,7 +4,7 @@ FROM ubuntu:24.04
 # initial debugging, but we should publish to a more proper location.
 #
 # docker buildx create --use
-# docker buildx build --platform linux/amd64,linux/arm64 -f .github/workflows/Dockerfile.bazel -t mbolin491/codex-bazel:latest --push .
+# docker buildx build --platform linux/amd64 -f .github/workflows/Dockerfile.bazel -t mbolin491/codex-bazel:latest --push .
 
 RUN apt-get update && \
     apt-get install -y --no-install-recommends \

.github/workflows/ci.bazelrc

@@ -2,19 +2,14 @@ common --remote_download_minimal
 common --nobuild_runfile_links
 common --keep_going
 
-# We prefer to run the build actions entirely remotely so we can dial up the concurrency.
-# We have platform-specific tests, so we want to execute the tests on all platforms using the strongest sandboxing available on each platform.
-
-# On linux, we can do a full remote build/test, by targeting the right (x86/arm) runners, so we have coverage of both.
-# Linux crossbuilds don't work until we untangle the libc constraint mess.
-common:linux --config=remote
-common:linux --strategy=remote
-common:linux --platforms=//:rbe
-
-# On mac, we can run all the build actions remotely but test actions locally.
+# Prefer to run the build actions entirely remotely so we can dial up the concurrency.
+# Currently remote builds only work on Mac hosts, until we untangle the libc constraints mess on linux.
 common:macos --config=remote
 common:macos --strategy=remote
-common:macos --strategy=TestRunner=darwin-sandbox,local
 
+# We have platform-specific tests, so execute the tests locally using the strongest sandboxing available on each platform.
+common:macos --strategy=TestRunner=darwin-sandbox,local
+# Note: linux-sandbox is stronger, but not available in GHA.
+common:linux --strategy=TestRunner=processwrapper-sandbox,local
 common:windows --strategy=TestRunner=local
 

BUILD.bazel

@@ -11,9 +11,19 @@ platform(
     ],
 )
 
-alias(
+platform(
     name = "rbe",
-    actual = "@rbe_platform",
+    constraint_values = [
+        "@platforms//cpu:x86_64",
+        "@platforms//os:linux",
+        "@bazel_tools//tools/cpp:clang",
+        "@toolchains_llvm_bootstrapped//constraints/libc:gnu.2.28",
+    ],
+    exec_properties = {
+        # Ubuntu-based image that includes git, python3, dotslash, and other
+        # tools that various integration tests need.
+        # Verify at https://hub.docker.com/layers/mbolin491/codex-bazel/latest/images/sha256:8c9ff94187ea7c08a31e9a81f5fe8046ea3972a6768983c955c4079fa30567fb
+        "container-image": "docker://docker.io/mbolin491/codex-bazel@sha256:8c9ff94187ea7c08a31e9a81f5fe8046ea3972a6768983c955c4079fa30567fb",
+        "OSFamily": "Linux",
+    },
 )
-
-exports_files(["AGENTS.md"])

MODULE.bazel

@@ -120,9 +120,3 @@ crate.annotation(
     deps = [":windows_import_lib"],
 )
 use_repo(crate, "crates")
-
-rbe_platform_repository = use_repo_rule("//:rbe.bzl", "rbe_platform_repository")
-
-rbe_platform_repository(
-    name = "rbe_platform",
-)

announcement_tip.toml

@@ -1,17 +0,0 @@
-# Example announcement tips for Codex TUI.
-# Each [[announcements]] entry is evaluated in order; the last matching one is shown.
-# Dates are UTC, formatted as YYYY-MM-DD. The from_date is inclusive and the to_date is exclusive.
-# version_regex matches against the CLI version (env!("CARGO_PKG_VERSION")); omit to apply to all versions.
-# target_app specify which app should display the announcement (cli, vsce, ...).
-
-[[announcements]]
-content = "Welcome to Codex! Check out the new onboarding flow."
-from_date = "2024-10-01"
-to_date = "2024-10-15"
-target_app = "cli"
-
-# Test announcement only for local build version until 2026-01-10 excluded (past)
-[[announcements]]
-content = "This is a test announcement"
-version_regex = "^0\\.0\\.0$"
-to_date = "2026-01-10"

codex-rs/codex-client/src/error.rs

@@ -7,7 +7,6 @@ pub enum TransportError {
     #[error("http {status}: {body:?}")]
     Http {
         status: StatusCode,
-        url: Option<String>,
         headers: Option<HeaderMap>,
         body: Option<String>,
     },

codex-rs/codex-client/src/transport.rs

@@ -131,7 +131,6 @@ impl HttpTransport for ReqwestTransport {
             );
         }
 
-        let url = req.url.clone();
         let builder = self.build(req)?;
         let resp = builder.send().await.map_err(Self::map_error)?;
         let status = resp.status();
@@ -141,7 +140,6 @@ impl HttpTransport for ReqwestTransport {
             let body = String::from_utf8(bytes.to_vec()).ok();
             return Err(TransportError::Http {
                 status,
-                url: Some(url),
                 headers: Some(headers),
                 body,
             });
@@ -163,7 +161,6 @@ impl HttpTransport for ReqwestTransport {
             );
         }
 
-        let url = req.url.clone();
         let builder = self.build(req)?;
         let resp = builder.send().await.map_err(Self::map_error)?;
         let status = resp.status();
@@ -172,7 +169,6 @@ impl HttpTransport for ReqwestTransport {
             let body = resp.text().await.ok();
             return Err(TransportError::Http {
                 status,
-                url: Some(url),
                 headers: Some(headers),
                 body,
             });

codex-rs/core/BUILD.bazel

@@ -20,15 +20,6 @@ codex_rust_crate(
         "//codex-rs/apply-patch:apply_patch_tool_instructions.md",
         "prompt.md",
     ],
-    # This is a bit of a hack, but empirically, some of our integration tests
-    # are relying on the presence of this file as a repo root marker. When
-    # running tests locally, this "just works," but in remote execution,
-    # the working directory is different and so the file is not found unless it
-    # is explicitly added as test data.
-    #
-    # TODO(aibrahim): Update the tests so that `just bazel-remote-test` succeeds
-    # without this workaround.
-    test_data_extra = ["//:AGENTS.md"],
     integration_deps_extra = ["//codex-rs/core/tests/common:common"],
     test_tags = ["no-sandbox"],
     extra_binaries = [

codex-rs/core/src/api_bridge.rs

@@ -25,13 +25,11 @@ pub(crate) fn map_api_error(err: ApiError) -> CodexErr {
         ApiError::Api { status, message } => CodexErr::UnexpectedStatus(UnexpectedResponseError {
             status,
             body: message,
-            url: None,
             request_id: None,
         }),
         ApiError::Transport(transport) => match transport {
             TransportError::Http {
                 status,
-                url,
                 headers,
                 body,
             } => {
@@ -73,7 +71,6 @@ pub(crate) fn map_api_error(err: ApiError) -> CodexErr {
                     CodexErr::UnexpectedStatus(UnexpectedResponseError {
                         status,
                         body: body_text,
-                        url,
                         request_id: extract_request_id(headers.as_ref()),
                     })
                 }

codex-rs/core/src/client.rs

@@ -533,7 +533,6 @@ async fn handle_unauthorized(
 fn map_unauthorized_status(status: StatusCode) -> CodexErr {
     map_api_error(ApiError::Transport(TransportError::Http {
         status,
-        url: None,
         headers: None,
         body: None,
     }))

codex-rs/core/src/codex.rs

@@ -1540,24 +1540,6 @@ impl Session {
         }
     }
 
-    /// Returns the input if there was no task running to inject into
-    pub async fn inject_response_items(
-        &self,
-        input: Vec<ResponseInputItem>,
-    ) -> Result<(), Vec<ResponseInputItem>> {
-        let mut active = self.active_turn.lock().await;
-        match active.as_mut() {
-            Some(at) => {
-                let mut ts = at.turn_state.lock().await;
-                for item in input {
-                    ts.push_pending_input(item);
-                }
-                Ok(())
-            }
-            None => Err(input),
-        }
-    }
-
     pub async fn get_pending_input(&self) -> Vec<ResponseInputItem> {
         let mut active = self.active_turn.lock().await;
         match active.as_mut() {

codex-rs/core/src/error.rs

@@ -277,7 +277,6 @@ pub enum RefreshTokenFailedReason {
 pub struct UnexpectedResponseError {
     pub status: StatusCode,
     pub body: String,
-    pub url: Option<String>,
     pub request_id: Option<String>,
 }
 
@@ -294,11 +293,7 @@ impl UnexpectedResponseError {
             return None;
         }
 
-        let status = self.status;
-        let mut message = format!("{CLOUDFLARE_BLOCKED_MESSAGE} (status {status})");
-        if let Some(url) = &self.url {
-            message.push_str(&format!(", url: {url}"));
-        }
+        let mut message = format!("{CLOUDFLARE_BLOCKED_MESSAGE} (status {})", self.status);
         if let Some(id) = &self.request_id {
             message.push_str(&format!(", request id: {id}"));
         }
@@ -312,16 +307,16 @@ impl std::fmt::Display for UnexpectedResponseError {
         if let Some(friendly) = self.friendly_message() {
             write!(f, "{friendly}")
         } else {
-            let status = self.status;
-            let body = &self.body;
-            let mut message = format!("unexpected status {status}: {body}");
-            if let Some(url) = &self.url {
-                message.push_str(&format!(", url: {url}"));
-            }
-            if let Some(id) = &self.request_id {
-                message.push_str(&format!(", request id: {id}"));
-            }
-            write!(f, "{message}")
+            write!(
+                f,
+                "unexpected status {}: {}{}",
+                self.status,
+                self.body,
+                self.request_id
+                    .as_ref()
+                    .map(|id| format!(", request id: {id}"))
+                    .unwrap_or_default()
+            )
         }
     }
 }
@@ -831,16 +826,12 @@ mod tests {
             status: StatusCode::FORBIDDEN,
             body: "<html><body>Cloudflare error: Sorry, you have been blocked</body></html>"
                 .to_string(),
-            url: Some("http://example.com/blocked".to_string()),
             request_id: Some("ray-id".to_string()),
         };
         let status = StatusCode::FORBIDDEN.to_string();
-        let url = "http://example.com/blocked";
         assert_eq!(
             err.to_string(),
-            format!(
-                "{CLOUDFLARE_BLOCKED_MESSAGE} (status {status}), url: {url}, request id: ray-id"
-            )
+            format!("{CLOUDFLARE_BLOCKED_MESSAGE} (status {status}), request id: ray-id")
         );
     }
 
@@ -849,14 +840,12 @@ mod tests {
         let err = UnexpectedResponseError {
             status: StatusCode::FORBIDDEN,
             body: "plain text error".to_string(),
-            url: Some("http://example.com/plain".to_string()),
             request_id: None,
         };
         let status = StatusCode::FORBIDDEN.to_string();
-        let url = "http://example.com/plain";
         assert_eq!(
             err.to_string(),
-            format!("unexpected status {status}: plain text error, url: {url}")
+            format!("unexpected status {status}: plain text error")
         );
     }
 

codex-rs/core/src/event_mapping.rs

@@ -9,10 +9,6 @@ use codex_protocol::models::ReasoningItemContent;
 use codex_protocol::models::ReasoningItemReasoningSummary;
 use codex_protocol::models::ResponseItem;
 use codex_protocol::models::WebSearchAction;
-use codex_protocol::models::is_image_close_tag_text;
-use codex_protocol::models::is_image_open_tag_text;
-use codex_protocol::models::is_local_image_close_tag_text;
-use codex_protocol::models::is_local_image_open_tag_text;
 use codex_protocol::user_input::UserInput;
 use tracing::warn;
 use uuid::Uuid;
@@ -36,17 +32,9 @@ fn parse_user_message(message: &[ContentItem]) -> Option<UserMessageItem> {
 
     let mut content: Vec<UserInput> = Vec::new();
 
-    for (idx, content_item) in message.iter().enumerate() {
+    for content_item in message.iter() {
         match content_item {
             ContentItem::InputText { text } => {
-                if (is_local_image_open_tag_text(text) || is_image_open_tag_text(text))
-                    && (matches!(message.get(idx + 1), Some(ContentItem::InputImage { .. })))
-                    || (idx > 0
-                        && (is_local_image_close_tag_text(text) || is_image_close_tag_text(text))
-                        && matches!(message.get(idx - 1), Some(ContentItem::InputImage { .. })))
-                {
-                    continue;
-                }
                 if is_session_prefix(text) || is_user_shell_command_text(text) {
                     return None;
                 }
@@ -189,80 +177,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn skips_local_image_label_text() {
-        let image_url = "data:image/png;base64,abc".to_string();
-        let label = codex_protocol::models::local_image_open_tag_text(1);
-        let user_text = "Please review this image.".to_string();
-
-        let item = ResponseItem::Message {
-            id: None,
-            role: "user".to_string(),
-            content: vec![
-                ContentItem::InputText { text: label },
-                ContentItem::InputImage {
-                    image_url: image_url.clone(),
-                },
-                ContentItem::InputText {
-                    text: "</image>".to_string(),
-                },
-                ContentItem::InputText {
-                    text: user_text.clone(),
-                },
-            ],
-        };
-
-        let turn_item = parse_turn_item(&item).expect("expected user message turn item");
-
-        match turn_item {
-            TurnItem::UserMessage(user) => {
-                let expected_content = vec![
-                    UserInput::Image { image_url },
-                    UserInput::Text { text: user_text },
-                ];
-                assert_eq!(user.content, expected_content);
-            }
-            other => panic!("expected TurnItem::UserMessage, got {other:?}"),
-        }
-    }
-
-    #[test]
-    fn skips_unnamed_image_label_text() {
-        let image_url = "data:image/png;base64,abc".to_string();
-        let label = codex_protocol::models::image_open_tag_text();
-        let user_text = "Please review this image.".to_string();
-
-        let item = ResponseItem::Message {
-            id: None,
-            role: "user".to_string(),
-            content: vec![
-                ContentItem::InputText { text: label },
-                ContentItem::InputImage {
-                    image_url: image_url.clone(),
-                },
-                ContentItem::InputText {
-                    text: codex_protocol::models::image_close_tag_text(),
-                },
-                ContentItem::InputText {
-                    text: user_text.clone(),
-                },
-            ],
-        };
-
-        let turn_item = parse_turn_item(&item).expect("expected user message turn item");
-
-        match turn_item {
-            TurnItem::UserMessage(user) => {
-                let expected_content = vec![
-                    UserInput::Image { image_url },
-                    UserInput::Text { text: user_text },
-                ];
-                assert_eq!(user.content, expected_content);
-            }
-            other => panic!("expected TurnItem::UserMessage, got {other:?}"),
-        }
-    }
-
     #[test]
     fn skips_user_instructions_and_env() {
         let items = vec![

codex-rs/core/src/tools/handlers/view_image.rs

@@ -11,9 +11,7 @@ use crate::tools::context::ToolPayload;
 use crate::tools::handlers::parse_arguments;
 use crate::tools::registry::ToolHandler;
 use crate::tools::registry::ToolKind;
-use codex_protocol::models::ContentItem;
-use codex_protocol::models::ResponseInputItem;
-use codex_protocol::models::local_image_content_items_with_label_number;
+use codex_protocol::user_input::UserInput;
 
 pub struct ViewImageHandler;
 
@@ -65,15 +63,8 @@ impl ToolHandler for ViewImageHandler {
         }
         let event_path = abs_path.clone();
 
-        let content: Vec<ContentItem> =
-            local_image_content_items_with_label_number(&abs_path, None);
-        let input = ResponseInputItem::Message {
-            role: "user".to_string(),
-            content,
-        };
-
         session
-            .inject_response_items(vec![input])
+            .inject_input(vec![UserInput::LocalImage { path: abs_path }])
             .await
             .map_err(|_| {
                 FunctionCallError::RespondToModel(

codex-rs/core/src/tools/spec.rs

@@ -8,7 +8,6 @@ use crate::tools::handlers::apply_patch::create_apply_patch_json_tool;
 use crate::tools::handlers::collab::DEFAULT_WAIT_TIMEOUT_MS;
 use crate::tools::handlers::collab::MAX_WAIT_TIMEOUT_MS;
 use crate::tools::registry::ToolRegistryBuilder;
-use codex_protocol::models::VIEW_IMAGE_TOOL_NAME;
 use codex_protocol::openai_models::ApplyPatchToolType;
 use codex_protocol::openai_models::ConfigShellToolType;
 use codex_protocol::openai_models::ModelInfo;
@@ -413,9 +412,10 @@ fn create_view_image_tool() -> ToolSpec {
     )]);
 
     ToolSpec::Function(ResponsesApiTool {
-        name: VIEW_IMAGE_TOOL_NAME.to_string(),
-        description: "View a local image from the filesystem (only use if given a full filepath by the user, and the image isn't already attached to the thread context within <image ...> tags)."
-            .to_string(),
+        name: "view_image".to_string(),
+        description:
+            "Attach a local image (by filesystem path) to the thread context for this turn."
+                .to_string(),
         strict: false,
         parameters: JsonSchema::Object {
             properties,

codex-rs/core/tests/suite/mid_turn_input.rs

@@ -1,183 +0,0 @@
-#![cfg(not(target_os = "windows"))]
-
-use anyhow::Result;
-use codex_core::protocol::AskForApproval;
-use codex_core::protocol::EventMsg;
-use codex_core::protocol::Op;
-use codex_core::protocol::SandboxPolicy;
-use codex_protocol::config_types::ReasoningSummary;
-use codex_protocol::user_input::UserInput;
-use core_test_support::responses::ev_assistant_message;
-use core_test_support::responses::ev_completed;
-use core_test_support::responses::ev_function_call;
-use core_test_support::responses::ev_response_created;
-use core_test_support::responses::mount_sse_once;
-use core_test_support::responses::sse;
-use core_test_support::test_codex::TestCodexHarness;
-use core_test_support::wait_for_event;
-use core_test_support::wait_for_event_match;
-use pretty_assertions::assert_eq;
-use serde_json::Value;
-use serde_json::json;
-
-#[derive(Clone, Copy, Debug)]
-enum MidTurnOp {
-    UserInput,
-    UserTurn,
-}
-
-fn message_contains_text(item: &Value, text: &str) -> bool {
-    item.get("type").and_then(Value::as_str) == Some("message")
-        && item.get("role").and_then(Value::as_str) == Some("user")
-        && item
-            .get("content")
-            .and_then(Value::as_array)
-            .map(|content| {
-                content.iter().any(|span| {
-                    span.get("type").and_then(Value::as_str) == Some("input_text")
-                        && span.get("text").and_then(Value::as_str) == Some(text)
-                })
-            })
-            .unwrap_or(false)
-}
-
-async fn run_mid_turn_injection_test(mid_turn_op: MidTurnOp) -> Result<()> {
-    let harness = TestCodexHarness::new().await?;
-    let test = harness.test();
-    let codex = test.codex.clone();
-    let session_model = test.session_configured.model.clone();
-    let cwd = test.cwd_path().to_path_buf();
-
-    let call_id = "shell-mid-turn";
-    let first_message = "first message";
-    let mid_turn_message = "mid-turn message";
-    let workdir = cwd.to_string_lossy().to_string();
-
-    let args = json!({
-        "command": ["bash", "-lc", "sleep 2; echo finished"],
-        "workdir": workdir,
-        "timeout_ms": 10_000,
-    });
-
-    let first_response = sse(vec![
-        ev_response_created("resp-1"),
-        ev_function_call(call_id, "shell", &serde_json::to_string(&args)?),
-        ev_completed("resp-1"),
-    ]);
-    let second_response = sse(vec![
-        ev_response_created("resp-2"),
-        ev_assistant_message("msg-1", "follow up"),
-        ev_completed("resp-2"),
-    ]);
-
-    mount_sse_once(harness.server(), first_response).await;
-    let request_log = mount_sse_once(harness.server(), second_response).await;
-
-    codex
-        .submit(Op::UserTurn {
-            items: vec![UserInput::Text {
-                text: first_message.to_string(),
-            }],
-            final_output_json_schema: None,
-            cwd: cwd.clone(),
-            approval_policy: AskForApproval::Never,
-            sandbox_policy: SandboxPolicy::DangerFullAccess,
-            model: session_model.clone(),
-            effort: None,
-            summary: ReasoningSummary::Auto,
-        })
-        .await?;
-
-    let _ = wait_for_event_match(&codex, |event| match event {
-        EventMsg::ExecCommandBegin(ev) if ev.call_id == call_id => Some(ev.clone()),
-        _ => None,
-    })
-    .await;
-
-    match mid_turn_op {
-        MidTurnOp::UserInput => {
-            codex
-                .submit(Op::UserInput {
-                    items: vec![UserInput::Text {
-                        text: mid_turn_message.to_string(),
-                    }],
-                    final_output_json_schema: None,
-                })
-                .await?;
-        }
-        MidTurnOp::UserTurn => {
-            codex
-                .submit(Op::UserTurn {
-                    items: vec![UserInput::Text {
-                        text: mid_turn_message.to_string(),
-                    }],
-                    final_output_json_schema: None,
-                    cwd: cwd.clone(),
-                    approval_policy: AskForApproval::Never,
-                    sandbox_policy: SandboxPolicy::DangerFullAccess,
-                    model: session_model,
-                    effort: None,
-                    summary: ReasoningSummary::Auto,
-                })
-                .await?;
-        }
-    }
-
-    let end_event = wait_for_event_match(&codex, |event| match event {
-        EventMsg::ExecCommandEnd(ev) if ev.call_id == call_id => Some(ev.clone()),
-        _ => None,
-    })
-    .await;
-    assert_eq!(end_event.exit_code, 0);
-    assert!(
-        end_event.stdout.contains("finished"),
-        "expected stdout to include finished: {}",
-        end_event.stdout
-    );
-
-    wait_for_event(&codex, |event| matches!(event, EventMsg::TurnComplete(_))).await;
-
-    let request = request_log.single_request();
-    let user_messages = request.message_input_texts("user");
-    assert_eq!(
-        user_messages,
-        vec![first_message.to_string(), mid_turn_message.to_string()]
-    );
-
-    let input = request.input();
-    let tool_index = input
-        .iter()
-        .position(|item| {
-            item.get("type").and_then(Value::as_str) == Some("function_call_output")
-                && item.get("call_id").and_then(Value::as_str) == Some(call_id)
-        })
-        .expect("expected function_call_output in request");
-    let mid_turn_index = input
-        .iter()
-        .position(|item| message_contains_text(item, mid_turn_message))
-        .expect("expected mid-turn user message in request");
-    assert!(
-        tool_index < mid_turn_index,
-        "expected tool output before mid-turn input"
-    );
-
-    let tool_output = request
-        .function_call_output_text(call_id)
-        .expect("expected function_call_output output text");
-    assert!(
-        tool_output.contains("finished"),
-        "expected tool output to include finished: {tool_output}"
-    );
-
-    Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn mid_turn_input_inserts_user_input_after_tool_output() -> Result<()> {
-    run_mid_turn_injection_test(MidTurnOp::UserInput).await
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn mid_turn_input_inserts_user_turn_after_tool_output() -> Result<()> {
-    run_mid_turn_injection_test(MidTurnOp::UserTurn).await
-}

codex-rs/core/tests/suite/view_image.rs

@@ -216,20 +216,6 @@ async fn view_image_tool_attaches_local_image() -> anyhow::Result<()> {
 
     let image_message =
         find_image_message(&body).expect("pending input image message not included in request");
-    let content_items = image_message
-        .get("content")
-        .and_then(Value::as_array)
-        .expect("image message has content array");
-    assert_eq!(
-        content_items.len(),
-        1,
-        "view_image should inject only the image content item (no tag/label text)"
-    );
-    assert_eq!(
-        content_items[0].get("type").and_then(Value::as_str),
-        Some("input_image"),
-        "view_image should inject only an input_image content item"
-    );
     let image_url = image_message
         .get("content")
         .and_then(Value::as_array)

codex-rs/protocol/src/models.rs

@@ -180,48 +180,6 @@ fn local_image_error_placeholder(
     }
 }
 
-pub const VIEW_IMAGE_TOOL_NAME: &str = "view_image";
-
-const IMAGE_OPEN_TAG: &str = "<image>";
-const IMAGE_CLOSE_TAG: &str = "</image>";
-const LOCAL_IMAGE_OPEN_TAG_PREFIX: &str = "<image name=";
-const LOCAL_IMAGE_OPEN_TAG_SUFFIX: &str = ">";
-const LOCAL_IMAGE_CLOSE_TAG: &str = IMAGE_CLOSE_TAG;
-
-pub fn image_open_tag_text() -> String {
-    IMAGE_OPEN_TAG.to_string()
-}
-
-pub fn image_close_tag_text() -> String {
-    IMAGE_CLOSE_TAG.to_string()
-}
-
-pub fn local_image_label_text(label_number: usize) -> String {
-    format!("[Image #{label_number}]")
-}
-
-pub fn local_image_open_tag_text(label_number: usize) -> String {
-    let label = local_image_label_text(label_number);
-    format!("{LOCAL_IMAGE_OPEN_TAG_PREFIX}{label}{LOCAL_IMAGE_OPEN_TAG_SUFFIX}")
-}
-
-pub fn is_local_image_open_tag_text(text: &str) -> bool {
-    text.strip_prefix(LOCAL_IMAGE_OPEN_TAG_PREFIX)
-        .is_some_and(|rest| rest.ends_with(LOCAL_IMAGE_OPEN_TAG_SUFFIX))
-}
-
-pub fn is_local_image_close_tag_text(text: &str) -> bool {
-    is_image_close_tag_text(text)
-}
-
-pub fn is_image_open_tag_text(text: &str) -> bool {
-    text == IMAGE_OPEN_TAG
-}
-
-pub fn is_image_close_tag_text(text: &str) -> bool {
-    text == IMAGE_CLOSE_TAG
-}
-
 fn invalid_image_error_placeholder(
     path: &std::path::Path,
     error: impl std::fmt::Display,
@@ -245,53 +203,6 @@ fn unsupported_image_error_placeholder(path: &std::path::Path, mime: &str) -> Co
     }
 }
 
-pub fn local_image_content_items_with_label_number(
-    path: &std::path::Path,
-    label_number: Option<usize>,
-) -> Vec<ContentItem> {
-    match load_and_resize_to_fit(path) {
-        Ok(image) => {
-            let mut items = Vec::with_capacity(3);
-            if let Some(label_number) = label_number {
-                items.push(ContentItem::InputText {
-                    text: local_image_open_tag_text(label_number),
-                });
-            }
-            items.push(ContentItem::InputImage {
-                image_url: image.into_data_url(),
-            });
-            if label_number.is_some() {
-                items.push(ContentItem::InputText {
-                    text: LOCAL_IMAGE_CLOSE_TAG.to_string(),
-                });
-            }
-            items
-        }
-        Err(err) => {
-            if matches!(&err, ImageProcessingError::Read { .. }) {
-                vec![local_image_error_placeholder(path, &err)]
-            } else if err.is_invalid_image() {
-                vec![invalid_image_error_placeholder(path, &err)]
-            } else {
-                let Some(mime_guess) = mime_guess::from_path(path).first() else {
-                    return vec![local_image_error_placeholder(
-                        path,
-                        "unsupported MIME type (unknown)",
-                    )];
-                };
-                let mime = mime_guess.essence_str().to_owned();
-                if !mime.starts_with("image/") {
-                    return vec![local_image_error_placeholder(
-                        path,
-                        format!("unsupported MIME type `{mime}`"),
-                    )];
-                }
-                vec![unsupported_image_error_placeholder(path, &mime)]
-            }
-        }
-    }
-}
-
 impl From<ResponseInputItem> for ResponseItem {
     fn from(item: ResponseInputItem) -> Self {
         match item {
@@ -385,27 +296,41 @@ pub enum ReasoningItemContent {
 
 impl From<Vec<UserInput>> for ResponseInputItem {
     fn from(items: Vec<UserInput>) -> Self {
-        let mut image_index = 0;
         Self::Message {
             role: "user".to_string(),
             content: items
                 .into_iter()
-                .flat_map(|c| match c {
-                    UserInput::Text { text } => vec![ContentItem::InputText { text }],
-                    UserInput::Image { image_url } => vec![
-                        ContentItem::InputText {
-                            text: image_open_tag_text(),
-                        },
-                        ContentItem::InputImage { image_url },
-                        ContentItem::InputText {
-                            text: image_close_tag_text(),
-                        },
-                    ],
-                    UserInput::LocalImage { path } => {
-                        image_index += 1;
-                        local_image_content_items_with_label_number(&path, Some(image_index))
-                    }
-                    UserInput::Skill { .. } => Vec::new(), // Skill bodies are injected later in core
+                .filter_map(|c| match c {
+                    UserInput::Text { text } => Some(ContentItem::InputText { text }),
+                    UserInput::Image { image_url } => Some(ContentItem::InputImage { image_url }),
+                    UserInput::LocalImage { path } => match load_and_resize_to_fit(&path) {
+                        Ok(image) => Some(ContentItem::InputImage {
+                            image_url: image.into_data_url(),
+                        }),
+                        Err(err) => {
+                            if matches!(&err, ImageProcessingError::Read { .. }) {
+                                Some(local_image_error_placeholder(&path, &err))
+                            } else if err.is_invalid_image() {
+                                Some(invalid_image_error_placeholder(&path, &err))
+                            } else {
+                                let Some(mime_guess) = mime_guess::from_path(&path).first() else {
+                                    return Some(local_image_error_placeholder(
+                                        &path,
+                                        "unsupported MIME type (unknown)",
+                                    ));
+                                };
+                                let mime = mime_guess.essence_str().to_owned();
+                                if !mime.starts_with("image/") {
+                                    return Some(local_image_error_placeholder(
+                                        &path,
+                                        format!("unsupported MIME type `{mime}`"),
+                                    ));
+                                }
+                                Some(unsupported_image_error_placeholder(&path, &mime))
+                            }
+                        }
+                    },
+                    UserInput::Skill { .. } => None, // Skill bodies are injected later in core
                 })
                 .collect::<Vec<ContentItem>>(),
         }
@@ -845,33 +770,6 @@ mod tests {
         Ok(())
     }
 
-    #[test]
-    fn wraps_image_user_input_with_tags() -> Result<()> {
-        let image_url = "data:image/png;base64,abc".to_string();
-
-        let item = ResponseInputItem::from(vec![UserInput::Image {
-            image_url: image_url.clone(),
-        }]);
-
-        match item {
-            ResponseInputItem::Message { content, .. } => {
-                let expected = vec![
-                    ContentItem::InputText {
-                        text: image_open_tag_text(),
-                    },
-                    ContentItem::InputImage { image_url },
-                    ContentItem::InputText {
-                        text: image_close_tag_text(),
-                    },
-                ];
-                assert_eq!(content, expected);
-            }
-            other => panic!("expected message response but got {other:?}"),
-        }
-
-        Ok(())
-    }
-
     #[test]
     fn local_image_read_error_adds_placeholder() -> Result<()> {
         let dir = tempdir()?;

codex-rs/tui/Cargo.toml

@@ -91,6 +91,7 @@ tree-sitter-highlight = { workspace = true }
 unicode-segmentation = { workspace = true }
 unicode-width = { workspace = true }
 url = { workspace = true }
+uuid = { workspace = true }
 
 codex-windows-sandbox = { workspace = true }
 tokio-util = { workspace = true, features = ["time"] }
@@ -121,4 +122,3 @@ pretty_assertions = { workspace = true }
 rand = { workspace = true }
 serial_test = { workspace = true }
 vt100 = { workspace = true }
-uuid = { workspace = true }

codex-rs/tui/src/app.rs

@@ -702,6 +702,9 @@ impl App {
             AppEvent::CommitTick => {
                 self.chat_widget.on_commit_tick();
             }
+            AppEvent::AutomationTick => {
+                self.chat_widget.on_automation_tick();
+            }
             AppEvent::CodexEvent(event) => {
                 if self.suppress_shutdown_complete
                     && matches!(event.msg, EventMsg::ShutdownComplete)

codex-rs/tui/src/app_event.rs

@@ -70,6 +70,7 @@ pub(crate) enum AppEvent {
     StartCommitAnimation,
     StopCommitAnimation,
     CommitTick,
+    AutomationTick,
 
     /// Update the current reasoning effort in the running app and widget.
     UpdateReasoningEffort(Option<ReasoningEffort>),

codex-rs/tui/src/bottom_pane/chat_composer.rs

@@ -46,7 +46,6 @@ use crate::style::user_message_style;
 use codex_common::fuzzy_match::fuzzy_match;
 use codex_protocol::custom_prompts::CustomPrompt;
 use codex_protocol::custom_prompts::PROMPTS_CMD_PREFIX;
-use codex_protocol::models::local_image_label_text;
 
 use crate::app_event::AppEvent;
 use crate::app_event_sender::AppEventSender;
@@ -60,7 +59,7 @@ use codex_core::skills::model::SkillMetadata;
 use codex_file_search::FileMatch;
 use std::cell::RefCell;
 use std::collections::HashMap;
-use std::collections::HashSet;
+use std::path::Path;
 use std::path::PathBuf;
 use std::time::Duration;
 use std::time::Instant;
@@ -80,7 +79,6 @@ const LARGE_PASTE_CHAR_THRESHOLD: usize = 1000;
 #[derive(Debug, PartialEq)]
 pub enum InputResult {
     Submitted(String),
-    Queued(String),
     Command(SlashCommand),
     CommandWithArgs(SlashCommand, String),
     None,
@@ -102,12 +100,6 @@ enum PromptSelectionAction {
     Submit { text: String },
 }
 
-#[derive(Clone, Copy, Debug, PartialEq)]
-enum SubmitMode {
-    Submit,
-    Queue,
-}
-
 pub(crate) struct ChatComposer {
     textarea: TextArea,
     textarea_state: RefCell<TextAreaState>,
@@ -282,12 +274,10 @@ impl ChatComposer {
         // normalize_pasted_path already handles Windows → WSL path conversion,
         // so we can directly try to read the image dimensions.
         match image::image_dimensions(&path_buf) {
-            Ok((width, height)) => {
+            Ok((w, h)) => {
                 tracing::info!("OK: {pasted}");
-                tracing::debug!("image dimensions={}x{}", width, height);
-                let format = pasted_image_format(&path_buf);
-                tracing::debug!("attached image format={}", format.label());
-                self.attach_image(path_buf);
+                let format_label = pasted_image_format(&path_buf).label();
+                self.attach_image(path_buf, w, h, format_label);
                 true
             }
             Err(err) => {
@@ -418,9 +408,13 @@ impl ChatComposer {
     }
 
     /// Attempt to start a burst by retro-capturing recent chars before the cursor.
-    pub fn attach_image(&mut self, path: PathBuf) {
-        let image_number = self.attached_images.len() + 1;
-        let placeholder = local_image_label_text(image_number);
+    pub fn attach_image(&mut self, path: PathBuf, width: u32, height: u32, _format_label: &str) {
+        let file_label = path
+            .file_name()
+            .map(|name| name.to_string_lossy().into_owned())
+            .unwrap_or_else(|| "image".to_string());
+        let base_placeholder = format!("{file_label} {width}x{height}");
+        let placeholder = self.next_image_placeholder(&base_placeholder);
         // Insert as an element to match large paste placeholder behavior:
         // styled distinctly and treated atomically for cursor/mutations.
         self.textarea.insert_element(&placeholder);
@@ -483,6 +477,22 @@ impl ChatComposer {
         }
     }
 
+    fn next_image_placeholder(&mut self, base: &str) -> String {
+        let text = self.textarea.text();
+        let mut suffix = 1;
+        loop {
+            let placeholder = if suffix == 1 {
+                format!("[{base}]")
+            } else {
+                format!("[{base} #{suffix}]")
+            };
+            if !text.contains(&placeholder) {
+                return placeholder;
+            }
+            suffix += 1;
+        }
+    }
+
     pub(crate) fn insert_str(&mut self, text: &str) {
         self.textarea.insert_str(text);
         self.sync_popups();
@@ -808,43 +818,47 @@ impl ChatComposer {
                 if is_image {
                     // Determine dimensions; if that fails fall back to normal path insertion.
                     let path_buf = PathBuf::from(&sel_path);
-                    match image::image_dimensions(&path_buf) {
-                        Ok((width, height)) => {
-                            tracing::debug!("selected image dimensions={}x{}", width, height);
-                            // Remove the current @token (mirror logic from insert_selected_path without inserting text)
-                            // using the flat text and byte-offset cursor API.
-                            let cursor_offset = self.textarea.cursor();
-                            let text = self.textarea.text();
-                            // Clamp to a valid char boundary to avoid panics when slicing.
-                            let safe_cursor = Self::clamp_to_char_boundary(text, cursor_offset);
-                            let before_cursor = &text[..safe_cursor];
-                            let after_cursor = &text[safe_cursor..];
+                    if let Ok((w, h)) = image::image_dimensions(&path_buf) {
+                        // Remove the current @token (mirror logic from insert_selected_path without inserting text)
+                        // using the flat text and byte-offset cursor API.
+                        let cursor_offset = self.textarea.cursor();
+                        let text = self.textarea.text();
+                        // Clamp to a valid char boundary to avoid panics when slicing.
+                        let safe_cursor = Self::clamp_to_char_boundary(text, cursor_offset);
+                        let before_cursor = &text[..safe_cursor];
+                        let after_cursor = &text[safe_cursor..];
 
-                            // Determine token boundaries in the full text.
-                            let start_idx = before_cursor
-                                .char_indices()
-                                .rfind(|(_, c)| c.is_whitespace())
-                                .map(|(idx, c)| idx + c.len_utf8())
-                                .unwrap_or(0);
-                            let end_rel_idx = after_cursor
-                                .char_indices()
-                                .find(|(_, c)| c.is_whitespace())
-                                .map(|(idx, _)| idx)
-                                .unwrap_or(after_cursor.len());
-                            let end_idx = safe_cursor + end_rel_idx;
+                        // Determine token boundaries in the full text.
+                        let start_idx = before_cursor
+                            .char_indices()
+                            .rfind(|(_, c)| c.is_whitespace())
+                            .map(|(idx, c)| idx + c.len_utf8())
+                            .unwrap_or(0);
+                        let end_rel_idx = after_cursor
+                            .char_indices()
+                            .find(|(_, c)| c.is_whitespace())
+                            .map(|(idx, _)| idx)
+                            .unwrap_or(after_cursor.len());
+                        let end_idx = safe_cursor + end_rel_idx;
 
-                            self.textarea.replace_range(start_idx..end_idx, "");
-                            self.textarea.set_cursor(start_idx);
+                        self.textarea.replace_range(start_idx..end_idx, "");
+                        self.textarea.set_cursor(start_idx);
 
-                            self.attach_image(path_buf);
-                            // Add a trailing space to keep typing fluid.
-                            self.textarea.insert_str(" ");
-                        }
-                        Err(err) => {
-                            tracing::trace!("image dimensions lookup failed: {err}");
-                            // Fallback to plain path insertion if metadata read fails.
-                            self.insert_selected_path(&sel_path);
-                        }
+                        let format_label = match Path::new(&sel_path)
+                            .extension()
+                            .and_then(|e| e.to_str())
+                            .map(str::to_ascii_lowercase)
+                        {
+                            Some(ext) if ext == "png" => "PNG",
+                            Some(ext) if ext == "jpg" || ext == "jpeg" => "JPEG",
+                            _ => "IMG",
+                        };
+                        self.attach_image(path_buf, w, h, format_label);
+                        // Add a trailing space to keep typing fluid.
+                        self.textarea.insert_str(" ");
+                    } else {
+                        // Fallback to plain path insertion if metadata read fails.
+                        self.insert_selected_path(&sel_path);
                     }
                 } else {
                     // Non-image: inserting file path.
@@ -1205,169 +1219,159 @@ impl ChatComposer {
                 }
                 self.handle_input_basic(key_event)
             }
-            KeyEvent {
-                code: KeyCode::Char('k'),
-                modifiers: KeyModifiers::CONTROL,
-                kind: KeyEventKind::Press,
-                ..
-            } => self.handle_submit(SubmitMode::Queue),
             KeyEvent {
                 code: KeyCode::Enter,
                 modifiers: KeyModifiers::NONE,
                 ..
-            } => self.handle_submit(SubmitMode::Submit),
-            input => self.handle_input_basic(input),
-        }
-    }
-
-    fn handle_submit(&mut self, mode: SubmitMode) -> (InputResult, bool) {
-        // If the first line is a bare built-in slash command (no args),
-        // dispatch it even when the slash popup isn't visible. This preserves
-        // the workflow: type a prefix ("/di"), press Tab to complete to
-        // "/diff ", then press Enter to run it. Tab moves the cursor beyond
-        // the '/name' token and our caret-based heuristic hides the popup,
-        // but Enter should still dispatch the command rather than submit
-        // literal text.
-        let first_line = self.textarea.text().lines().next().unwrap_or("");
-        if let Some((name, rest)) = parse_slash_name(first_line)
-            && rest.is_empty()
-            && let Some((_n, cmd)) = built_in_slash_commands()
-                .into_iter()
-                .filter(|(_, cmd)| {
-                    windows_degraded_sandbox_active() || *cmd != SlashCommand::ElevateSandbox
-                })
-                .find(|(n, _)| *n == name)
-        {
-            self.textarea.set_text("");
-            return (InputResult::Command(cmd), true);
-        }
-        // If we're in a paste-like burst capture, treat Enter as part of the burst
-        // and accumulate it rather than submitting or inserting immediately.
-        // Do not treat Enter as paste inside a slash-command context.
-        let in_slash_context = matches!(self.active_popup, ActivePopup::Command(_))
-            || self
-                .textarea
-                .text()
-                .lines()
-                .next()
-                .unwrap_or("")
-                .starts_with('/');
-        if self.paste_burst.is_active() && !in_slash_context {
-            let now = Instant::now();
-            if self.paste_burst.append_newline_if_active(now) {
-                return (InputResult::None, true);
-            }
-        }
-        // If we have pending placeholder pastes, replace them in the textarea text
-        // and continue to the normal submission flow to handle slash commands.
-        if !self.pending_pastes.is_empty() {
-            let mut text = self.textarea.text().to_string();
-            for (placeholder, actual) in &self.pending_pastes {
-                if text.contains(placeholder) {
-                    text = text.replace(placeholder, actual);
+            } => {
+                // If the first line is a bare built-in slash command (no args),
+                // dispatch it even when the slash popup isn't visible. This preserves
+                // the workflow: type a prefix ("/di"), press Tab to complete to
+                // "/diff ", then press Enter to run it. Tab moves the cursor beyond
+                // the '/name' token and our caret-based heuristic hides the popup,
+                // but Enter should still dispatch the command rather than submit
+                // literal text.
+                let first_line = self.textarea.text().lines().next().unwrap_or("");
+                if let Some((name, rest)) = parse_slash_name(first_line)
+                    && rest.is_empty()
+                    && let Some((_n, cmd)) = built_in_slash_commands()
+                        .into_iter()
+                        .filter(|(_, cmd)| {
+                            windows_degraded_sandbox_active()
+                                || *cmd != SlashCommand::ElevateSandbox
+                        })
+                        .find(|(n, _)| *n == name)
+                {
+                    self.textarea.set_text("");
+                    return (InputResult::Command(cmd), true);
+                }
+                // If we're in a paste-like burst capture, treat Enter as part of the burst
+                // and accumulate it rather than submitting or inserting immediately.
+                // Do not treat Enter as paste inside a slash-command context.
+                let in_slash_context = matches!(self.active_popup, ActivePopup::Command(_))
+                    || self
+                        .textarea
+                        .text()
+                        .lines()
+                        .next()
+                        .unwrap_or("")
+                        .starts_with('/');
+                if self.paste_burst.is_active() && !in_slash_context {
+                    let now = Instant::now();
+                    if self.paste_burst.append_newline_if_active(now) {
+                        return (InputResult::None, true);
+                    }
+                }
+                // If we have pending placeholder pastes, replace them in the textarea text
+                // and continue to the normal submission flow to handle slash commands.
+                if !self.pending_pastes.is_empty() {
+                    let mut text = self.textarea.text().to_string();
+                    for (placeholder, actual) in &self.pending_pastes {
+                        if text.contains(placeholder) {
+                            text = text.replace(placeholder, actual);
+                        }
+                    }
+                    self.textarea.set_text(&text);
+                    self.pending_pastes.clear();
                 }
-            }
-            self.textarea.set_text(&text);
-            self.pending_pastes.clear();
-        }
 
-        // During a paste-like burst, treat Enter as a newline instead of submit.
-        let now = Instant::now();
-        if self
-            .paste_burst
-            .newline_should_insert_instead_of_submit(now)
-            && !in_slash_context
-        {
-            self.textarea.insert_str("\n");
-            self.paste_burst.extend_window(now);
-            return (InputResult::None, true);
-        }
-        let mut text = self.textarea.text().to_string();
-        let original_input = text.clone();
-        let input_starts_with_space = original_input.starts_with(' ');
-        self.textarea.set_text("");
-
-        // Replace all pending pastes in the text
-        for (placeholder, actual) in &self.pending_pastes {
-            if text.contains(placeholder) {
-                text = text.replace(placeholder, actual);
-            }
-        }
-        self.pending_pastes.clear();
-
-        // If there is neither text nor attachments, suppress submission entirely.
-        let has_attachments = !self.attached_images.is_empty();
-        text = text.trim().to_string();
-        if let Some((name, _rest)) = parse_slash_name(&text) {
-            let treat_as_plain_text = input_starts_with_space || name.contains('/');
-            if !treat_as_plain_text {
-                let is_builtin = built_in_slash_commands()
-                    .into_iter()
-                    .filter(|(_, cmd)| {
-                        windows_degraded_sandbox_active() || *cmd != SlashCommand::ElevateSandbox
-                    })
-                    .any(|(command_name, _)| command_name == name);
-                let prompt_prefix = format!("{PROMPTS_CMD_PREFIX}:");
-                let is_known_prompt = name
-                    .strip_prefix(&prompt_prefix)
-                    .map(|prompt_name| {
-                        self.custom_prompts
-                            .iter()
-                            .any(|prompt| prompt.name == prompt_name)
-                    })
-                    .unwrap_or(false);
-                if !is_builtin && !is_known_prompt {
-                    let message = format!(
-                        r#"Unrecognized command '/{name}'. Type "/" for a list of supported commands."#
-                    );
-                    self.app_event_tx.send(AppEvent::InsertHistoryCell(Box::new(
-                        history_cell::new_info_event(message, None),
-                    )));
-                    self.textarea.set_text(&original_input);
-                    self.textarea.set_cursor(original_input.len());
+                // During a paste-like burst, treat Enter as a newline instead of submit.
+                let now = Instant::now();
+                if self
+                    .paste_burst
+                    .newline_should_insert_instead_of_submit(now)
+                    && !in_slash_context
+                {
+                    self.textarea.insert_str("\n");
+                    self.paste_burst.extend_window(now);
                     return (InputResult::None, true);
                 }
-            }
-        }
+                let mut text = self.textarea.text().to_string();
+                let original_input = text.clone();
+                let input_starts_with_space = original_input.starts_with(' ');
+                self.textarea.set_text("");
 
-        if !input_starts_with_space
-            && let Some((name, rest)) = parse_slash_name(&text)
-            && !rest.is_empty()
-            && !name.contains('/')
-            && let Some((_n, cmd)) = built_in_slash_commands()
-                .into_iter()
-                .find(|(command_name, _)| *command_name == name)
-            && cmd == SlashCommand::Review
-        {
-            return (InputResult::CommandWithArgs(cmd, rest.to_string()), true);
-        }
+                // Replace all pending pastes in the text
+                for (placeholder, actual) in &self.pending_pastes {
+                    if text.contains(placeholder) {
+                        text = text.replace(placeholder, actual);
+                    }
+                }
+                self.pending_pastes.clear();
 
-        let expanded_prompt = match expand_custom_prompt(&text, &self.custom_prompts) {
-            Ok(expanded) => expanded,
-            Err(err) => {
-                self.app_event_tx.send(AppEvent::InsertHistoryCell(Box::new(
-                    history_cell::new_error_event(err.user_message()),
-                )));
-                self.textarea.set_text(&original_input);
-                self.textarea.set_cursor(original_input.len());
-                return (InputResult::None, true);
+                // If there is neither text nor attachments, suppress submission entirely.
+                let has_attachments = !self.attached_images.is_empty();
+                text = text.trim().to_string();
+                if let Some((name, _rest)) = parse_slash_name(&text) {
+                    let treat_as_plain_text = input_starts_with_space || name.contains('/');
+                    if !treat_as_plain_text {
+                        let is_builtin = built_in_slash_commands()
+                            .into_iter()
+                            .filter(|(_, cmd)| {
+                                windows_degraded_sandbox_active()
+                                    || *cmd != SlashCommand::ElevateSandbox
+                            })
+                            .any(|(command_name, _)| command_name == name);
+                        let prompt_prefix = format!("{PROMPTS_CMD_PREFIX}:");
+                        let is_known_prompt = name
+                            .strip_prefix(&prompt_prefix)
+                            .map(|prompt_name| {
+                                self.custom_prompts
+                                    .iter()
+                                    .any(|prompt| prompt.name == prompt_name)
+                            })
+                            .unwrap_or(false);
+                        if !is_builtin && !is_known_prompt {
+                            let message = format!(
+                                r#"Unrecognized command '/{name}'. Type "/" for a list of supported commands."#
+                            );
+                            self.app_event_tx.send(AppEvent::InsertHistoryCell(Box::new(
+                                history_cell::new_info_event(message, None),
+                            )));
+                            self.textarea.set_text(&original_input);
+                            self.textarea.set_cursor(original_input.len());
+                            return (InputResult::None, true);
+                        }
+                    }
+                }
+
+                if !input_starts_with_space
+                    && let Some((name, rest)) = parse_slash_name(&text)
+                    && !rest.is_empty()
+                    && !name.contains('/')
+                    && let Some((_n, cmd)) = built_in_slash_commands()
+                        .into_iter()
+                        .find(|(command_name, _)| *command_name == name)
+                    && matches!(cmd, SlashCommand::Review | SlashCommand::Automation)
+                {
+                    return (InputResult::CommandWithArgs(cmd, rest.to_string()), true);
+                }
+
+                let expanded_prompt = match expand_custom_prompt(&text, &self.custom_prompts) {
+                    Ok(expanded) => expanded,
+                    Err(err) => {
+                        self.app_event_tx.send(AppEvent::InsertHistoryCell(Box::new(
+                            history_cell::new_error_event(err.user_message()),
+                        )));
+                        self.textarea.set_text(&original_input);
+                        self.textarea.set_cursor(original_input.len());
+                        return (InputResult::None, true);
+                    }
+                };
+                if let Some(expanded) = expanded_prompt {
+                    text = expanded;
+                }
+                if text.is_empty() && !has_attachments {
+                    return (InputResult::None, true);
+                }
+                if !text.is_empty() {
+                    self.history.record_local_submission(&text);
+                }
+                // Do not clear attached_images here; ChatWidget drains them via take_recent_submission_images().
+                (InputResult::Submitted(text), true)
             }
-        };
-        if let Some(expanded) = expanded_prompt {
-            text = expanded;
+            input => self.handle_input_basic(input),
         }
-        if text.is_empty() && !has_attachments {
-            return (InputResult::None, true);
-        }
-        if !text.is_empty() {
-            self.history.record_local_submission(&text);
-        }
-        // Do not clear attached_images here; ChatWidget drains them via take_recent_submission_images().
-        let result = match mode {
-            SubmitMode::Submit => InputResult::Submitted(text),
-            SubmitMode::Queue => InputResult::Queued(text),
-        };
-        (result, true)
     }
 
     fn handle_paste_burst_flush(&mut self, now: Instant) -> bool {
@@ -1460,29 +1464,20 @@ impl ChatComposer {
             }
         }
 
-        // Backspace at the start of an image placeholder should delete that placeholder (rather
-        // than deleting content before it). Do this without scanning the full text by consulting
-        // the textarea's element list.
-        if matches!(input.code, KeyCode::Backspace)
-            && self.try_remove_image_element_at_cursor_start()
+        // For non-char inputs (or after flushing), handle normally.
+        // Special handling for backspace on placeholders
+        if let KeyEvent {
+            code: KeyCode::Backspace,
+            ..
+        } = input
+            && self.try_remove_any_placeholder_at_cursor()
         {
             return (InputResult::None, true);
         }
 
-        // For non-char inputs (or after flushing), handle normally.
-        // Track element removals so we can drop any corresponding placeholders without scanning
-        // the full text. (Placeholders are atomic elements; when deleted, the element disappears.)
-        let elements_before = if self.pending_pastes.is_empty() && self.attached_images.is_empty() {
-            None
-        } else {
-            Some(self.textarea.element_payloads())
-        };
-
+        // Normal input handling
         self.textarea.input(input);
-
-        if let Some(elements_before) = elements_before {
-            self.reconcile_deleted_elements(elements_before);
-        }
+        let text_after = self.textarea.text();
 
         // Update paste-burst heuristic for plain Char (no Ctrl/Alt) events.
         let crossterm::event::KeyEvent {
@@ -1504,69 +1499,176 @@ impl ChatComposer {
             }
         }
 
+        // Check if any placeholders were removed and remove their corresponding pending pastes
+        self.pending_pastes
+            .retain(|(placeholder, _)| text_after.contains(placeholder));
+
+        // Keep attached images in proportion to how many matching placeholders exist in the text.
+        // This handles duplicate placeholders that share the same visible label.
+        if !self.attached_images.is_empty() {
+            let mut needed: HashMap<String, usize> = HashMap::new();
+            for img in &self.attached_images {
+                needed
+                    .entry(img.placeholder.clone())
+                    .or_insert_with(|| text_after.matches(&img.placeholder).count());
+            }
+
+            let mut used: HashMap<String, usize> = HashMap::new();
+            let mut kept: Vec<AttachedImage> = Vec::with_capacity(self.attached_images.len());
+            for img in self.attached_images.drain(..) {
+                let total_needed = *needed.get(&img.placeholder).unwrap_or(&0);
+                let used_count = used.entry(img.placeholder.clone()).or_insert(0);
+                if *used_count < total_needed {
+                    kept.push(img);
+                    *used_count += 1;
+                }
+            }
+            self.attached_images = kept;
+        }
+
         (InputResult::None, true)
     }
 
-    fn try_remove_image_element_at_cursor_start(&mut self) -> bool {
-        if self.attached_images.is_empty() {
-            return false;
-        }
+    /// Attempts to remove an image or paste placeholder if the cursor is at the end of one.
+    /// Returns true if a placeholder was removed.
+    fn try_remove_any_placeholder_at_cursor(&mut self) -> bool {
+        // Clamp the cursor to a valid char boundary to avoid panics when slicing.
+        let text = self.textarea.text();
+        let p = Self::clamp_to_char_boundary(text, self.textarea.cursor());
 
-        let p = self.textarea.cursor();
-        let Some(payload) = self.textarea.element_payload_starting_at(p) else {
-            return false;
-        };
-        let Some(idx) = self
-            .attached_images
-            .iter()
-            .position(|img| img.placeholder == payload)
-        else {
-            return false;
-        };
-
-        self.textarea.replace_range(p..p + payload.len(), "");
-        self.attached_images.remove(idx);
-        self.relabel_attached_images_and_update_placeholders();
-        true
-    }
-
-    fn reconcile_deleted_elements(&mut self, elements_before: Vec<String>) {
-        let elements_after: HashSet<String> =
-            self.textarea.element_payloads().into_iter().collect();
-
-        let mut removed_any_image = false;
-        for removed in elements_before
-            .into_iter()
-            .filter(|payload| !elements_after.contains(payload))
-        {
-            self.pending_pastes.retain(|(ph, _)| ph != &removed);
-
-            if let Some(idx) = self
-                .attached_images
-                .iter()
-                .position(|img| img.placeholder == removed)
-            {
-                self.attached_images.remove(idx);
-                removed_any_image = true;
+        // Try image placeholders first
+        let mut out: Option<(usize, String)> = None;
+        // Detect if the cursor is at the end of any image placeholder.
+        // If duplicates exist, remove the specific occurrence's mapping.
+        for (i, img) in self.attached_images.iter().enumerate() {
+            let ph = &img.placeholder;
+            if p < ph.len() {
+                continue;
             }
-        }
-
-        if removed_any_image {
-            self.relabel_attached_images_and_update_placeholders();
-        }
-    }
-
-    fn relabel_attached_images_and_update_placeholders(&mut self) {
-        for idx in 0..self.attached_images.len() {
-            let expected = local_image_label_text(idx + 1);
-            let current = self.attached_images[idx].placeholder.clone();
-            if current == expected {
+            let start = p - ph.len();
+            if text.get(start..p) != Some(ph.as_str()) {
                 continue;
             }
 
-            self.attached_images[idx].placeholder = expected.clone();
-            let _renamed = self.textarea.replace_element_payload(&current, &expected);
+            // Count the number of occurrences of `ph` before `start`.
+            let mut occ_before = 0usize;
+            let mut search_pos = 0usize;
+            while search_pos < start {
+                let segment = match text.get(search_pos..start) {
+                    Some(s) => s,
+                    None => break,
+                };
+                if let Some(found) = segment.find(ph) {
+                    occ_before += 1;
+                    search_pos += found + ph.len();
+                } else {
+                    break;
+                }
+            }
+
+            // Remove the occ_before-th attached image that shares this placeholder label.
+            out = if let Some((remove_idx, _)) = self
+                .attached_images
+                .iter()
+                .enumerate()
+                .filter(|(_, img2)| img2.placeholder == *ph)
+                .nth(occ_before)
+            {
+                Some((remove_idx, ph.clone()))
+            } else {
+                Some((i, ph.clone()))
+            };
+            break;
         }
+        if let Some((idx, placeholder)) = out {
+            self.textarea.replace_range(p - placeholder.len()..p, "");
+            self.attached_images.remove(idx);
+            return true;
+        }
+
+        // Also handle when the cursor is at the START of an image placeholder.
+        // let result = 'out: {
+        let out: Option<(usize, String)> = 'out: {
+            for (i, img) in self.attached_images.iter().enumerate() {
+                let ph = &img.placeholder;
+                if p + ph.len() > text.len() {
+                    continue;
+                }
+                if text.get(p..p + ph.len()) != Some(ph.as_str()) {
+                    continue;
+                }
+
+                // Count occurrences of `ph` before `p`.
+                let mut occ_before = 0usize;
+                let mut search_pos = 0usize;
+                while search_pos < p {
+                    let segment = match text.get(search_pos..p) {
+                        Some(s) => s,
+                        None => break 'out None,
+                    };
+                    if let Some(found) = segment.find(ph) {
+                        occ_before += 1;
+                        search_pos += found + ph.len();
+                    } else {
+                        break 'out None;
+                    }
+                }
+
+                if let Some((remove_idx, _)) = self
+                    .attached_images
+                    .iter()
+                    .enumerate()
+                    .filter(|(_, img2)| img2.placeholder == *ph)
+                    .nth(occ_before)
+                {
+                    break 'out Some((remove_idx, ph.clone()));
+                } else {
+                    break 'out Some((i, ph.clone()));
+                }
+            }
+            None
+        };
+
+        if let Some((idx, placeholder)) = out {
+            self.textarea.replace_range(p..p + placeholder.len(), "");
+            self.attached_images.remove(idx);
+            return true;
+        }
+
+        // Then try pasted-content placeholders
+        if let Some(placeholder) = self.pending_pastes.iter().find_map(|(ph, _)| {
+            if p < ph.len() {
+                return None;
+            }
+            let start = p - ph.len();
+            if text.get(start..p) == Some(ph.as_str()) {
+                Some(ph.clone())
+            } else {
+                None
+            }
+        }) {
+            self.textarea.replace_range(p - placeholder.len()..p, "");
+            self.pending_pastes.retain(|(ph, _)| ph != &placeholder);
+            return true;
+        }
+
+        // Also handle when the cursor is at the START of a pasted-content placeholder.
+        if let Some(placeholder) = self.pending_pastes.iter().find_map(|(ph, _)| {
+            if p + ph.len() > text.len() {
+                return None;
+            }
+            if text.get(p..p + ph.len()) == Some(ph.as_str()) {
+                Some(ph.clone())
+            } else {
+                None
+            }
+        }) {
+            self.textarea.replace_range(p..p + placeholder.len(), "");
+            self.pending_pastes.retain(|(ph, _)| ph != &placeholder);
+            return true;
+        }
+
+        false
     }
 
     fn handle_shortcut_overlay_key(&mut self, key_event: &KeyEvent) -> bool {
@@ -3375,12 +3477,12 @@ mod tests {
             false,
         );
         let path = PathBuf::from("/tmp/image1.png");
-        composer.attach_image(path.clone());
+        composer.attach_image(path.clone(), 32, 16, "PNG");
         composer.handle_paste(" hi".into());
         let (result, _) =
             composer.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
         match result {
-            InputResult::Submitted(text) => assert_eq!(text, "[Image #1] hi"),
+            InputResult::Submitted(text) => assert_eq!(text, "[image1.png 32x16] hi"),
             _ => panic!("expected Submitted"),
         }
         let imgs = composer.take_recent_submission_images();
@@ -3399,11 +3501,11 @@ mod tests {
             false,
         );
         let path = PathBuf::from("/tmp/image2.png");
-        composer.attach_image(path.clone());
+        composer.attach_image(path.clone(), 10, 5, "PNG");
         let (result, _) =
             composer.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
         match result {
-            InputResult::Submitted(text) => assert_eq!(text, "[Image #1]"),
+            InputResult::Submitted(text) => assert_eq!(text, "[image2.png 10x5]"),
             _ => panic!("expected Submitted"),
         }
         let imgs = composer.take_recent_submission_images();
@@ -3424,15 +3526,21 @@ mod tests {
             false,
         );
         let path = PathBuf::from("/tmp/image_dup.png");
-        composer.attach_image(path.clone());
+        composer.attach_image(path.clone(), 10, 5, "PNG");
         composer.handle_paste(" ".into());
-        composer.attach_image(path);
+        composer.attach_image(path, 10, 5, "PNG");
 
         let text = composer.textarea.text().to_string();
-        assert!(text.contains("[Image #1]"));
-        assert!(text.contains("[Image #2]"));
-        assert_eq!(composer.attached_images[0].placeholder, "[Image #1]");
-        assert_eq!(composer.attached_images[1].placeholder, "[Image #2]");
+        assert!(text.contains("[image_dup.png 10x5]"));
+        assert!(text.contains("[image_dup.png 10x5 #2]"));
+        assert_eq!(
+            composer.attached_images[0].placeholder,
+            "[image_dup.png 10x5]"
+        );
+        assert_eq!(
+            composer.attached_images[1].placeholder,
+            "[image_dup.png 10x5 #2]"
+        );
     }
 
     #[test]
@@ -3447,7 +3555,7 @@ mod tests {
             false,
         );
         let path = PathBuf::from("/tmp/image3.png");
-        composer.attach_image(path.clone());
+        composer.attach_image(path.clone(), 20, 10, "PNG");
         let placeholder = composer.attached_images[0].placeholder.clone();
 
         // Case 1: backspace at end
@@ -3458,7 +3566,7 @@ mod tests {
 
         // Re-add and test backspace in middle: should break the placeholder string
         // and drop the image mapping (same as text placeholder behavior).
-        composer.attach_image(path);
+        composer.attach_image(path, 20, 10, "PNG");
         let placeholder2 = composer.attached_images[0].placeholder.clone();
         // Move cursor to roughly middle of placeholder
         if let Some(start_pos) = composer.textarea.text().find(&placeholder2) {
@@ -3490,7 +3598,7 @@ mod tests {
 
         // Insert an image placeholder at the start
         let path = PathBuf::from("/tmp/image_multibyte.png");
-        composer.attach_image(path);
+        composer.attach_image(path, 10, 5, "PNG");
         // Add multibyte text after the placeholder
         composer.textarea.insert_str("日本語");
 
@@ -3499,11 +3607,16 @@ mod tests {
         composer.handle_key_event(KeyEvent::new(KeyCode::Backspace, KeyModifiers::NONE));
 
         assert_eq!(composer.attached_images.len(), 1);
-        assert!(composer.textarea.text().starts_with("[Image #1]"));
+        assert!(
+            composer
+                .textarea
+                .text()
+                .starts_with("[image_multibyte.png 10x5]")
+        );
     }
 
     #[test]
-    fn deleting_one_of_duplicate_image_placeholders_removes_one_entry() {
+    fn deleting_one_of_duplicate_image_placeholders_removes_matching_entry() {
         let (tx, _rx) = unbounded_channel::<AppEvent>();
         let sender = AppEventSender::new(tx);
         let mut composer = ChatComposer::new(
@@ -3517,10 +3630,10 @@ mod tests {
         let path1 = PathBuf::from("/tmp/image_dup1.png");
         let path2 = PathBuf::from("/tmp/image_dup2.png");
 
-        composer.attach_image(path1);
+        composer.attach_image(path1, 10, 5, "PNG");
         // separate placeholders with a space for clarity
         composer.handle_paste(" ".into());
-        composer.attach_image(path2.clone());
+        composer.attach_image(path2.clone(), 10, 5, "PNG");
 
         let placeholder1 = composer.attached_images[0].placeholder.clone();
         let placeholder2 = composer.attached_images[1].placeholder.clone();
@@ -3533,67 +3646,26 @@ mod tests {
         composer.handle_key_event(KeyEvent::new(KeyCode::Backspace, KeyModifiers::NONE));
 
         let new_text = composer.textarea.text().to_string();
-        assert_eq!(
-            1,
-            new_text.matches(&placeholder1).count(),
-            "one placeholder remains after deletion"
-        );
         assert_eq!(
             0,
-            new_text.matches(&placeholder2).count(),
-            "second placeholder was relabeled"
+            new_text.matches(&placeholder1).count(),
+            "first placeholder removed"
         );
         assert_eq!(
             1,
-            new_text.matches("[Image #1]").count(),
-            "remaining placeholder relabeled to #1"
+            new_text.matches(&placeholder2).count(),
+            "second placeholder remains"
         );
         assert_eq!(
             vec![AttachedImage {
                 path: path2,
-                placeholder: "[Image #1]".to_string()
+                placeholder: "[image_dup2.png 10x5]".to_string()
             }],
             composer.attached_images,
             "one image mapping remains"
         );
     }
 
-    #[test]
-    fn deleting_first_text_element_renumbers_following_text_element() {
-        use crossterm::event::KeyCode;
-        use crossterm::event::KeyEvent;
-        use crossterm::event::KeyModifiers;
-
-        let (tx, _rx) = unbounded_channel::<AppEvent>();
-        let sender = AppEventSender::new(tx);
-        let mut composer = ChatComposer::new(
-            true,
-            sender,
-            false,
-            "Ask Codex to do anything".to_string(),
-            false,
-        );
-
-        let path1 = PathBuf::from("/tmp/image_first.png");
-        let path2 = PathBuf::from("/tmp/image_second.png");
-
-        // Insert two adjacent atomic elements.
-        composer.attach_image(path1);
-        composer.attach_image(path2.clone());
-        assert_eq!(composer.textarea.text(), "[Image #1][Image #2]");
-        assert_eq!(composer.attached_images.len(), 2);
-
-        // Delete the first element using normal textarea editing (Delete at cursor start).
-        composer.textarea.set_cursor(0);
-        composer.handle_key_event(KeyEvent::new(KeyCode::Delete, KeyModifiers::NONE));
-
-        // Remaining image should be renumbered and the textarea element updated.
-        assert_eq!(composer.attached_images.len(), 1);
-        assert_eq!(composer.attached_images[0].path, path2);
-        assert_eq!(composer.attached_images[0].placeholder, "[Image #1]");
-        assert_eq!(composer.textarea.text(), "[Image #1]");
-    }
-
     #[test]
     fn pasting_filepath_attaches_image() {
         let tmp = tempdir().expect("create TempDir");
@@ -3614,7 +3686,12 @@ mod tests {
 
         let needs_redraw = composer.handle_paste(tmp_path.to_string_lossy().to_string());
         assert!(needs_redraw);
-        assert!(composer.textarea.text().starts_with("[Image #1] "));
+        assert!(
+            composer
+                .textarea
+                .text()
+                .starts_with("[codex_tui_test_paste_image.png 3x2] ")
+        );
 
         let imgs = composer.take_recent_submission_images();
         assert_eq!(imgs, vec![tmp_path]);

codex-rs/tui/src/bottom_pane/footer.rs

@@ -266,7 +266,6 @@ enum ShortcutId {
     Commands,
     ShellCommands,
     InsertNewline,
-    QueueMessage,
     FilePaths,
     PasteImage,
     ExternalEditor,
@@ -373,15 +372,6 @@ const SHORTCUTS: &[ShortcutDescriptor] = &[
         prefix: "",
         label: " for newline",
     },
-    ShortcutDescriptor {
-        id: ShortcutId::QueueMessage,
-        bindings: &[ShortcutBinding {
-            key: key_hint::ctrl(KeyCode::Char('k')),
-            condition: DisplayCondition::Always,
-        }],
-        prefix: "",
-        label: " to queue message",
-    },
     ShortcutDescriptor {
         id: ShortcutId::FilePaths,
         bindings: &[ShortcutBinding {

codex-rs/tui/src/bottom_pane/mod.rs

@@ -542,9 +542,16 @@ impl BottomPane {
         self.request_redraw();
     }
 
-    pub(crate) fn attach_image(&mut self, path: PathBuf) {
+    pub(crate) fn attach_image(
+        &mut self,
+        path: PathBuf,
+        width: u32,
+        height: u32,
+        format_label: &str,
+    ) {
         if self.view_stack.is_empty() {
-            self.composer.attach_image(path);
+            self.composer
+                .attach_image(path, width, height, format_label);
             self.request_redraw();
         }
     }

codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__footer_mode_shortcut_overlay.snap.new

@@ -1,19 +0,0 @@
----
-source: tui/src/bottom_pane/chat_composer.rs
-assertion_line: 2127
-expression: terminal.backend()
----
-"                                                                                                    "
-"› Ask Codex to do anything                                                                          "
-"                                                                                                    "
-"                                                                                                    "
-"                                                                                                    "
-"                                                                                                    "
-"                                                                                                    "
-"                                                                                                    "
-"  / for commands                             ! for shell commands                                   "
-"  shift + enter for newline                  ctrl + enter to send immediately                       "
-"  @ for file paths                           ctrl + v to paste images                               "
-"  ctrl + g to edit in external editor        esc again to edit previous message                     "
-"  ctrl + c to exit                                                                                  "
-"  ctrl + t to view transcript                                                                       "

codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__footer__tests__footer_shortcuts_shift_and_esc.snap.new

@@ -1,11 +0,0 @@
----
-source: tui/src/bottom_pane/footer.rs
-assertion_line: 468
-expression: terminal.backend()
----
-"  / for commands                             ! for shell commands               "
-"  shift + enter for newline                  ctrl + enter to send immediately   "
-"  @ for file paths                           ctrl + v to paste images           "
-"  ctrl + g to edit in external editor        esc again to edit previous message "
-"  ctrl + c to exit                                                              "
-"  ctrl + t to view transcript                                                   "

codex-rs/tui/src/bottom_pane/textarea.rs

@@ -715,88 +715,6 @@ impl TextArea {
 
     // ===== Text elements support =====
 
-    pub fn element_payloads(&self) -> Vec<String> {
-        self.elements
-            .iter()
-            .filter_map(|e| self.text.get(e.range.clone()).map(str::to_string))
-            .collect()
-    }
-
-    pub fn element_payload_starting_at(&self, pos: usize) -> Option<String> {
-        let pos = pos.min(self.text.len());
-        let elem = self.elements.iter().find(|e| e.range.start == pos)?;
-        self.text.get(elem.range.clone()).map(str::to_string)
-    }
-
-    /// Renames a single text element in-place, keeping it atomic.
-    ///
-    /// This is intended for cases where the element payload is an identifier (e.g. a placeholder)
-    /// that must be updated without converting the element back into normal text.
-    pub fn replace_element_payload(&mut self, old: &str, new: &str) -> bool {
-        let Some(idx) = self
-            .elements
-            .iter()
-            .position(|e| self.text.get(e.range.clone()) == Some(old))
-        else {
-            return false;
-        };
-
-        let range = self.elements[idx].range.clone();
-        let start = range.start;
-        let end = range.end;
-        if start > end || end > self.text.len() {
-            return false;
-        }
-
-        let removed_len = end - start;
-        let inserted_len = new.len();
-        let diff = inserted_len as isize - removed_len as isize;
-
-        self.text.replace_range(range, new);
-        self.wrap_cache.replace(None);
-        self.preferred_col = None;
-
-        // Update the modified element's range.
-        self.elements[idx].range = start..(start + inserted_len);
-
-        // Shift element ranges that occur after the replaced element.
-        if diff != 0 {
-            for (j, e) in self.elements.iter_mut().enumerate() {
-                if j == idx {
-                    continue;
-                }
-                if e.range.end <= start {
-                    continue;
-                }
-                if e.range.start >= end {
-                    e.range.start = ((e.range.start as isize) + diff) as usize;
-                    e.range.end = ((e.range.end as isize) + diff) as usize;
-                    continue;
-                }
-
-                // Elements should not partially overlap each other; degrade gracefully by
-                // snapping anything intersecting the replaced range to the new bounds.
-                e.range.start = start.min(e.range.start);
-                e.range.end = (start + inserted_len).max(e.range.end.saturating_add_signed(diff));
-            }
-        }
-
-        // Update the cursor position to account for the edit.
-        self.cursor_pos = if self.cursor_pos < start {
-            self.cursor_pos
-        } else if self.cursor_pos <= end {
-            start + inserted_len
-        } else {
-            ((self.cursor_pos as isize) + diff) as usize
-        };
-        self.cursor_pos = self.clamp_pos_to_nearest_boundary(self.cursor_pos);
-
-        // Keep element ordering deterministic.
-        self.elements.sort_by_key(|e| e.range.start);
-
-        true
-    }
-
     pub fn insert_element(&mut self, text: &str) {
         let start = self.clamp_pos_for_insertion(self.cursor_pos);
         self.insert_str_at(start, text);

codex-rs/tui/src/chatwidget.rs

@@ -5,6 +5,8 @@ use std::path::PathBuf;
 use std::sync::Arc;
 use std::time::Duration;
 
+use chrono::Local;
+use chrono::TimeZone;
 use codex_app_server_protocol::AuthMode;
 use codex_backend_client::Client as BackendClient;
 use codex_core::config::Config;
@@ -83,6 +85,7 @@ use ratatui::widgets::Wrap;
 use tokio::sync::mpsc::UnboundedSender;
 use tokio::task::JoinHandle;
 use tracing::debug;
+use uuid::Uuid;
 
 use crate::app_event::AppEvent;
 #[cfg(target_os = "windows")]
@@ -134,7 +137,6 @@ use self::session_header::SessionHeader;
 use crate::streaming::controller::StreamController;
 use std::path::Path;
 
-use chrono::Local;
 use codex_common::approval_presets::ApprovalPreset;
 use codex_common::approval_presets::builtin_approval_presets;
 use codex_core::AuthManager;
@@ -194,6 +196,7 @@ fn is_standard_tool_call(parsed_cmd: &[ParsedCommand]) -> bool {
 const RATE_LIMIT_WARNING_THRESHOLDS: [f64; 3] = [75.0, 90.0, 95.0];
 const NUDGE_MODEL_SLUG: &str = "gpt-5.1-codex-mini";
 const RATE_LIMIT_SWITCH_PROMPT_THRESHOLD: f64 = 90.0;
+const AUTOMATION_TICK_SECS: u64 = 30;
 
 #[derive(Default)]
 struct RateLimitWarningState {
@@ -282,6 +285,71 @@ pub(crate) fn get_limits_duration(windows_minutes: i64) -> String {
     }
 }
 
+fn now_ms() -> u64 {
+    let Ok(duration) = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH) else {
+        return 0;
+    };
+    duration.as_millis().min(u128::from(u64::MAX)) as u64
+}
+
+fn format_timestamp(ms: u64) -> String {
+    Local
+        .timestamp_millis_opt(ms as i64)
+        .single()
+        .map(|ts| ts.format("%Y-%m-%d %H:%M:%S").to_string())
+        .unwrap_or_else(|| "-".to_string())
+}
+
+fn format_interval(interval: Duration) -> String {
+    let secs = interval.as_secs();
+    if secs % 86_400 == 0 {
+        format!("{}d", secs / 86_400)
+    } else if secs % 3_600 == 0 {
+        format!("{}h", secs / 3_600)
+    } else if secs % 60 == 0 {
+        format!("{}m", secs / 60)
+    } else {
+        format!("{}s", secs)
+    }
+}
+
+fn parse_interval_spec(spec: &str) -> Option<Duration> {
+    let trimmed = spec.trim();
+    if trimmed.is_empty() {
+        return None;
+    }
+    let (value_str, unit) = trimmed.split_at(trimmed.len().saturating_sub(1));
+    let (value, unit) = if value_str.is_empty() || value_str.chars().any(|c| !c.is_ascii_digit()) {
+        (trimmed, "")
+    } else {
+        (value_str, unit)
+    };
+    let value: u64 = value.parse().ok()?;
+    if value == 0 {
+        return None;
+    }
+    let secs = match unit {
+        "s" => value,
+        "m" | "" => value.checked_mul(60)?,
+        "h" => value.checked_mul(3_600)?,
+        "d" => value.checked_mul(86_400)?,
+        _ => return None,
+    };
+    Some(Duration::from_secs(secs))
+}
+
+fn summarize_prompt(prompt: &str) -> String {
+    const MAX: usize = 80;
+    let trimmed = prompt.trim().replace('\n', " ");
+    if trimmed.chars().count() <= MAX {
+        trimmed
+    } else {
+        let mut out = trimmed.chars().take(MAX - 3).collect::<String>();
+        out.push_str("...");
+        out
+    }
+}
+
 /// Common initialization parameters shared by all `ChatWidget` constructors.
 pub(crate) struct ChatWidgetInit {
     pub(crate) config: Config,
@@ -313,6 +381,14 @@ pub(crate) enum ExternalEditorState {
     Active,
 }
 
+struct Automation {
+    id: Uuid,
+    prompt: String,
+    interval: Duration,
+    next_run_at_ms: u64,
+    last_run_at_ms: Option<u64>,
+}
+
 pub(crate) struct ChatWidget {
     app_event_tx: AppEventSender,
     codex_op_tx: UnboundedSender<Op>,
@@ -330,6 +406,7 @@ pub(crate) struct ChatWidget {
     rate_limit_warnings: RateLimitWarningState,
     rate_limit_switch_prompt: RateLimitSwitchPromptState,
     rate_limit_poller: Option<JoinHandle<()>>,
+    automation_ticker: Option<JoinHandle<()>>,
     // Stream lifecycle controller
     stream_controller: Option<StreamController>,
     running_commands: HashMap<String, RunningCommand>,
@@ -357,6 +434,7 @@ pub(crate) struct ChatWidget {
     suppress_session_configured_redraw: bool,
     // User messages queued while a turn is in progress
     queued_user_messages: VecDeque<UserMessage>,
+    automations: Vec<Automation>,
     // Pending notification to show when unfocused on next Draw
     pending_notification: Option<Notification>,
     // Simple review mode flag; used to adjust layout and banners.
@@ -374,9 +452,16 @@ pub(crate) struct ChatWidget {
     external_editor_state: ExternalEditorState,
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum UserMessageSource {
+    User,
+    Automation(Uuid),
+}
+
 struct UserMessage {
     text: String,
     image_paths: Vec<PathBuf>,
+    source: UserMessageSource,
 }
 
 impl From<String> for UserMessage {
@@ -384,6 +469,7 @@ impl From<String> for UserMessage {
         Self {
             text,
             image_paths: Vec::new(),
+            source: UserMessageSource::User,
         }
     }
 }
@@ -393,15 +479,34 @@ impl From<&str> for UserMessage {
         Self {
             text: text.to_string(),
             image_paths: Vec::new(),
+            source: UserMessageSource::User,
         }
     }
 }
 
+impl UserMessage {
+    fn automation(prompt: String, id: Uuid) -> Self {
+        Self {
+            text: prompt,
+            image_paths: Vec::new(),
+            source: UserMessageSource::Automation(id),
+        }
+    }
+
+    fn is_automation(&self) -> bool {
+        matches!(self.source, UserMessageSource::Automation(_))
+    }
+}
+
 fn create_initial_user_message(text: String, image_paths: Vec<PathBuf>) -> Option<UserMessage> {
     if text.is_empty() && image_paths.is_empty() {
         None
     } else {
-        Some(UserMessage { text, image_paths })
+        Some(UserMessage {
+            text,
+            image_paths,
+            source: UserMessageSource::User,
+        })
     }
 }
 
@@ -1455,6 +1560,7 @@ impl ChatWidget {
             rate_limit_warnings: RateLimitWarningState::default(),
             rate_limit_switch_prompt: RateLimitSwitchPromptState::default(),
             rate_limit_poller: None,
+            automation_ticker: None,
             stream_controller: None,
             running_commands: HashMap::new(),
             suppressed_exec_calls: HashSet::new(),
@@ -1469,6 +1575,7 @@ impl ChatWidget {
             retry_status_header: None,
             thread_id: None,
             queued_user_messages: VecDeque::new(),
+            automations: Vec::new(),
             show_welcome_banner: is_first_run,
             suppress_session_configured_redraw: false,
             pending_notification: None,
@@ -1541,6 +1648,7 @@ impl ChatWidget {
             rate_limit_warnings: RateLimitWarningState::default(),
             rate_limit_switch_prompt: RateLimitSwitchPromptState::default(),
             rate_limit_poller: None,
+            automation_ticker: None,
             stream_controller: None,
             running_commands: HashMap::new(),
             suppressed_exec_calls: HashSet::new(),
@@ -1555,6 +1663,7 @@ impl ChatWidget {
             retry_status_header: None,
             thread_id: None,
             queued_user_messages: VecDeque::new(),
+            automations: Vec::new(),
             show_welcome_banner: false,
             suppress_session_configured_redraw: true,
             pending_notification: None,
@@ -1593,13 +1702,12 @@ impl ChatWidget {
             {
                 match paste_image_to_temp_png() {
                     Ok((path, info)) => {
-                        tracing::debug!(
-                            "pasted image size={}x{} format={}",
+                        self.attach_image(
+                            path,
                             info.width,
                             info.height,
-                            info.encoded_format.label()
+                            info.encoded_format.label(),
                         );
-                        self.attach_image(path);
                     }
                     Err(err) => {
                         tracing::warn!("failed to paste image: {err}");
@@ -1630,35 +1738,41 @@ impl ChatWidget {
                     self.request_redraw();
                 }
             }
-            _ => match self.bottom_pane.handle_key_event(key_event) {
-                InputResult::Submitted(text) => {
-                    let user_message = UserMessage {
-                        text,
-                        image_paths: self.bottom_pane.take_recent_submission_images(),
-                    };
-                    self.submit_user_message(user_message);
+            _ => {
+                match self.bottom_pane.handle_key_event(key_event) {
+                    InputResult::Submitted(text) => {
+                        // If a task is running, queue the user input to be sent after the turn completes.
+                        let user_message = UserMessage {
+                            text,
+                            image_paths: self.bottom_pane.take_recent_submission_images(),
+                            source: UserMessageSource::User,
+                        };
+                        self.queue_user_message(user_message);
+                    }
+                    InputResult::Command(cmd) => {
+                        self.dispatch_command(cmd);
+                    }
+                    InputResult::CommandWithArgs(cmd, args) => {
+                        self.dispatch_command_with_args(cmd, args);
+                    }
+                    InputResult::None => {}
                 }
-                InputResult::Queued(text) => {
-                    let user_message = UserMessage {
-                        text,
-                        image_paths: self.bottom_pane.take_recent_submission_images(),
-                    };
-                    self.queue_user_message(user_message);
-                }
-                InputResult::Command(cmd) => {
-                    self.dispatch_command(cmd);
-                }
-                InputResult::CommandWithArgs(cmd, args) => {
-                    self.dispatch_command_with_args(cmd, args);
-                }
-                InputResult::None => {}
-            },
+            }
         }
     }
 
-    pub(crate) fn attach_image(&mut self, path: PathBuf) {
-        tracing::info!("attach_image path={path:?}");
-        self.bottom_pane.attach_image(path);
+    pub(crate) fn attach_image(
+        &mut self,
+        path: PathBuf,
+        width: u32,
+        height: u32,
+        format_label: &str,
+    ) {
+        tracing::info!(
+            "attach_image path={path:?} width={width} height={height} format={format_label}",
+        );
+        self.bottom_pane
+            .attach_image(path, width, height, format_label);
         self.request_redraw();
     }
 
@@ -1825,6 +1939,9 @@ impl ChatWidget {
             SlashCommand::Status => {
                 self.add_status_output();
             }
+            SlashCommand::Automation => {
+                self.show_automation_help();
+            }
             SlashCommand::Ps => {
                 self.add_ps_output();
             }
@@ -1905,6 +2022,9 @@ impl ChatWidget {
                     },
                 });
             }
+            SlashCommand::Automation => {
+                self.handle_automation_command(trimmed);
+            }
             _ => self.dispatch_command(cmd),
         }
     }
@@ -1982,11 +2102,35 @@ impl ChatWidget {
         }
     }
 
+    fn queue_automation_message(&mut self, id: Uuid, prompt: String) {
+        let message = UserMessage::automation(prompt, id);
+        if self.bottom_pane.is_task_running() {
+            if self.queued_user_messages.iter().any(UserMessage::is_automation) {
+                return;
+            }
+            self.queued_user_messages.push_back(message);
+            self.refresh_queued_user_messages();
+        } else {
+            self.submit_user_message(message);
+        }
+    }
+
     fn submit_user_message(&mut self, user_message: UserMessage) {
-        let UserMessage { text, image_paths } = user_message;
+        let is_automation = user_message.is_automation();
+        let UserMessage {
+            text,
+            image_paths,
+            ..
+        } = user_message;
         if text.is_empty() && image_paths.is_empty() {
             return;
         }
+        if is_automation {
+            self.add_info_message(
+                format!("Automation fired at {}: {}", format_timestamp(now_ms()), text),
+                None,
+            );
+        }
 
         let mut items: Vec<UserInput> = Vec::new();
 
@@ -2008,14 +2152,14 @@ impl ChatWidget {
             return;
         }
 
-        for path in image_paths {
-            items.push(UserInput::LocalImage { path });
-        }
-
         if !text.is_empty() {
             items.push(UserInput::Text { text: text.clone() });
         }
 
+        for path in image_paths {
+            items.push(UserInput::LocalImage { path });
+        }
+
         if let Some(skills) = self.bottom_pane.skills() {
             let skill_mentions = find_skill_mentions(&text, skills);
             for skill in skill_mentions {
@@ -2345,12 +2489,191 @@ impl ChatWidget {
         self.add_to_history(history_cell::new_unified_exec_processes_output(processes));
     }
 
+    fn show_automation_help(&mut self) {
+        self.add_info_message(
+            "Automation commands: /automation list | /automation add <interval> <prompt> | /automation remove <id> | /automation clear (interval example: 5m, 1h, 30s)".to_string(),
+            None,
+        );
+    }
+
+    fn show_automation_list(&mut self) {
+        if self.automations.is_empty() {
+            self.add_info_message("No automations scheduled for this session.".to_string(), None);
+            return;
+        }
+        let mut lines = Vec::with_capacity(self.automations.len() + 1);
+        lines.push(Line::from("Automations (session-only):"));
+        for automation in &self.automations {
+            let next_run = format_timestamp(automation.next_run_at_ms);
+            let last_run = automation
+                .last_run_at_ms
+                .map(format_timestamp)
+                .unwrap_or_else(|| "-".to_string());
+            lines.push(Line::from(format!(
+                "{} | every {} | next {} | last {} | {}",
+                automation.id,
+                format_interval(automation.interval),
+                next_run,
+                last_run,
+                summarize_prompt(&automation.prompt),
+            )));
+        }
+        self.add_plain_history_lines(lines);
+    }
+
+    fn add_automation(&mut self, interval: Duration, prompt: String) {
+        let now = now_ms();
+        let interval_ms = interval.as_millis().min(u128::from(u64::MAX)) as u64;
+        let next_run_at_ms = now.saturating_add(interval_ms);
+        let id = Uuid::new_v4();
+        self.automations.push(Automation {
+            id,
+            prompt,
+            interval,
+            next_run_at_ms,
+            last_run_at_ms: None,
+        });
+        self.refresh_automation_ticker();
+        self.add_info_message(
+            format!(
+                "Automation {id} scheduled every {}. Next run at {}.",
+                format_interval(interval),
+                format_timestamp(next_run_at_ms),
+            ),
+            None,
+        );
+    }
+
+    fn remove_automation(&mut self, id: Uuid) {
+        let before = self.automations.len();
+        self.automations.retain(|automation| automation.id != id);
+        if self.automations.len() == before {
+            self.add_error_message(format!("No automation found for id {id}."));
+            return;
+        }
+        self.refresh_automation_ticker();
+        self.add_info_message(format!("Removed automation {id}."), None);
+    }
+
+    fn clear_automations(&mut self) {
+        if self.automations.is_empty() {
+            self.add_info_message("No automations to clear.".to_string(), None);
+            return;
+        }
+        self.automations.clear();
+        self.refresh_automation_ticker();
+        self.add_info_message("Cleared all automations for this session.".to_string(), None);
+    }
+
+    fn handle_automation_command(&mut self, args: &str) {
+        let trimmed = args.trim();
+        if trimmed.is_empty() {
+            self.show_automation_help();
+            return;
+        }
+        let action = trimmed.split_whitespace().next().unwrap_or("");
+        let rest = trimmed[action.len()..].trim();
+        match action {
+            "list" => self.show_automation_list(),
+            "add" => {
+                let interval_spec = rest.split_whitespace().next().unwrap_or("");
+                let prompt = rest[interval_spec.len()..].trim();
+                let Some(interval) = parse_interval_spec(interval_spec) else {
+                    self.add_error_message(
+                        "Usage: /automation add <interval> <prompt> (example: /automation add 5m check status)".to_string(),
+                    );
+                    return;
+                };
+                if prompt.is_empty() {
+                    self.add_error_message(
+                        "Usage: /automation add <interval> <prompt> (example: /automation add 5m check status)".to_string(),
+                    );
+                    return;
+                }
+                self.add_automation(interval, prompt.to_string());
+            }
+            "remove" | "rm" | "delete" => {
+                let id_str = rest.trim();
+                let Ok(id) = Uuid::parse_str(id_str) else {
+                    self.add_error_message(
+                        "Usage: /automation remove <id> (use /automation list to find ids)".to_string(),
+                    );
+                    return;
+                };
+                self.remove_automation(id);
+            }
+            "clear" => self.clear_automations(),
+            _ => self.show_automation_help(),
+        }
+    }
+
     fn stop_rate_limit_poller(&mut self) {
         if let Some(handle) = self.rate_limit_poller.take() {
             handle.abort();
         }
     }
 
+    fn stop_automation_ticker(&mut self) {
+        if let Some(handle) = self.automation_ticker.take() {
+            handle.abort();
+        }
+    }
+
+    fn ensure_automation_ticker(&mut self) {
+        if self.automation_ticker.is_some() {
+            return;
+        }
+        let app_event_tx = self.app_event_tx.clone();
+        let handle = tokio::spawn(async move {
+            let mut interval = tokio::time::interval(Duration::from_secs(AUTOMATION_TICK_SECS));
+            loop {
+                interval.tick().await;
+                app_event_tx.send(AppEvent::AutomationTick);
+            }
+        });
+        self.automation_ticker = Some(handle);
+    }
+
+    fn refresh_automation_ticker(&mut self) {
+        if self.automations.is_empty() {
+            self.stop_automation_ticker();
+        } else {
+            self.ensure_automation_ticker();
+        }
+    }
+
+    pub(crate) fn on_automation_tick(&mut self) {
+        if self.automations.is_empty() {
+            self.stop_automation_ticker();
+            return;
+        }
+        if self.queued_user_messages.iter().any(UserMessage::is_automation) {
+            return;
+        }
+        let now = now_ms();
+        let mut next_index: Option<usize> = None;
+        let mut earliest_due = u64::MAX;
+        for (idx, automation) in self.automations.iter().enumerate() {
+            if automation.next_run_at_ms <= now && automation.next_run_at_ms < earliest_due {
+                earliest_due = automation.next_run_at_ms;
+                next_index = Some(idx);
+            }
+        }
+        let Some(index) = next_index else {
+            return;
+        };
+        let automation = &mut self.automations[index];
+        let interval_ms = automation
+            .interval
+            .as_millis()
+            .min(u128::from(u64::MAX)) as u64;
+        automation.last_run_at_ms = Some(now);
+        automation.next_run_at_ms = now.saturating_add(interval_ms);
+        let id = automation.id;
+        let prompt = automation.prompt.clone();
+        self.queue_automation_message(id, prompt);
+    }
+
     fn prefetch_rate_limits(&mut self) {
         self.stop_rate_limit_poller();
 
@@ -3905,6 +4228,7 @@ impl ChatWidget {
 impl Drop for ChatWidget {
     fn drop(&mut self) {
         self.stop_rate_limit_poller();
+        self.stop_automation_ticker();
     }
 }
 

codex-rs/tui/src/chatwidget/tests.rs

@@ -401,6 +401,7 @@ async fn make_chatwidget_manual(
         rate_limit_warnings: RateLimitWarningState::default(),
         rate_limit_switch_prompt: RateLimitSwitchPromptState::default(),
         rate_limit_poller: None,
+        automation_ticker: None,
         stream_controller: None,
         running_commands: HashMap::new(),
         suppressed_exec_calls: HashSet::new(),
@@ -417,6 +418,7 @@ async fn make_chatwidget_manual(
         frame_requester: FrameRequester::test_dummy(),
         show_welcome_banner: true,
         queued_user_messages: VecDeque::new(),
+        automations: Vec::new(),
         suppress_session_configured_redraw: false,
         pending_notification: None,
         is_review_mode: false,
@@ -1057,7 +1059,7 @@ async fn enqueueing_history_prompt_multiple_times_is_stable() {
         assert_eq!(chat.bottom_pane.composer_text(), "repeat me");
 
         // Queue the prompt while the task is running.
-        chat.handle_key_event(KeyEvent::new(KeyCode::Char('k'), KeyModifiers::CONTROL));
+        chat.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
     }
 
     assert_eq!(chat.queued_user_messages.len(), 3);
@@ -1079,7 +1081,7 @@ async fn streaming_final_answer_keeps_task_running_state() {
 
     chat.bottom_pane
         .set_composer_text("queued submission".to_string());
-    chat.handle_key_event(KeyEvent::new(KeyCode::Char('k'), KeyModifiers::CONTROL));
+    chat.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
 
     assert_eq!(chat.queued_user_messages.len(), 1);
     assert_eq!(
@@ -1114,8 +1116,8 @@ async fn ctrl_c_cleared_prompt_is_recoverable_via_history() {
 
     chat.bottom_pane.insert_str("draft message ");
     chat.bottom_pane
-        .attach_image(PathBuf::from("/tmp/preview.png"));
-    let placeholder = "[Image #1]";
+        .attach_image(PathBuf::from("/tmp/preview.png"), 24, 42, "png");
+    let placeholder = "[preview.png 24x42]";
     assert!(
         chat.bottom_pane.composer_text().ends_with(placeholder),
         "expected placeholder {placeholder:?} in composer text"

codex-rs/tui/src/public_widgets/composer_input.rs

@@ -54,9 +54,7 @@ impl ComposerInput {
     /// Feed a key event into the composer and return a high-level action.
     pub fn input(&mut self, key: KeyEvent) -> ComposerAction {
         let action = match self.inner.handle_key_event(key).0 {
-            InputResult::Submitted(text) | InputResult::Queued(text) => {
-                ComposerAction::Submitted(text)
-            }
+            InputResult::Submitted(text) => ComposerAction::Submitted(text),
             _ => ComposerAction::None,
         };
         self.drain_app_events();

codex-rs/tui/src/slash_command.rs

@@ -27,6 +27,7 @@ pub enum SlashCommand {
     Diff,
     Mention,
     Status,
+    Automation,
     Mcp,
     Logout,
     Quit,
@@ -53,6 +54,7 @@ impl SlashCommand {
             SlashCommand::Mention => "mention a file",
             SlashCommand::Skills => "use skills to improve how Codex performs specific tasks",
             SlashCommand::Status => "show current session configuration and token usage",
+            SlashCommand::Automation => "manage scheduled prompts for this session",
             SlashCommand::Ps => "list background terminals",
             SlashCommand::Model => "choose what model and reasoning effort to use",
             SlashCommand::Approvals => "choose what Codex can do without approval",
@@ -89,6 +91,7 @@ impl SlashCommand {
             | SlashCommand::Mention
             | SlashCommand::Skills
             | SlashCommand::Status
+            | SlashCommand::Automation
             | SlashCommand::Ps
             | SlashCommand::Mcp
             | SlashCommand::Feedback

codex-rs/tui/src/status/card.rs

@@ -17,7 +17,6 @@ use ratatui::prelude::*;
 use ratatui::style::Stylize;
 use std::collections::BTreeSet;
 use std::path::PathBuf;
-use url::Url;
 
 use super::account::StatusAccountDisplay;
 use super::format::FieldFormatter;
@@ -63,7 +62,6 @@ struct StatusHistoryCell {
     approval: String,
     sandbox: String,
     agents_summary: String,
-    model_provider: Option<String>,
     account: Option<StatusAccountDisplay>,
     session_id: Option<String>,
     token_usage: StatusTokenUsageData,
@@ -131,7 +129,6 @@ impl StatusHistoryCell {
             }
         };
         let agents_summary = compose_agents_summary(config);
-        let model_provider = format_model_provider(config);
         let account = compose_account_display(auth_manager, plan_type);
         let session_id = session_id.as_ref().map(std::string::ToString::to_string);
         let default_usage = TokenUsage::default();
@@ -160,7 +157,6 @@ impl StatusHistoryCell {
             approval,
             sandbox,
             agents_summary,
-            model_provider,
             account,
             session_id,
             token_usage,
@@ -342,9 +338,6 @@ impl HistoryCell for StatusHistoryCell {
                 .collect();
         let mut seen: BTreeSet<String> = labels.iter().cloned().collect();
 
-        if self.model_provider.is_some() {
-            push_label(&mut labels, &mut seen, "Model provider");
-        }
         if account_value.is_some() {
             push_label(&mut labels, &mut seen, "Account");
         }
@@ -388,9 +381,6 @@ impl HistoryCell for StatusHistoryCell {
         let directory_value = format_directory_display(&self.directory, Some(value_width));
 
         lines.push(formatter.line("Model", model_spans));
-        if let Some(model_provider) = self.model_provider.as_ref() {
-            lines.push(formatter.line("Model provider", vec![Span::from(model_provider.clone())]));
-        }
         lines.push(formatter.line("Directory", vec![Span::from(directory_value)]));
         lines.push(formatter.line("Approval", vec![Span::from(self.approval.clone())]));
         lines.push(formatter.line("Sandbox", vec![Span::from(self.sandbox.clone())]));
@@ -426,39 +416,3 @@ impl HistoryCell for StatusHistoryCell {
         with_border_with_inner_width(truncated_lines, inner_width)
     }
 }
-
-fn format_model_provider(config: &Config) -> Option<String> {
-    let provider = &config.model_provider;
-    let name = provider.name.trim();
-    let provider_name = if name.is_empty() {
-        config.model_provider_id.as_str()
-    } else {
-        name
-    };
-    let base_url = provider.base_url.as_deref().and_then(sanitize_base_url);
-    let is_default_openai = provider.is_openai() && base_url.is_none();
-    if is_default_openai {
-        return None;
-    }
-
-    Some(match base_url {
-        Some(base_url) => format!("{provider_name} - {base_url}"),
-        None => provider_name.to_string(),
-    })
-}
-
-fn sanitize_base_url(raw: &str) -> Option<String> {
-    let trimmed = raw.trim();
-    if trimmed.is_empty() {
-        return None;
-    }
-
-    let Ok(mut url) = Url::parse(trimmed) else {
-        return None;
-    };
-    let _ = url.set_username("");
-    let _ = url.set_password(None);
-    url.set_query(None);
-    url.set_fragment(None);
-    Some(url.to_string().trim_end_matches('/').to_string()).filter(|value| !value.is_empty())
-}

codex-rs/tui2/src/bottom_pane/chat_composer.rs

@@ -49,7 +49,6 @@ use crate::style::user_message_style;
 use codex_common::fuzzy_match::fuzzy_match;
 use codex_protocol::custom_prompts::CustomPrompt;
 use codex_protocol::custom_prompts::PROMPTS_CMD_PREFIX;
-use codex_protocol::models::local_image_label_text;
 
 use crate::app_event::AppEvent;
 use crate::app_event_sender::AppEventSender;
@@ -63,7 +62,7 @@ use codex_core::skills::model::SkillMetadata;
 use codex_file_search::FileMatch;
 use std::cell::RefCell;
 use std::collections::HashMap;
-use std::collections::HashSet;
+use std::path::Path;
 use std::path::PathBuf;
 use std::time::Duration;
 use std::time::Instant;
@@ -83,7 +82,6 @@ const LARGE_PASTE_CHAR_THRESHOLD: usize = 1000;
 #[derive(Debug, PartialEq)]
 pub enum InputResult {
     Submitted(String),
-    Queued(String),
     Command(SlashCommand),
     CommandWithArgs(SlashCommand, String),
     None,
@@ -105,12 +103,6 @@ enum PromptSelectionAction {
     Submit { text: String },
 }
 
-#[derive(Clone, Copy, Debug, PartialEq)]
-enum SubmitMode {
-    Submit,
-    Queue,
-}
-
 pub(crate) struct ChatComposer {
     textarea: TextArea,
     textarea_state: RefCell<TextAreaState>,
@@ -295,12 +287,10 @@ impl ChatComposer {
         // normalize_pasted_path already handles Windows → WSL path conversion,
         // so we can directly try to read the image dimensions.
         match image::image_dimensions(&path_buf) {
-            Ok((width, height)) => {
+            Ok((w, h)) => {
                 tracing::info!("OK: {pasted}");
-                tracing::debug!("image dimensions={}x{}", width, height);
-                let format = pasted_image_format(&path_buf);
-                tracing::debug!("attached image format={}", format.label());
-                self.attach_image(path_buf);
+                let format_label = pasted_image_format(&path_buf).label();
+                self.attach_image(path_buf, w, h, format_label);
                 true
             }
             Err(err) => {
@@ -352,9 +342,12 @@ impl ChatComposer {
     }
 
     /// Attempt to start a burst by retro-capturing recent chars before the cursor.
-    pub fn attach_image(&mut self, path: PathBuf) {
-        let image_number = self.attached_images.len() + 1;
-        let placeholder = local_image_label_text(image_number);
+    pub fn attach_image(&mut self, path: PathBuf, width: u32, height: u32, _format_label: &str) {
+        let file_label = path
+            .file_name()
+            .map(|name| name.to_string_lossy().into_owned())
+            .unwrap_or_else(|| "image".to_string());
+        let placeholder = format!("[{file_label} {width}x{height}]");
         // Insert as an element to match large paste placeholder behavior:
         // styled distinctly and treated atomically for cursor/mutations.
         self.textarea.insert_element(&placeholder);
@@ -742,43 +735,47 @@ impl ChatComposer {
                 if is_image {
                     // Determine dimensions; if that fails fall back to normal path insertion.
                     let path_buf = PathBuf::from(&sel_path);
-                    match image::image_dimensions(&path_buf) {
-                        Ok((width, height)) => {
-                            tracing::debug!("selected image dimensions={}x{}", width, height);
-                            // Remove the current @token (mirror logic from insert_selected_path without inserting text)
-                            // using the flat text and byte-offset cursor API.
-                            let cursor_offset = self.textarea.cursor();
-                            let text = self.textarea.text();
-                            // Clamp to a valid char boundary to avoid panics when slicing.
-                            let safe_cursor = Self::clamp_to_char_boundary(text, cursor_offset);
-                            let before_cursor = &text[..safe_cursor];
-                            let after_cursor = &text[safe_cursor..];
+                    if let Ok((w, h)) = image::image_dimensions(&path_buf) {
+                        // Remove the current @token (mirror logic from insert_selected_path without inserting text)
+                        // using the flat text and byte-offset cursor API.
+                        let cursor_offset = self.textarea.cursor();
+                        let text = self.textarea.text();
+                        // Clamp to a valid char boundary to avoid panics when slicing.
+                        let safe_cursor = Self::clamp_to_char_boundary(text, cursor_offset);
+                        let before_cursor = &text[..safe_cursor];
+                        let after_cursor = &text[safe_cursor..];
 
-                            // Determine token boundaries in the full text.
-                            let start_idx = before_cursor
-                                .char_indices()
-                                .rfind(|(_, c)| c.is_whitespace())
-                                .map(|(idx, c)| idx + c.len_utf8())
-                                .unwrap_or(0);
-                            let end_rel_idx = after_cursor
-                                .char_indices()
-                                .find(|(_, c)| c.is_whitespace())
-                                .map(|(idx, _)| idx)
-                                .unwrap_or(after_cursor.len());
-                            let end_idx = safe_cursor + end_rel_idx;
+                        // Determine token boundaries in the full text.
+                        let start_idx = before_cursor
+                            .char_indices()
+                            .rfind(|(_, c)| c.is_whitespace())
+                            .map(|(idx, c)| idx + c.len_utf8())
+                            .unwrap_or(0);
+                        let end_rel_idx = after_cursor
+                            .char_indices()
+                            .find(|(_, c)| c.is_whitespace())
+                            .map(|(idx, _)| idx)
+                            .unwrap_or(after_cursor.len());
+                        let end_idx = safe_cursor + end_rel_idx;
 
-                            self.textarea.replace_range(start_idx..end_idx, "");
-                            self.textarea.set_cursor(start_idx);
+                        self.textarea.replace_range(start_idx..end_idx, "");
+                        self.textarea.set_cursor(start_idx);
 
-                            self.attach_image(path_buf);
-                            // Add a trailing space to keep typing fluid.
-                            self.textarea.insert_str(" ");
-                        }
-                        Err(err) => {
-                            tracing::trace!("image dimensions lookup failed: {err}");
-                            // Fallback to plain path insertion if metadata read fails.
-                            self.insert_selected_path(&sel_path);
-                        }
+                        let format_label = match Path::new(&sel_path)
+                            .extension()
+                            .and_then(|e| e.to_str())
+                            .map(str::to_ascii_lowercase)
+                        {
+                            Some(ext) if ext == "png" => "PNG",
+                            Some(ext) if ext == "jpg" || ext == "jpeg" => "JPEG",
+                            _ => "IMG",
+                        };
+                        self.attach_image(path_buf, w, h, format_label);
+                        // Add a trailing space to keep typing fluid.
+                        self.textarea.insert_str(" ");
+                    } else {
+                        // Fallback to plain path insertion if metadata read fails.
+                        self.insert_selected_path(&sel_path);
                     }
                 } else {
                     // Non-image: inserting file path.
@@ -1139,169 +1136,159 @@ impl ChatComposer {
                 }
                 self.handle_input_basic(key_event)
             }
-            KeyEvent {
-                code: KeyCode::Char('k'),
-                modifiers: KeyModifiers::CONTROL,
-                kind: KeyEventKind::Press,
-                ..
-            } => self.handle_submit(SubmitMode::Queue),
             KeyEvent {
                 code: KeyCode::Enter,
                 modifiers: KeyModifiers::NONE,
                 ..
-            } => self.handle_submit(SubmitMode::Submit),
-            input => self.handle_input_basic(input),
-        }
-    }
-
-    fn handle_submit(&mut self, mode: SubmitMode) -> (InputResult, bool) {
-        // If the first line is a bare built-in slash command (no args),
-        // dispatch it even when the slash popup isn't visible. This preserves
-        // the workflow: type a prefix ("/di"), press Tab to complete to
-        // "/diff ", then press Enter to run it. Tab moves the cursor beyond
-        // the '/name' token and our caret-based heuristic hides the popup,
-        // but Enter should still dispatch the command rather than submit
-        // literal text.
-        let first_line = self.textarea.text().lines().next().unwrap_or("");
-        if let Some((name, rest)) = parse_slash_name(first_line)
-            && rest.is_empty()
-            && let Some((_n, cmd)) = built_in_slash_commands()
-                .into_iter()
-                .filter(|(_, cmd)| {
-                    windows_degraded_sandbox_active() || *cmd != SlashCommand::ElevateSandbox
-                })
-                .find(|(n, _)| *n == name)
-        {
-            self.textarea.set_text("");
-            return (InputResult::Command(cmd), true);
-        }
-        // If we're in a paste-like burst capture, treat Enter as part of the burst
-        // and accumulate it rather than submitting or inserting immediately.
-        // Do not treat Enter as paste inside a slash-command context.
-        let in_slash_context = matches!(self.active_popup, ActivePopup::Command(_))
-            || self
-                .textarea
-                .text()
-                .lines()
-                .next()
-                .unwrap_or("")
-                .starts_with('/');
-        if self.paste_burst.is_active() && !in_slash_context {
-            let now = Instant::now();
-            if self.paste_burst.append_newline_if_active(now) {
-                return (InputResult::None, true);
-            }
-        }
-        // If we have pending placeholder pastes, replace them in the textarea text
-        // and continue to the normal submission flow to handle slash commands.
-        if !self.pending_pastes.is_empty() {
-            let mut text = self.textarea.text().to_string();
-            for (placeholder, actual) in &self.pending_pastes {
-                if text.contains(placeholder) {
-                    text = text.replace(placeholder, actual);
+            } => {
+                // If the first line is a bare built-in slash command (no args),
+                // dispatch it even when the slash popup isn't visible. This preserves
+                // the workflow: type a prefix ("/di"), press Tab to complete to
+                // "/diff ", then press Enter to run it. Tab moves the cursor beyond
+                // the '/name' token and our caret-based heuristic hides the popup,
+                // but Enter should still dispatch the command rather than submit
+                // literal text.
+                let first_line = self.textarea.text().lines().next().unwrap_or("");
+                if let Some((name, rest)) = parse_slash_name(first_line)
+                    && rest.is_empty()
+                    && let Some((_n, cmd)) = built_in_slash_commands()
+                        .into_iter()
+                        .filter(|(_, cmd)| {
+                            windows_degraded_sandbox_active()
+                                || *cmd != SlashCommand::ElevateSandbox
+                        })
+                        .find(|(n, _)| *n == name)
+                {
+                    self.textarea.set_text("");
+                    return (InputResult::Command(cmd), true);
+                }
+                // If we're in a paste-like burst capture, treat Enter as part of the burst
+                // and accumulate it rather than submitting or inserting immediately.
+                // Do not treat Enter as paste inside a slash-command context.
+                let in_slash_context = matches!(self.active_popup, ActivePopup::Command(_))
+                    || self
+                        .textarea
+                        .text()
+                        .lines()
+                        .next()
+                        .unwrap_or("")
+                        .starts_with('/');
+                if self.paste_burst.is_active() && !in_slash_context {
+                    let now = Instant::now();
+                    if self.paste_burst.append_newline_if_active(now) {
+                        return (InputResult::None, true);
+                    }
+                }
+                // If we have pending placeholder pastes, replace them in the textarea text
+                // and continue to the normal submission flow to handle slash commands.
+                if !self.pending_pastes.is_empty() {
+                    let mut text = self.textarea.text().to_string();
+                    for (placeholder, actual) in &self.pending_pastes {
+                        if text.contains(placeholder) {
+                            text = text.replace(placeholder, actual);
+                        }
+                    }
+                    self.textarea.set_text(&text);
+                    self.pending_pastes.clear();
                 }
-            }
-            self.textarea.set_text(&text);
-            self.pending_pastes.clear();
-        }
 
-        // During a paste-like burst, treat Enter as a newline instead of submit.
-        let now = Instant::now();
-        if self
-            .paste_burst
-            .newline_should_insert_instead_of_submit(now)
-            && !in_slash_context
-        {
-            self.textarea.insert_str("\n");
-            self.paste_burst.extend_window(now);
-            return (InputResult::None, true);
-        }
-        let mut text = self.textarea.text().to_string();
-        let original_input = text.clone();
-        let input_starts_with_space = original_input.starts_with(' ');
-        self.textarea.set_text("");
-
-        // Replace all pending pastes in the text
-        for (placeholder, actual) in &self.pending_pastes {
-            if text.contains(placeholder) {
-                text = text.replace(placeholder, actual);
-            }
-        }
-        self.pending_pastes.clear();
-
-        // If there is neither text nor attachments, suppress submission entirely.
-        let has_attachments = !self.attached_images.is_empty();
-        text = text.trim().to_string();
-        if let Some((name, _rest)) = parse_slash_name(&text) {
-            let treat_as_plain_text = input_starts_with_space || name.contains('/');
-            if !treat_as_plain_text {
-                let is_builtin = built_in_slash_commands()
-                    .into_iter()
-                    .filter(|(_, cmd)| {
-                        windows_degraded_sandbox_active() || *cmd != SlashCommand::ElevateSandbox
-                    })
-                    .any(|(command_name, _)| command_name == name);
-                let prompt_prefix = format!("{PROMPTS_CMD_PREFIX}:");
-                let is_known_prompt = name
-                    .strip_prefix(&prompt_prefix)
-                    .map(|prompt_name| {
-                        self.custom_prompts
-                            .iter()
-                            .any(|prompt| prompt.name == prompt_name)
-                    })
-                    .unwrap_or(false);
-                if !is_builtin && !is_known_prompt {
-                    let message = format!(
-                        r#"Unrecognized command '/{name}'. Type "/" for a list of supported commands."#
-                    );
-                    self.app_event_tx.send(AppEvent::InsertHistoryCell(Box::new(
-                        history_cell::new_info_event(message, None),
-                    )));
-                    self.textarea.set_text(&original_input);
-                    self.textarea.set_cursor(original_input.len());
+                // During a paste-like burst, treat Enter as a newline instead of submit.
+                let now = Instant::now();
+                if self
+                    .paste_burst
+                    .newline_should_insert_instead_of_submit(now)
+                    && !in_slash_context
+                {
+                    self.textarea.insert_str("\n");
+                    self.paste_burst.extend_window(now);
                     return (InputResult::None, true);
                 }
-            }
-        }
+                let mut text = self.textarea.text().to_string();
+                let original_input = text.clone();
+                let input_starts_with_space = original_input.starts_with(' ');
+                self.textarea.set_text("");
 
-        if !input_starts_with_space
-            && let Some((name, rest)) = parse_slash_name(&text)
-            && !rest.is_empty()
-            && !name.contains('/')
-            && let Some((_n, cmd)) = built_in_slash_commands()
-                .into_iter()
-                .find(|(command_name, _)| *command_name == name)
-            && cmd == SlashCommand::Review
-        {
-            return (InputResult::CommandWithArgs(cmd, rest.to_string()), true);
-        }
+                // Replace all pending pastes in the text
+                for (placeholder, actual) in &self.pending_pastes {
+                    if text.contains(placeholder) {
+                        text = text.replace(placeholder, actual);
+                    }
+                }
+                self.pending_pastes.clear();
 
-        let expanded_prompt = match expand_custom_prompt(&text, &self.custom_prompts) {
-            Ok(expanded) => expanded,
-            Err(err) => {
-                self.app_event_tx.send(AppEvent::InsertHistoryCell(Box::new(
-                    history_cell::new_error_event(err.user_message()),
-                )));
-                self.textarea.set_text(&original_input);
-                self.textarea.set_cursor(original_input.len());
-                return (InputResult::None, true);
+                // If there is neither text nor attachments, suppress submission entirely.
+                let has_attachments = !self.attached_images.is_empty();
+                text = text.trim().to_string();
+                if let Some((name, _rest)) = parse_slash_name(&text) {
+                    let treat_as_plain_text = input_starts_with_space || name.contains('/');
+                    if !treat_as_plain_text {
+                        let is_builtin = built_in_slash_commands()
+                            .into_iter()
+                            .filter(|(_, cmd)| {
+                                windows_degraded_sandbox_active()
+                                    || *cmd != SlashCommand::ElevateSandbox
+                            })
+                            .any(|(command_name, _)| command_name == name);
+                        let prompt_prefix = format!("{PROMPTS_CMD_PREFIX}:");
+                        let is_known_prompt = name
+                            .strip_prefix(&prompt_prefix)
+                            .map(|prompt_name| {
+                                self.custom_prompts
+                                    .iter()
+                                    .any(|prompt| prompt.name == prompt_name)
+                            })
+                            .unwrap_or(false);
+                        if !is_builtin && !is_known_prompt {
+                            let message = format!(
+                                r#"Unrecognized command '/{name}'. Type "/" for a list of supported commands."#
+                            );
+                            self.app_event_tx.send(AppEvent::InsertHistoryCell(Box::new(
+                                history_cell::new_info_event(message, None),
+                            )));
+                            self.textarea.set_text(&original_input);
+                            self.textarea.set_cursor(original_input.len());
+                            return (InputResult::None, true);
+                        }
+                    }
+                }
+
+                if !input_starts_with_space
+                    && let Some((name, rest)) = parse_slash_name(&text)
+                    && !rest.is_empty()
+                    && !name.contains('/')
+                    && let Some((_n, cmd)) = built_in_slash_commands()
+                        .into_iter()
+                        .find(|(command_name, _)| *command_name == name)
+                    && cmd == SlashCommand::Review
+                {
+                    return (InputResult::CommandWithArgs(cmd, rest.to_string()), true);
+                }
+
+                let expanded_prompt = match expand_custom_prompt(&text, &self.custom_prompts) {
+                    Ok(expanded) => expanded,
+                    Err(err) => {
+                        self.app_event_tx.send(AppEvent::InsertHistoryCell(Box::new(
+                            history_cell::new_error_event(err.user_message()),
+                        )));
+                        self.textarea.set_text(&original_input);
+                        self.textarea.set_cursor(original_input.len());
+                        return (InputResult::None, true);
+                    }
+                };
+                if let Some(expanded) = expanded_prompt {
+                    text = expanded;
+                }
+                if text.is_empty() && !has_attachments {
+                    return (InputResult::None, true);
+                }
+                if !text.is_empty() {
+                    self.history.record_local_submission(&text);
+                }
+                // Do not clear attached_images here; ChatWidget drains them via take_recent_submission_images().
+                (InputResult::Submitted(text), true)
             }
-        };
-        if let Some(expanded) = expanded_prompt {
-            text = expanded;
+            input => self.handle_input_basic(input),
         }
-        if text.is_empty() && !has_attachments {
-            return (InputResult::None, true);
-        }
-        if !text.is_empty() {
-            self.history.record_local_submission(&text);
-        }
-        // Do not clear attached_images here; ChatWidget drains them via take_recent_submission_images().
-        let result = match mode {
-            SubmitMode::Submit => InputResult::Submitted(text),
-            SubmitMode::Queue => InputResult::Queued(text),
-        };
-        (result, true)
     }
 
     fn handle_paste_burst_flush(&mut self, now: Instant) -> bool {
@@ -1394,28 +1381,20 @@ impl ChatComposer {
             }
         }
 
-        // Backspace at the start of an image placeholder should delete that placeholder (rather
-        // than deleting content before it). Do this without scanning the full text by consulting
-        // the textarea's element list.
-        if matches!(input.code, KeyCode::Backspace)
-            && self.try_remove_image_element_at_cursor_start()
+        // For non-char inputs (or after flushing), handle normally.
+        // Special handling for backspace on placeholders
+        if let KeyEvent {
+            code: KeyCode::Backspace,
+            ..
+        } = input
+            && self.try_remove_any_placeholder_at_cursor()
         {
             return (InputResult::None, true);
         }
 
-        // Track element removals so we can drop any corresponding placeholders without scanning
-        // the full text. (Placeholders are atomic elements; when deleted, the element disappears.)
-        let elements_before = if self.pending_pastes.is_empty() && self.attached_images.is_empty() {
-            None
-        } else {
-            Some(self.textarea.element_payloads())
-        };
-
+        // Normal input handling
         self.textarea.input(input);
-
-        if let Some(elements_before) = elements_before {
-            self.reconcile_deleted_elements(elements_before);
-        }
+        let text_after = self.textarea.text();
 
         // Update paste-burst heuristic for plain Char (no Ctrl/Alt) events.
         let crossterm::event::KeyEvent {
@@ -1437,69 +1416,176 @@ impl ChatComposer {
             }
         }
 
+        // Check if any placeholders were removed and remove their corresponding pending pastes
+        self.pending_pastes
+            .retain(|(placeholder, _)| text_after.contains(placeholder));
+
+        // Keep attached images in proportion to how many matching placeholders exist in the text.
+        // This handles duplicate placeholders that share the same visible label.
+        if !self.attached_images.is_empty() {
+            let mut needed: HashMap<String, usize> = HashMap::new();
+            for img in &self.attached_images {
+                needed
+                    .entry(img.placeholder.clone())
+                    .or_insert_with(|| text_after.matches(&img.placeholder).count());
+            }
+
+            let mut used: HashMap<String, usize> = HashMap::new();
+            let mut kept: Vec<AttachedImage> = Vec::with_capacity(self.attached_images.len());
+            for img in self.attached_images.drain(..) {
+                let total_needed = *needed.get(&img.placeholder).unwrap_or(&0);
+                let used_count = used.entry(img.placeholder.clone()).or_insert(0);
+                if *used_count < total_needed {
+                    kept.push(img);
+                    *used_count += 1;
+                }
+            }
+            self.attached_images = kept;
+        }
+
         (InputResult::None, true)
     }
 
-    fn try_remove_image_element_at_cursor_start(&mut self) -> bool {
-        if self.attached_images.is_empty() {
-            return false;
-        }
+    /// Attempts to remove an image or paste placeholder if the cursor is at the end of one.
+    /// Returns true if a placeholder was removed.
+    fn try_remove_any_placeholder_at_cursor(&mut self) -> bool {
+        // Clamp the cursor to a valid char boundary to avoid panics when slicing.
+        let text = self.textarea.text();
+        let p = Self::clamp_to_char_boundary(text, self.textarea.cursor());
 
-        let p = self.textarea.cursor();
-        let Some(payload) = self.textarea.element_payload_starting_at(p) else {
-            return false;
-        };
-        let Some(idx) = self
-            .attached_images
-            .iter()
-            .position(|img| img.placeholder == payload)
-        else {
-            return false;
-        };
-
-        self.textarea.replace_range(p..p + payload.len(), "");
-        self.attached_images.remove(idx);
-        self.relabel_attached_images_and_update_placeholders();
-        true
-    }
-
-    fn reconcile_deleted_elements(&mut self, elements_before: Vec<String>) {
-        let elements_after: HashSet<String> =
-            self.textarea.element_payloads().into_iter().collect();
-
-        let mut removed_any_image = false;
-        for removed in elements_before
-            .into_iter()
-            .filter(|payload| !elements_after.contains(payload))
-        {
-            self.pending_pastes.retain(|(ph, _)| ph != &removed);
-
-            if let Some(idx) = self
-                .attached_images
-                .iter()
-                .position(|img| img.placeholder == removed)
-            {
-                self.attached_images.remove(idx);
-                removed_any_image = true;
+        // Try image placeholders first
+        let mut out: Option<(usize, String)> = None;
+        // Detect if the cursor is at the end of any image placeholder.
+        // If duplicates exist, remove the specific occurrence's mapping.
+        for (i, img) in self.attached_images.iter().enumerate() {
+            let ph = &img.placeholder;
+            if p < ph.len() {
+                continue;
             }
-        }
-
-        if removed_any_image {
-            self.relabel_attached_images_and_update_placeholders();
-        }
-    }
-
-    fn relabel_attached_images_and_update_placeholders(&mut self) {
-        for idx in 0..self.attached_images.len() {
-            let expected = local_image_label_text(idx + 1);
-            let current = self.attached_images[idx].placeholder.clone();
-            if current == expected {
+            let start = p - ph.len();
+            if text.get(start..p) != Some(ph.as_str()) {
                 continue;
             }
 
-            self.attached_images[idx].placeholder = expected.clone();
-            let _renamed = self.textarea.replace_element_payload(&current, &expected);
+            // Count the number of occurrences of `ph` before `start`.
+            let mut occ_before = 0usize;
+            let mut search_pos = 0usize;
+            while search_pos < start {
+                let segment = match text.get(search_pos..start) {
+                    Some(s) => s,
+                    None => break,
+                };
+                if let Some(found) = segment.find(ph) {
+                    occ_before += 1;
+                    search_pos += found + ph.len();
+                } else {
+                    break;
+                }
+            }
+
+            // Remove the occ_before-th attached image that shares this placeholder label.
+            out = if let Some((remove_idx, _)) = self
+                .attached_images
+                .iter()
+                .enumerate()
+                .filter(|(_, img2)| img2.placeholder == *ph)
+                .nth(occ_before)
+            {
+                Some((remove_idx, ph.clone()))
+            } else {
+                Some((i, ph.clone()))
+            };
+            break;
         }
+        if let Some((idx, placeholder)) = out {
+            self.textarea.replace_range(p - placeholder.len()..p, "");
+            self.attached_images.remove(idx);
+            return true;
+        }
+
+        // Also handle when the cursor is at the START of an image placeholder.
+        // let result = 'out: {
+        let out: Option<(usize, String)> = 'out: {
+            for (i, img) in self.attached_images.iter().enumerate() {
+                let ph = &img.placeholder;
+                if p + ph.len() > text.len() {
+                    continue;
+                }
+                if text.get(p..p + ph.len()) != Some(ph.as_str()) {
+                    continue;
+                }
+
+                // Count occurrences of `ph` before `p`.
+                let mut occ_before = 0usize;
+                let mut search_pos = 0usize;
+                while search_pos < p {
+                    let segment = match text.get(search_pos..p) {
+                        Some(s) => s,
+                        None => break 'out None,
+                    };
+                    if let Some(found) = segment.find(ph) {
+                        occ_before += 1;
+                        search_pos += found + ph.len();
+                    } else {
+                        break 'out None;
+                    }
+                }
+
+                if let Some((remove_idx, _)) = self
+                    .attached_images
+                    .iter()
+                    .enumerate()
+                    .filter(|(_, img2)| img2.placeholder == *ph)
+                    .nth(occ_before)
+                {
+                    break 'out Some((remove_idx, ph.clone()));
+                } else {
+                    break 'out Some((i, ph.clone()));
+                }
+            }
+            None
+        };
+
+        if let Some((idx, placeholder)) = out {
+            self.textarea.replace_range(p..p + placeholder.len(), "");
+            self.attached_images.remove(idx);
+            return true;
+        }
+
+        // Then try pasted-content placeholders
+        if let Some(placeholder) = self.pending_pastes.iter().find_map(|(ph, _)| {
+            if p < ph.len() {
+                return None;
+            }
+            let start = p - ph.len();
+            if text.get(start..p) == Some(ph.as_str()) {
+                Some(ph.clone())
+            } else {
+                None
+            }
+        }) {
+            self.textarea.replace_range(p - placeholder.len()..p, "");
+            self.pending_pastes.retain(|(ph, _)| ph != &placeholder);
+            return true;
+        }
+
+        // Also handle when the cursor is at the START of a pasted-content placeholder.
+        if let Some(placeholder) = self.pending_pastes.iter().find_map(|(ph, _)| {
+            if p + ph.len() > text.len() {
+                return None;
+            }
+            if text.get(p..p + ph.len()) == Some(ph.as_str()) {
+                Some(ph.clone())
+            } else {
+                None
+            }
+        }) {
+            self.textarea.replace_range(p..p + placeholder.len(), "");
+            self.pending_pastes.retain(|(ph, _)| ph != &placeholder);
+            return true;
+        }
+
+        false
     }
 
     fn handle_shortcut_overlay_key(&mut self, key_event: &KeyEvent) -> bool {
@@ -3322,12 +3408,12 @@ mod tests {
             false,
         );
         let path = PathBuf::from("/tmp/image1.png");
-        composer.attach_image(path.clone());
+        composer.attach_image(path.clone(), 32, 16, "PNG");
         composer.handle_paste(" hi".into());
         let (result, _) =
             composer.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
         match result {
-            InputResult::Submitted(text) => assert_eq!(text, "[Image #1] hi"),
+            InputResult::Submitted(text) => assert_eq!(text, "[image1.png 32x16] hi"),
             _ => panic!("expected Submitted"),
         }
         let imgs = composer.take_recent_submission_images();
@@ -3346,11 +3432,11 @@ mod tests {
             false,
         );
         let path = PathBuf::from("/tmp/image2.png");
-        composer.attach_image(path.clone());
+        composer.attach_image(path.clone(), 10, 5, "PNG");
         let (result, _) =
             composer.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
         match result {
-            InputResult::Submitted(text) => assert_eq!(text, "[Image #1]"),
+            InputResult::Submitted(text) => assert_eq!(text, "[image2.png 10x5]"),
             _ => panic!("expected Submitted"),
         }
         let imgs = composer.take_recent_submission_images();
@@ -3371,7 +3457,7 @@ mod tests {
             false,
         );
         let path = PathBuf::from("/tmp/image3.png");
-        composer.attach_image(path.clone());
+        composer.attach_image(path.clone(), 20, 10, "PNG");
         let placeholder = composer.attached_images[0].placeholder.clone();
 
         // Case 1: backspace at end
@@ -3382,7 +3468,7 @@ mod tests {
 
         // Re-add and test backspace in middle: should break the placeholder string
         // and drop the image mapping (same as text placeholder behavior).
-        composer.attach_image(path);
+        composer.attach_image(path, 20, 10, "PNG");
         let placeholder2 = composer.attached_images[0].placeholder.clone();
         // Move cursor to roughly middle of placeholder
         if let Some(start_pos) = composer.textarea.text().find(&placeholder2) {
@@ -3414,7 +3500,7 @@ mod tests {
 
         // Insert an image placeholder at the start
         let path = PathBuf::from("/tmp/image_multibyte.png");
-        composer.attach_image(path);
+        composer.attach_image(path, 10, 5, "PNG");
         // Add multibyte text after the placeholder
         composer.textarea.insert_str("日本語");
 
@@ -3423,7 +3509,12 @@ mod tests {
         composer.handle_key_event(KeyEvent::new(KeyCode::Backspace, KeyModifiers::NONE));
 
         assert_eq!(composer.attached_images.len(), 1);
-        assert!(composer.textarea.text().starts_with("[Image #1]"));
+        assert!(
+            composer
+                .textarea
+                .text()
+                .starts_with("[image_multibyte.png 10x5]")
+        );
     }
 
     #[test]
@@ -3441,10 +3532,10 @@ mod tests {
         let path1 = PathBuf::from("/tmp/image_dup1.png");
         let path2 = PathBuf::from("/tmp/image_dup2.png");
 
-        composer.attach_image(path1);
+        composer.attach_image(path1, 10, 5, "PNG");
         // separate placeholders with a space for clarity
         composer.handle_paste(" ".into());
-        composer.attach_image(path2.clone());
+        composer.attach_image(path2.clone(), 10, 5, "PNG");
 
         let placeholder1 = composer.attached_images[0].placeholder.clone();
         let placeholder2 = composer.attached_images[1].placeholder.clone();
@@ -3459,60 +3550,24 @@ mod tests {
         let new_text = composer.textarea.text().to_string();
         assert_eq!(
             0,
-            new_text.matches(&placeholder2).count(),
-            "second placeholder was relabeled"
+            new_text.matches(&placeholder1).count(),
+            "first placeholder removed"
         );
         assert_eq!(
             1,
-            new_text.matches("[Image #1]").count(),
-            "remaining placeholder relabeled to #1"
+            new_text.matches(&placeholder2).count(),
+            "second placeholder remains"
         );
         assert_eq!(
             vec![AttachedImage {
                 path: path2,
-                placeholder: "[Image #1]".to_string()
+                placeholder: "[image_dup2.png 10x5]".to_string()
             }],
             composer.attached_images,
             "one image mapping remains"
         );
     }
 
-    #[test]
-    fn deleting_first_text_element_renumbers_following_text_element() {
-        use crossterm::event::KeyCode;
-        use crossterm::event::KeyEvent;
-        use crossterm::event::KeyModifiers;
-
-        let (tx, _rx) = unbounded_channel::<AppEvent>();
-        let sender = AppEventSender::new(tx);
-        let mut composer = ChatComposer::new(
-            true,
-            sender,
-            false,
-            "Ask Codex to do anything".to_string(),
-            false,
-        );
-
-        let path1 = PathBuf::from("/tmp/image_first.png");
-        let path2 = PathBuf::from("/tmp/image_second.png");
-
-        // Insert two adjacent atomic elements.
-        composer.attach_image(path1);
-        composer.attach_image(path2.clone());
-        assert_eq!(composer.textarea.text(), "[Image #1][Image #2]");
-        assert_eq!(composer.attached_images.len(), 2);
-
-        // Delete the first element using normal textarea editing (Delete at cursor start).
-        composer.textarea.set_cursor(0);
-        composer.handle_key_event(KeyEvent::new(KeyCode::Delete, KeyModifiers::NONE));
-
-        // Remaining image should be renumbered and the textarea element updated.
-        assert_eq!(composer.attached_images.len(), 1);
-        assert_eq!(composer.attached_images[0].path, path2);
-        assert_eq!(composer.attached_images[0].placeholder, "[Image #1]");
-        assert_eq!(composer.textarea.text(), "[Image #1]");
-    }
-
     #[test]
     fn pasting_filepath_attaches_image() {
         let tmp = tempdir().expect("create TempDir");
@@ -3533,7 +3588,12 @@ mod tests {
 
         let needs_redraw = composer.handle_paste(tmp_path.to_string_lossy().to_string());
         assert!(needs_redraw);
-        assert!(composer.textarea.text().starts_with("[Image #1] "));
+        assert!(
+            composer
+                .textarea
+                .text()
+                .starts_with("[codex_tui_test_paste_image.png 3x2] ")
+        );
 
         let imgs = composer.take_recent_submission_images();
         assert_eq!(imgs, vec![tmp_path]);

codex-rs/tui2/src/bottom_pane/footer.rs

@@ -307,7 +307,6 @@ enum ShortcutId {
     Commands,
     ShellCommands,
     InsertNewline,
-    QueueMessage,
     FilePaths,
     PasteImage,
     EditPrevious,
@@ -413,15 +412,6 @@ const SHORTCUTS: &[ShortcutDescriptor] = &[
         prefix: "",
         label: " for newline",
     },
-    ShortcutDescriptor {
-        id: ShortcutId::QueueMessage,
-        bindings: &[ShortcutBinding {
-            key: key_hint::ctrl(KeyCode::Char('k')),
-            condition: DisplayCondition::Always,
-        }],
-        prefix: "",
-        label: " to queue message",
-    },
     ShortcutDescriptor {
         id: ShortcutId::FilePaths,
         bindings: &[ShortcutBinding {

codex-rs/tui2/src/bottom_pane/mod.rs

@@ -529,9 +529,16 @@ impl BottomPane {
         self.request_redraw();
     }
 
-    pub(crate) fn attach_image(&mut self, path: PathBuf) {
+    pub(crate) fn attach_image(
+        &mut self,
+        path: PathBuf,
+        width: u32,
+        height: u32,
+        format_label: &str,
+    ) {
         if self.view_stack.is_empty() {
-            self.composer.attach_image(path);
+            self.composer
+                .attach_image(path, width, height, format_label);
             self.request_redraw();
         }
     }

codex-rs/tui2/src/bottom_pane/textarea.rs

@@ -715,88 +715,6 @@ impl TextArea {
 
     // ===== Text elements support =====
 
-    pub fn element_payloads(&self) -> Vec<String> {
-        self.elements
-            .iter()
-            .filter_map(|e| self.text.get(e.range.clone()).map(str::to_string))
-            .collect()
-    }
-
-    pub fn element_payload_starting_at(&self, pos: usize) -> Option<String> {
-        let pos = pos.min(self.text.len());
-        let elem = self.elements.iter().find(|e| e.range.start == pos)?;
-        self.text.get(elem.range.clone()).map(str::to_string)
-    }
-
-    /// Renames a single text element in-place, keeping it atomic.
-    ///
-    /// This is intended for cases where the element payload is an identifier (e.g. a placeholder)
-    /// that must be updated without converting the element back into normal text.
-    pub fn replace_element_payload(&mut self, old: &str, new: &str) -> bool {
-        let Some(idx) = self
-            .elements
-            .iter()
-            .position(|e| self.text.get(e.range.clone()) == Some(old))
-        else {
-            return false;
-        };
-
-        let range = self.elements[idx].range.clone();
-        let start = range.start;
-        let end = range.end;
-        if start > end || end > self.text.len() {
-            return false;
-        }
-
-        let removed_len = end - start;
-        let inserted_len = new.len();
-        let diff = inserted_len as isize - removed_len as isize;
-
-        self.text.replace_range(range, new);
-        self.wrap_cache.replace(None);
-        self.preferred_col = None;
-
-        // Update the modified element's range.
-        self.elements[idx].range = start..(start + inserted_len);
-
-        // Shift element ranges that occur after the replaced element.
-        if diff != 0 {
-            for (j, e) in self.elements.iter_mut().enumerate() {
-                if j == idx {
-                    continue;
-                }
-                if e.range.end <= start {
-                    continue;
-                }
-                if e.range.start >= end {
-                    e.range.start = ((e.range.start as isize) + diff) as usize;
-                    e.range.end = ((e.range.end as isize) + diff) as usize;
-                    continue;
-                }
-
-                // Elements should not partially overlap each other; degrade gracefully by
-                // snapping anything intersecting the replaced range to the new bounds.
-                e.range.start = start.min(e.range.start);
-                e.range.end = (start + inserted_len).max(e.range.end.saturating_add_signed(diff));
-            }
-        }
-
-        // Update the cursor position to account for the edit.
-        self.cursor_pos = if self.cursor_pos < start {
-            self.cursor_pos
-        } else if self.cursor_pos <= end {
-            start + inserted_len
-        } else {
-            ((self.cursor_pos as isize) + diff) as usize
-        };
-        self.cursor_pos = self.clamp_pos_to_nearest_boundary(self.cursor_pos);
-
-        // Keep element ordering deterministic.
-        self.elements.sort_by_key(|e| e.range.start);
-
-        true
-    }
-
     pub fn insert_element(&mut self, text: &str) {
         let start = self.clamp_pos_for_insertion(self.cursor_pos);
         self.insert_str_at(start, text);

codex-rs/tui2/src/chatwidget.rs

@@ -1452,13 +1452,12 @@ impl ChatWidget {
             {
                 match paste_image_to_temp_png() {
                     Ok((path, info)) => {
-                        tracing::debug!(
-                            "pasted image size={}x{} format={}",
+                        self.attach_image(
+                            path,
                             info.width,
                             info.height,
-                            info.encoded_format.label()
+                            info.encoded_format.label(),
                         );
-                        self.attach_image(path);
                     }
                     Err(err) => {
                         tracing::warn!("failed to paste image: {err}");
@@ -1489,35 +1488,40 @@ impl ChatWidget {
                     self.request_redraw();
                 }
             }
-            _ => match self.bottom_pane.handle_key_event(key_event) {
-                InputResult::Submitted(text) => {
-                    let user_message = UserMessage {
-                        text,
-                        image_paths: self.bottom_pane.take_recent_submission_images(),
-                    };
-                    self.submit_user_message(user_message);
+            _ => {
+                match self.bottom_pane.handle_key_event(key_event) {
+                    InputResult::Submitted(text) => {
+                        // If a task is running, queue the user input to be sent after the turn completes.
+                        let user_message = UserMessage {
+                            text,
+                            image_paths: self.bottom_pane.take_recent_submission_images(),
+                        };
+                        self.queue_user_message(user_message);
+                    }
+                    InputResult::Command(cmd) => {
+                        self.dispatch_command(cmd);
+                    }
+                    InputResult::CommandWithArgs(cmd, args) => {
+                        self.dispatch_command_with_args(cmd, args);
+                    }
+                    InputResult::None => {}
                 }
-                InputResult::Queued(text) => {
-                    let user_message = UserMessage {
-                        text,
-                        image_paths: self.bottom_pane.take_recent_submission_images(),
-                    };
-                    self.queue_user_message(user_message);
-                }
-                InputResult::Command(cmd) => {
-                    self.dispatch_command(cmd);
-                }
-                InputResult::CommandWithArgs(cmd, args) => {
-                    self.dispatch_command_with_args(cmd, args);
-                }
-                InputResult::None => {}
-            },
+            }
         }
     }
 
-    pub(crate) fn attach_image(&mut self, path: PathBuf) {
-        tracing::info!("attach_image path={path:?}");
-        self.bottom_pane.attach_image(path);
+    pub(crate) fn attach_image(
+        &mut self,
+        path: PathBuf,
+        width: u32,
+        height: u32,
+        format_label: &str,
+    ) {
+        tracing::info!(
+            "attach_image path={path:?} width={width} height={height} format={format_label}",
+        );
+        self.bottom_pane
+            .attach_image(path, width, height, format_label);
         self.request_redraw();
     }
 
@@ -1814,14 +1818,14 @@ impl ChatWidget {
             return;
         }
 
-        for path in image_paths {
-            items.push(UserInput::LocalImage { path });
-        }
-
         if !text.is_empty() {
             items.push(UserInput::Text { text: text.clone() });
         }
 
+        for path in image_paths {
+            items.push(UserInput::LocalImage { path });
+        }
+
         if let Some(skills) = self.bottom_pane.skills() {
             let skill_mentions = find_skill_mentions(&text, skills);
             for skill in skill_mentions {

codex-rs/tui2/src/chatwidget/tests.rs

@@ -1008,7 +1008,7 @@ async fn enqueueing_history_prompt_multiple_times_is_stable() {
         assert_eq!(chat.bottom_pane.composer_text(), "repeat me");
 
         // Queue the prompt while the task is running.
-        chat.handle_key_event(KeyEvent::new(KeyCode::Char('k'), KeyModifiers::CONTROL));
+        chat.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
     }
 
     assert_eq!(chat.queued_user_messages.len(), 3);
@@ -1030,7 +1030,7 @@ async fn streaming_final_answer_keeps_task_running_state() {
 
     chat.bottom_pane
         .set_composer_text("queued submission".to_string());
-    chat.handle_key_event(KeyEvent::new(KeyCode::Char('k'), KeyModifiers::CONTROL));
+    chat.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
 
     assert_eq!(chat.queued_user_messages.len(), 1);
     assert_eq!(
@@ -1065,8 +1065,8 @@ async fn ctrl_c_cleared_prompt_is_recoverable_via_history() {
 
     chat.bottom_pane.insert_str("draft message ");
     chat.bottom_pane
-        .attach_image(PathBuf::from("/tmp/preview.png"));
-    let placeholder = "[Image #1]";
+        .attach_image(PathBuf::from("/tmp/preview.png"), 24, 42, "png");
+    let placeholder = "[preview.png 24x42]";
     assert!(
         chat.bottom_pane.composer_text().ends_with(placeholder),
         "expected placeholder {placeholder:?} in composer text"

codex-rs/tui2/src/public_widgets/composer_input.rs

@@ -54,9 +54,7 @@ impl ComposerInput {
     /// Feed a key event into the composer and return a high-level action.
     pub fn input(&mut self, key: KeyEvent) -> ComposerAction {
         let action = match self.inner.handle_key_event(key).0 {
-            InputResult::Submitted(text) | InputResult::Queued(text) => {
-                ComposerAction::Submitted(text)
-            }
+            InputResult::Submitted(text) => ComposerAction::Submitted(text),
             _ => ComposerAction::None,
         };
         self.drain_app_events();

codex-rs/tui2/src/status/card.rs

@@ -17,7 +17,6 @@ use ratatui::prelude::*;
 use ratatui::style::Stylize;
 use std::collections::BTreeSet;
 use std::path::PathBuf;
-use url::Url;
 
 use super::account::StatusAccountDisplay;
 use super::format::FieldFormatter;
@@ -63,7 +62,6 @@ struct StatusHistoryCell {
     approval: String,
     sandbox: String,
     agents_summary: String,
-    model_provider: Option<String>,
     account: Option<StatusAccountDisplay>,
     session_id: Option<String>,
     token_usage: StatusTokenUsageData,
@@ -131,7 +129,6 @@ impl StatusHistoryCell {
             }
         };
         let agents_summary = compose_agents_summary(config);
-        let model_provider = format_model_provider(config);
         let account = compose_account_display(auth_manager, plan_type);
         let session_id = session_id.as_ref().map(std::string::ToString::to_string);
         let default_usage = TokenUsage::default();
@@ -160,7 +157,6 @@ impl StatusHistoryCell {
             approval,
             sandbox,
             agents_summary,
-            model_provider,
             account,
             session_id,
             token_usage,
@@ -342,9 +338,6 @@ impl HistoryCell for StatusHistoryCell {
                 .collect();
         let mut seen: BTreeSet<String> = labels.iter().cloned().collect();
 
-        if self.model_provider.is_some() {
-            push_label(&mut labels, &mut seen, "Model provider");
-        }
         if account_value.is_some() {
             push_label(&mut labels, &mut seen, "Account");
         }
@@ -387,9 +380,6 @@ impl HistoryCell for StatusHistoryCell {
         let directory_value = format_directory_display(&self.directory, Some(value_width));
 
         lines.push(formatter.line("Model", model_spans));
-        if let Some(model_provider) = self.model_provider.as_ref() {
-            lines.push(formatter.line("Model provider", vec![Span::from(model_provider.clone())]));
-        }
         lines.push(formatter.line("Directory", vec![Span::from(directory_value)]));
         lines.push(formatter.line("Approval", vec![Span::from(self.approval.clone())]));
         lines.push(formatter.line("Sandbox", vec![Span::from(self.sandbox.clone())]));
@@ -425,39 +415,3 @@ impl HistoryCell for StatusHistoryCell {
         with_border_with_inner_width(truncated_lines, inner_width)
     }
 }
-
-fn format_model_provider(config: &Config) -> Option<String> {
-    let provider = &config.model_provider;
-    let name = provider.name.trim();
-    let provider_name = if name.is_empty() {
-        config.model_provider_id.as_str()
-    } else {
-        name
-    };
-    let base_url = provider.base_url.as_deref().and_then(sanitize_base_url);
-    let is_default_openai = provider.is_openai() && base_url.is_none();
-    if is_default_openai {
-        return None;
-    }
-
-    Some(match base_url {
-        Some(base_url) => format!("{provider_name} - {base_url}"),
-        None => provider_name.to_string(),
-    })
-}
-
-fn sanitize_base_url(raw: &str) -> Option<String> {
-    let trimmed = raw.trim();
-    if trimmed.is_empty() {
-        return None;
-    }
-
-    let Ok(mut url) = Url::parse(trimmed) else {
-        return None;
-    };
-    let _ = url.set_username("");
-    let _ = url.set_password(None);
-    url.set_query(None);
-    url.set_fragment(None);
-    Some(url.to_string().trim_end_matches('/').to_string()).filter(|value| !value.is_empty())
-}

rbe.bzl

@@ -1,42 +0,0 @@
-def _rbe_platform_repo_impl(rctx):
-    arch = rctx.os.arch
-    if arch in ["x86_64", "amd64"]:
-        cpu = "x86_64"
-        exec_arch = "amd64"
-        image_sha = "8c9ff94187ea7c08a31e9a81f5fe8046ea3972a6768983c955c4079fa30567fb"
-    elif arch in ["aarch64", "arm64"]:
-        cpu = "aarch64"
-        exec_arch = "arm64"
-        image_sha = "ad9506086215fccfc66ed8d2be87847324be56790ae6a1964c241c28b77ef141"
-    else:
-        fail("Unsupported host arch for rbe platform: {}".format(arch))
-
-    rctx.file("BUILD.bazel", """\
-platform(
-    name = "rbe_platform",
-    constraint_values = [
-        "@platforms//cpu:{cpu}",
-        "@platforms//os:linux",
-        "@bazel_tools//tools/cpp:clang",
-        "@toolchains_llvm_bootstrapped//constraints/libc:gnu.2.28",
-    ],
-    exec_properties = {{
-        # Ubuntu-based image that includes git, python3, dotslash, and other
-        # tools that various integration tests need.
-        # Verify at https://hub.docker.com/layers/mbolin491/codex-bazel/latest/images/sha256:{image_sha}
-        "container-image": "docker://docker.io/mbolin491/codex-bazel@sha256:{image_sha}",
-        "Arch": "{arch}",
-        "OSFamily": "Linux",
-    }},
-    visibility = ["//visibility:public"],
-)
-""".format(
-    cpu = cpu,
-    arch = exec_arch,
-    image_sha = image_sha
-))
-
-rbe_platform_repository = repository_rule(
-    implementation = _rbe_platform_repo_impl,
-    doc = "Sets up a platform for remote builds with an Arch exec_property matching the host.",
-)