[codex] simplify memory read metrics (#28164)

## Why

Memory read telemetry currently reconstructs the executable shell
command after a tool call finishes. That duplicates shell, login-policy,
and cwd resolution owned by the tool handlers, and can diverge from the
environment-specific command that unified exec actually ran.

## What changed

- Expose the existing restricted shell-script parser directly for raw
script text.
- Parse `shell_command` and `exec_command` input into plain command argv
before classifying memory reads.
- Preserve all-or-nothing safe-command validation for multi-command
scripts.
- Remove cwd resolution, shell selection, and the unnecessary async
boundary from memory read metric emission.

## Testing

- `just test -p codex-shell-command`
- `cargo check -p codex-core`

codex-rs/shell-command/src/bash.rs

@@ -94,6 +94,12 @@ pub fn try_parse_word_only_commands_sequence(tree: &Tree, src: &str) -> Option<V
     Some(commands)
 }
 
+/// Parses a shell script consisting only of plain commands joined by safe operators.
+pub fn parse_shell_script_into_commands(script: &str) -> Option<Vec<Vec<String>>> {
+    let tree = try_parse_shell(script)?;
+    try_parse_word_only_commands_sequence(&tree, script)
+}
+
 pub fn extract_bash_command(command: &[String]) -> Option<(&str, &str)> {
     let [shell, flag, script] = command else {
         return None;
@@ -114,9 +120,7 @@ pub fn extract_bash_command(command: &[String]) -> Option<(&str, &str)> {
 /// joined by safe operators.
 pub fn parse_shell_lc_plain_commands(command: &[String]) -> Option<Vec<Vec<String>>> {
     let (_, script) = extract_bash_command(command)?;
-
-    let tree = try_parse_shell(script)?;
-    try_parse_word_only_commands_sequence(&tree, script)
+    parse_shell_script_into_commands(script)
 }
 
 /// Returns the parsed argv for a single shell command in a here-doc style
@@ -322,8 +326,7 @@ mod tests {
     use pretty_assertions::assert_eq;
 
     fn parse_seq(src: &str) -> Option<Vec<Vec<String>>> {
-        let tree = try_parse_shell(src)?;
-        try_parse_word_only_commands_sequence(&tree, src)
+        parse_shell_script_into_commands(src)
     }
 
     #[test]

codex-rs/shell-command/src/parse_command.rs

@@ -1818,7 +1818,11 @@ fn parse_find_query_and_path(tail: &[String]) -> (Option<String>, Option<String>
 fn parse_shell_lc_commands(original: &[String]) -> Option<Vec<ParsedCommand>> {
     // Only handle bash/zsh here; PowerShell is stripped separately without bash parsing.
     let (_, script) = extract_bash_command(original)?;
+    Some(parse_shell_script(script))
+}
 
+/// Parses command metadata from a Bash-compatible shell script.
+pub fn parse_shell_script(script: &str) -> Vec<ParsedCommand> {
     if let Some(tree) = try_parse_shell(script)
         && let Some(all_commands) = try_parse_word_only_commands_sequence(&tree, script)
         && !all_commands.is_empty()
@@ -1831,9 +1835,9 @@ fn parse_shell_lc_commands(original: &[String]) -> Option<Vec<ParsedCommand>> {
         // Commands arrive in source order; drop formatting helpers while preserving it.
         let filtered_commands = drop_small_formatting_commands(all_commands);
         if filtered_commands.is_empty() {
-            return Some(vec![ParsedCommand::Unknown {
+            return vec![ParsedCommand::Unknown {
                 cmd: script.to_string(),
-            }]);
+            }];
         }
         // Build parsed commands, tracking `cd` segments to compute effective file paths.
         let mut commands: Vec<ParsedCommand> = Vec::new();
@@ -1939,11 +1943,11 @@ fn parse_shell_lc_commands(original: &[String]) -> Option<Vec<ParsedCommand>> {
                 })
                 .collect();
         }
-        return Some(commands);
+        return commands;
     }
-    Some(vec![ParsedCommand::Unknown {
+    vec![ParsedCommand::Unknown {
         cmd: script.to_string(),
-    }])
+    }]
 }
 
 /// Return true if this looks like a small formatting helper in a pipeline.