fix: stabilize upstream pick tests

Keep shell and unified exec hook payloads aligned with the upstream Bash hook contract while preserving the local tool_use_id behavior.

Avoid races in exec-server late-output tests by waiting for actual retained output after process exit.

Co-authored-by: Codex <noreply@openai.com>

Author: ericjuta

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

@@ -206,7 +206,7 @@ impl ToolHandler for ShellHandler {
 
     fn pre_tool_use_payload(&self, invocation: &ToolInvocation) -> Option<PreToolUsePayload> {
         shell_payload_command(&invocation.payload).map(|command| PreToolUsePayload {
-            tool_name: invocation.tool_name.display(),
+            tool_name: "Bash".to_string(),
             command,
             agentmemory_input: None,
             agentmemory_capability: None,
@@ -221,7 +221,7 @@ impl ToolHandler for ShellHandler {
         let tool_response =
             result.post_tool_use_response(&invocation.call_id, &invocation.payload)?;
         Some(PostToolUsePayload {
-            tool_name: invocation.tool_name.display(),
+            tool_name: "Bash".to_string(),
             tool_use_id: invocation.call_id.clone(),
             command: shell_payload_command(&invocation.payload)?,
             tool_response,
@@ -321,7 +321,7 @@ impl ToolHandler for ShellCommandHandler {
 
     fn pre_tool_use_payload(&self, invocation: &ToolInvocation) -> Option<PreToolUsePayload> {
         shell_command_payload_command(&invocation.payload).map(|command| PreToolUsePayload {
-            tool_name: invocation.tool_name.display(),
+            tool_name: "Bash".to_string(),
             command,
             agentmemory_input: None,
             agentmemory_capability: None,
@@ -336,7 +336,7 @@ impl ToolHandler for ShellCommandHandler {
         let tool_response =
             result.post_tool_use_response(&invocation.call_id, &invocation.payload)?;
         Some(PostToolUsePayload {
-            tool_name: invocation.tool_name.display(),
+            tool_name: "Bash".to_string(),
             tool_use_id: invocation.call_id.clone(),
             command: shell_command_payload_command(&invocation.payload)?,
             tool_response,

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

@@ -231,7 +231,7 @@ async fn shell_pre_tool_use_payload_uses_joined_command() {
             payload,
         }),
         Some(crate::tools::registry::PreToolUsePayload {
-            tool_name: "shell".to_string(),
+            tool_name: "Bash".to_string(),
             command: "bash -lc 'printf hi'".to_string(),
             agentmemory_input: None,
             agentmemory_capability: None,
@@ -259,7 +259,7 @@ async fn shell_command_pre_tool_use_payload_uses_raw_command() {
             payload,
         }),
         Some(crate::tools::registry::PreToolUsePayload {
-            tool_name: "shell_command".to_string(),
+            tool_name: "Bash".to_string(),
             command: "printf shell command".to_string(),
             agentmemory_input: None,
             agentmemory_capability: None,
@@ -294,7 +294,7 @@ async fn build_post_tool_use_payload_uses_tool_output_wire_value() {
     assert_eq!(
         handler.post_tool_use_payload(&invocation, &output),
         Some(crate::tools::registry::PostToolUsePayload {
-            tool_name: "shell_command".to_string(),
+            tool_name: "Bash".to_string(),
             tool_use_id: "call-42".to_string(),
             command: "printf shell command".to_string(),
             tool_response: json!("shell output"),

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

@@ -146,7 +146,7 @@ impl ToolHandler for UnifiedExecHandler {
         parse_arguments::<ExecCommandArgs>(arguments)
             .ok()
             .map(|args| PreToolUsePayload {
-                tool_name: invocation.tool_name.display(),
+                tool_name: "Bash".to_string(),
                 command: args.cmd,
                 agentmemory_input: None,
                 agentmemory_capability: None,
@@ -170,7 +170,7 @@ impl ToolHandler for UnifiedExecHandler {
         };
         let tool_response = result.post_tool_use_response(&tool_use_id, &invocation.payload)?;
         Some(PostToolUsePayload {
-            tool_name: invocation.tool_name.display(),
+            tool_name: "Bash".to_string(),
             tool_use_id,
             command,
             tool_response,

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

@@ -216,7 +216,7 @@ async fn exec_command_pre_tool_use_payload_uses_raw_command() {
             payload,
         }),
         Some(crate::tools::registry::PreToolUsePayload {
-            tool_name: "exec_command".to_string(),
+            tool_name: "Bash".to_string(),
             command: "printf exec command".to_string(),
             agentmemory_input: None,
             agentmemory_capability: None,
@@ -275,7 +275,7 @@ async fn exec_command_post_tool_use_payload_uses_output_for_noninteractive_one_s
     assert_eq!(
         UnifiedExecHandler.post_tool_use_payload(&invocation, &output),
         Some(crate::tools::registry::PostToolUsePayload {
-            tool_name: "exec_command".to_string(),
+            tool_name: "Bash".to_string(),
             tool_use_id: "call-43".to_string(),
             command: "echo three".to_string(),
             tool_response: serde_json::json!("three"),
@@ -313,7 +313,7 @@ async fn exec_command_post_tool_use_payload_uses_output_for_interactive_completi
     assert_eq!(
         UnifiedExecHandler.post_tool_use_payload(&invocation, &output),
         Some(crate::tools::registry::PostToolUsePayload {
-            tool_name: "exec_command".to_string(),
+            tool_name: "Bash".to_string(),
             tool_use_id: "call-44".to_string(),
             command: "echo three".to_string(),
             tool_response: serde_json::json!("three"),
@@ -388,7 +388,7 @@ async fn write_stdin_post_tool_use_payload_uses_original_exec_call_id_and_comman
     assert_eq!(
         UnifiedExecHandler.post_tool_use_payload(&invocation, &output),
         Some(crate::tools::registry::PostToolUsePayload {
-            tool_name: "exec_command".to_string(),
+            tool_name: "Bash".to_string(),
             tool_use_id: "exec-call-45".to_string(),
             command: "sleep 1; echo finished".to_string(),
             tool_response: serde_json::json!("finished\n"),
@@ -452,13 +452,13 @@ async fn write_stdin_post_tool_use_payload_keeps_parallel_session_metadata_separ
         payloads,
         [
             Some(crate::tools::registry::PostToolUsePayload {
-                tool_name: "exec_command".to_string(),
+                tool_name: "Bash".to_string(),
                 tool_use_id: "exec-call-b".to_string(),
                 command: "sleep 1; echo beta".to_string(),
                 tool_response: serde_json::json!("beta\n"),
             }),
             Some(crate::tools::registry::PostToolUsePayload {
-                tool_name: "exec_command".to_string(),
+                tool_name: "Bash".to_string(),
                 tool_use_id: "exec-call-a".to_string(),
                 command: "sleep 2; echo alpha".to_string(),
                 tool_response: serde_json::json!("alpha\n"),

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

@@ -180,7 +180,7 @@ fn pre_tool_use_hooks_enabled(payload: &PreToolUsePayload) -> bool {
     payload.agentmemory_capability.is_some()
         || matches!(
             payload.tool_name.as_str(),
-            "shell" | "shell_command" | "local_shell" | "exec_command"
+            "shell" | "shell_command" | "local_shell" | "exec_command" | "Bash"
         )
 }
 
@@ -191,6 +191,7 @@ fn post_tool_use_hooks_enabled(payload: &PostToolUsePayload) -> bool {
             | "shell_command"
             | "local_shell"
             | "exec_command"
+            | "Bash"
             | "Edit"
             | "Write"
             | "Read"

codex-rs/exec-server/src/local_process.rs

@@ -784,7 +784,7 @@ mod tests {
             .expect("send late stdout");
 
         let late_response =
-            read_process_until_change(&backend, &process.process_id, /*after_seq*/ Some(1)).await;
+            read_process_until_chunk(&backend, &process.process_id, /*after_seq*/ Some(1)).await;
         assert_eq!(
             late_response.chunks,
             vec![ProcessOutputChunk {
@@ -952,6 +952,32 @@ mod tests {
         .expect("process read")
     }
 
+    async fn read_process_until_chunk(
+        backend: &LocalProcess,
+        process_id: &ProcessId,
+        after_seq: Option<u64>,
+    ) -> ReadResponse {
+        timeout(Duration::from_secs(1), async {
+            loop {
+                let response = backend
+                    .exec_read(ReadParams {
+                        process_id: process_id.clone(),
+                        after_seq,
+                        max_bytes: None,
+                        wait_ms: Some(50),
+                    })
+                    .await
+                    .expect("process read");
+                if !response.chunks.is_empty() {
+                    break response;
+                }
+                tokio::time::sleep(Duration::from_millis(5)).await;
+            }
+        })
+        .await
+        .expect("process chunk read should finish")
+    }
+
     async fn read_process_until_closed(
         backend: &LocalProcess,
         process_id: &ProcessId,

codex-rs/exec-server/tests/exec_process.rs

@@ -371,25 +371,18 @@ async fn assert_exec_process_retains_output_after_exit_until_streams_close(
         .next_seq
         .checked_sub(1)
         .context("exit response should advance next_seq")?;
+    let mut wake_rx = process.subscribe_wake();
     std::fs::write(&release_path, b"go")?;
 
-    let late_response = timeout(
-        Duration::from_secs(2),
-        process.read(
-            /*after_seq*/ Some(exit_seq),
-            /*max_bytes*/ None,
-            /*wait_ms*/ Some(2_000),
-        ),
-    )
-    .await??;
+    let late_response =
+        read_process_until_change(Arc::clone(&process), &mut wake_rx, Some(exit_seq)).await?;
     let mut late_output = String::new();
     for chunk in late_response.chunks {
         assert_eq!(chunk.stream, ExecOutputStream::Stdout);
         late_output.push_str(&String::from_utf8_lossy(&chunk.chunk.into_inner()));
     }
     assert_eq!(late_output, "late output after exit\n");
 
-    let wake_rx = process.subscribe_wake();
     let actual = collect_process_output_from_reads(process, wake_rx).await?;
     assert_eq!(
         actual,