Lightweight coding agent that runs in your terminal
Rust
Expose originating tool call metadata in command environments (#52119)
Leonardo Di Donato9b738582b13c
diff --git a/codex-rs/core/src/exec_env.rs b/codex-rs/core/src/exec_env.rsindex ca1dcb6a93..a119fa33a2 100644--- a/codex-rs/core/src/exec_env.rs+++ b/codex-rs/core/src/exec_env.rs@@ -10,6 +10,8 @@ use std::collections::HashMap;pub use codex_protocol::shell_environment::CODEX_SESSION_ID_ENV_VAR;pub use codex_protocol::shell_environment::CODEX_THREAD_ID_ENV_VAR;+pub use codex_protocol::shell_environment::CODEX_TOOL_CALL_ID_ENV_VAR;+pub(crate) use codex_protocol::shell_environment::set_tool_call_id_env_var;pub(crate) const CODEX_VERSION_ENV_VAR: &str = "CODEX_VERSION";diff --git a/codex-rs/core/src/shell_snapshot.rs b/codex-rs/core/src/shell_snapshot.rsindex 994506d24c..01bd13688a 100644--- a/codex-rs/core/src/shell_snapshot.rs+++ b/codex-rs/core/src/shell_snapshot.rs@@ -23,6 +23,7 @@ use codex_network_proxy::brokered_credential_value_env_keys;use codex_otel::SessionTelemetry;use codex_protocol::ThreadId;use codex_protocol::config_types::ShellEnvironmentPolicy;+use codex_protocol::shell_environment::CODEX_TOOL_CALL_ID_ENV_VAR;use codex_protocol::shell_environment::create_env_from_vars;use codex_shell_command::shell_snapshot::CapturedSnapshot;use codex_shell_command::shell_snapshot::PreparedSnapshot;@@ -1053,11 +1054,13 @@ async fn run_script_with_timeout(SnapshotShellMode::Validation(path) => Some(path),SnapshotShellMode::Login | SnapshotShellMode::NonLogin => None,};+ let mut env = prepared_env.unwrap_or_else(|| std::env::vars().collect());+ remove_env_value(&mut env, CODEX_TOOL_CALL_ID_ENV_VAR);return sandbox.run(args,cwd,- prepared_env.unwrap_or_else(|| std::env::vars().collect()),+ env,snapshot_timeout,shell_name,snapshot_read_path,@@ -1081,6 +1084,7 @@ async fn run_script_with_timeout(handler.env_clear();handler.envs(env);}+ handler.env_remove(CODEX_TOOL_CALL_ID_ENV_VAR);codex_protocol::shell_environment::scrub_non_inheritable_env_vars(handler.as_std_mut());#[cfg(unix)]let output = {diff --git a/codex-rs/core/src/shell_snapshot_tests.rs b/codex-rs/core/src/shell_snapshot_tests.rsindex d6e754f6ad..44241ae045 100644--- a/codex-rs/core/src/shell_snapshot_tests.rs+++ b/codex-rs/core/src/shell_snapshot_tests.rs@@ -165,6 +165,80 @@ async fn get_snapshot(shell_type: ShellType) -> Result<String> {Ok(content)}+#[cfg(unix)]+#[tokio::test]+async fn snapshot_helpers_preserve_thread_without_caching_exec_metadata() -> Result<()> {+ let output = Command::new(std::env::current_exe()?)+ .arg("--exact")+ .arg("shell_snapshot::tests::snapshot_helper_exec_metadata_child")+ .arg("--nocapture")+ .env("CODEX_TEST_SNAPSHOT_HELPER_CHILD", "1")+ .env("CODEX_THREAD_ID", "helper-thread")+ .env("CODEX_TOOL_CALL_ID", "stale-call")+ .env("BASH_ENV", "/dev/null")+ .output()?;++ assert!(+ output.status.success(),+ "snapshot helper child failed:\nstdout:\n{}\nstderr:\n{}",+ String::from_utf8_lossy(&output.stdout),+ String::from_utf8_lossy(&output.stderr),+ );+ Ok(())+}++#[cfg(unix)]+#[tokio::test]+async fn snapshot_helper_exec_metadata_child() -> Result<()> {+ if std::env::var_os("CODEX_TEST_SNAPSHOT_HELPER_CHILD").is_none() {+ return Ok(());+ }+ assert_eq!(+ std::env::var("CODEX_THREAD_ID").as_deref(),+ Ok("helper-thread")+ );+ assert_eq!(+ std::env::var("CODEX_TOOL_CALL_ID").as_deref(),+ Ok("stale-call")+ );++ let dir = tempdir()?;+ let shell = crate::shell::get_shell(ShellType::Bash).context("No available Bash shell")?;+ let helper_env = run_script_with_timeout(+ &shell,+ "printf '%s|%s' \"${CODEX_THREAD_ID-unset}\" \"${CODEX_TOOL_CALL_ID-unset}\"",+ SNAPSHOT_TIMEOUT,+ SnapshotShellMode::NonLogin,+ &dir.path().abs(),+ /*credential_broker*/ None,+ /*sandbox*/ None,+ )+ .await?;+ assert_eq!(helper_env, "helper-thread|unset");+ let snapshot = get_snapshot(ShellType::Bash).await?;+ assert!(!snapshot.contains("CODEX_THREAD_ID"));+ assert!(!snapshot.contains("CODEX_TOOL_CALL_ID"));+ assert!(!snapshot.contains("helper-thread"));+ assert!(!snapshot.contains("stale-call"));++ let validation_path = dir.path().join("validation.sh").abs();+ fs::write(+ &validation_path,+ "test \"${CODEX_THREAD_ID-missing}\" = helper-thread && \+ test \"${CODEX_TOOL_CALL_ID-missing}\" = missing\n",+ )+ .await?;+ validate_snapshot(+ &shell,+ &validation_path,+ &dir.path().abs(),+ /*credential_broker*/ None,+ /*sandbox*/ None,+ )+ .await?;+ Ok(())+}+#[test]fn snapshot_file_name_parser_supports_legacy_and_suffixed_names() {let session_id = "019cf82b-6a62-7700-bbbd-46909794ef89";diff --git a/codex-rs/core/src/tools/runtimes/mod.rs b/codex-rs/core/src/tools/runtimes/mod.rsindex 7145665cc5..17a427be2f 100644--- a/codex-rs/core/src/tools/runtimes/mod.rs+++ b/codex-rs/core/src/tools/runtimes/mod.rs@@ -7,6 +7,7 @@ small and focused and reuses the orchestrator for approvals + sandbox + retry.use crate::exec_env::CODEX_PERMISSION_PROFILE_ENV_VAR;use crate::exec_env::CODEX_SESSION_ID_ENV_VAR;use crate::exec_env::CODEX_THREAD_ID_ENV_VAR;+use crate::exec_env::CODEX_TOOL_CALL_ID_ENV_VAR;use crate::exec_env::CODEX_VERSION_ENV_VAR;use crate::sandboxing::SandboxPermissions;use crate::shell::Shell;@@ -352,6 +353,7 @@ pub(crate) fn maybe_wrap_shell_lc_with_snapshot(for key in [CODEX_SESSION_ID_ENV_VAR,CODEX_THREAD_ID_ENV_VAR,+ CODEX_TOOL_CALL_ID_ENV_VAR,CODEX_VERSION_ENV_VAR,CODEX_PERMISSION_PROFILE_ENV_VAR,CODEX_APPLY_PATCH_PRESERVE_LINE_ENDINGS_ENV_VAR,@@ -368,6 +370,7 @@ pub(crate) fn maybe_wrap_shell_lc_with_snapshot(CODEX_PERMISSION_PROFILE_ENV_VAR,CODEX_APPLY_PATCH_PRESERVE_LINE_ENDINGS_ENV_VAR,PLUGIN_METRICS_OUTPUT_ENV_VAR,+ CODEX_TOOL_CALL_ID_ENV_VAR,],);let (proxy_captures, proxy_exports) = build_proxy_env_exports(env);diff --git a/codex-rs/core/src/tools/runtimes/mod_tests.rs b/codex-rs/core/src/tools/runtimes/mod_tests.rsindex 3ee918cb58..e1a25d1d82 100644--- a/codex-rs/core/src/tools/runtimes/mod_tests.rs+++ b/codex-rs/core/src/tools/runtimes/mod_tests.rs@@ -552,7 +552,7 @@ fn maybe_wrap_shell_lc_with_snapshot_restores_codex_metadata_from_env() {let snapshot_path = dir.path().join("snapshot.sh");std::fs::write(&snapshot_path,- "# Snapshot file\nexport CODEX_THREAD_ID='parent-thread'\nexport CODEX_VERSION='old-version'\n",+ "# Snapshot file\nexport CODEX_THREAD_ID='parent-thread'\nexport CODEX_TOOL_CALL_ID='parent-call'\nexport CODEX_VERSION='old-version'\n",).expect("write snapshot");let (session_shell, shell_snapshot) =@@ -560,10 +560,12 @@ fn maybe_wrap_shell_lc_with_snapshot_restores_codex_metadata_from_env() {let command = vec!["/bin/bash".to_string(),"-lc".to_string(),- "printf '%s|%s' \"$CODEX_THREAD_ID\" \"$CODEX_VERSION\"".to_string(),+ "printf '%s|%s|%s' \"$CODEX_THREAD_ID\" \"$CODEX_TOOL_CALL_ID\" \"$CODEX_VERSION\""+ .to_string(),];let env = HashMap::from([("CODEX_THREAD_ID".to_string(), "nested-thread".to_string()),+ ("CODEX_TOOL_CALL_ID".to_string(), "nested-call".to_string()),("CODEX_VERSION".to_string(),env!("CARGO_PKG_VERSION").to_string(),@@ -586,7 +588,7 @@ fn maybe_wrap_shell_lc_with_snapshot_restores_codex_metadata_from_env() {assert!(output.status.success(), "command failed: {output:?}");assert_eq!(String::from_utf8_lossy(&output.stdout),- concat!("nested-thread|", env!("CARGO_PKG_VERSION")),+ concat!("nested-thread|nested-call|", env!("CARGO_PKG_VERSION")),);}@@ -628,21 +630,21 @@ fn maybe_wrap_shell_lc_with_snapshot_restores_permission_profile_from_env() {assert_eq!(String::from_utf8_lossy(&output.stdout), "current-profile\n");}-#[test]-fn maybe_wrap_shell_lc_with_snapshot_unsets_absent_permission_profile() {- let dir = tempdir().expect("create temp dir");+#[test_case::test_case(CODEX_PERMISSION_PROFILE_ENV_VAR; "permission profile")]+#[test_case::test_case(CODEX_TOOL_CALL_ID_ENV_VAR; "tool call ID")]+fn maybe_wrap_shell_lc_with_snapshot_unsets_absent_metadata(key: &str) -> anyhow::Result<()> {+ let dir = tempdir()?;let snapshot_path = dir.path().join("snapshot.sh");std::fs::write(&snapshot_path,- "# Snapshot file\nexport CODEX_PERMISSION_PROFILE='stale-profile'\n",- )- .expect("write snapshot");+ format!("# Snapshot file\nexport {key}='stale-value'\n"),+ )?;let (session_shell, shell_snapshot) =shell_with_snapshot(ShellType::Bash, "/bin/bash", snapshot_path.abs());let command = vec!["/bin/bash".to_string(),"-lc".to_string(),- "printenv CODEX_PERMISSION_PROFILE".to_string(),+ format!("printenv {key}"),];let rewritten = maybe_wrap_shell_lc_with_snapshot(&command,@@ -654,12 +656,12 @@ fn maybe_wrap_shell_lc_with_snapshot_unsets_absent_permission_profile() {);let output = Command::new(&rewritten[0]).args(&rewritten[1..])- .env_remove(CODEX_PERMISSION_PROFILE_ENV_VAR)- .output()- .expect("run rewritten command");+ .env_remove(key)+ .output()?;assert_eq!(output.status.code(), Some(1));assert_eq!(output.stdout, b"");+ Ok(())}#[test]diff --git a/codex-rs/core/src/unified_exec/process_manager.rs b/codex-rs/core/src/unified_exec/process_manager.rsindex 4743e34f15..35a94ac959 100644--- a/codex-rs/core/src/unified_exec/process_manager.rs+++ b/codex-rs/core/src/unified_exec/process_manager.rs@@ -22,6 +22,7 @@ use crate::exec_env::create_env;use crate::exec_env::inject_apply_patch_env;use crate::exec_env::inject_permission_profile_env;use crate::exec_env::inject_session_env;+use crate::exec_env::set_tool_call_id_env_var;use crate::exec_policy::ExecApprovalRequest;use crate::guardian::GuardianReviewContext;use crate::plugins::metrics::finish_and_track_measurements;@@ -1445,10 +1446,13 @@ impl UnifiedExecProcessManager {let shell_environment_policy = request.turn_environment.shell_environment_policy();let local_policy_env = create_env(shell_environment_policy, /*thread_id*/ None);let mut env = local_policy_env.clone();+ #[cfg(windows)]+ env.retain(|name, _| !name.eq_ignore_ascii_case(CODEX_THREAD_ID_ENV_VAR));env.insert(CODEX_THREAD_ID_ENV_VAR.to_string(),context.session.thread_id.to_string(),);+ set_tool_call_id_env_var(&mut env, Some(&context.call_id));inject_session_env(&mut env, context.session.session_id());inject_apply_patch_env(&mut env);let active_permission_profile = request.turn_environment.active_permission_profile();diff --git a/codex-rs/core/tests/suite/shell_snapshot.rs b/codex-rs/core/tests/suite/shell_snapshot.rsindex 92e0a4c3d6..5518bad8c0 100644--- a/codex-rs/core/tests/suite/shell_snapshot.rs+++ b/codex-rs/core/tests/suite/shell_snapshot.rs@@ -641,9 +641,10 @@ async fn shell_snapshot_v2_guardian_uses_its_resolved_permissions_and_tools() -> Result<()> {skip_if_remote!(Ok(()), "profile fixture uses a host-local HOME directory");let profile_home = tempfile::tempdir()?;+ // Appending detects any successful reviewer write, even with the wrong thread ID.fs::write(profile_home.path().join(".bashrc"),- "printf capture > \"$HOME/$CODEX_THREAD_ID\"\n",+ "printf '%s\\n' \"$CODEX_THREAD_ID\" >> \"$HOME/captures\"\n",).await?;let builder =@@ -654,6 +655,12 @@ async fn shell_snapshot_v2_guardian_uses_its_resolved_permissions_and_tools(.expect("set parent permissions");config.permissions.approval_policy = Constrained::allow_any(AskForApproval::OnRequest);config.approvals_reviewer = ApprovalsReviewer::AutoReview;+ // Read the fixture's .bashrc instead of an inherited startup hook.+ config+ .permissions+ .shell_environment_policy+ .r#set+ .insert("BASH_ENV".to_string(), String::new());let rules = config.codex_home.join("rules");std::fs::create_dir_all(&rules).expect("create rules directory");std::fs::write(@@ -741,15 +748,10 @@ async fn shell_snapshot_v2_guardian_uses_its_resolved_permissions_and_tools(.expect("Guardian thread ID").to_string();assert_ne!(guardian_id, test.session_configured.thread_id.to_string());- assert!(- profile_home- .path()- .join(test.session_configured.thread_id.to_string())- .exists()- );- assert!(- !profile_home.path().join(guardian_id).exists(),- "Guardian profile must not inherit writable owner permissions"+ assert_eq!(+ fs::read_to_string(profile_home.path().join("captures")).await?,+ format!("{}\n", test.session_configured.thread_id),+ "only the parent may write; Guardian must not inherit writable owner permissions");Ok(())}diff --git a/codex-rs/core/tests/suite/unified_exec.rs b/codex-rs/core/tests/suite/unified_exec.rsindex a6e5161e96..acdb81445f 100644--- a/codex-rs/core/tests/suite/unified_exec.rs+++ b/codex-rs/core/tests/suite/unified_exec.rs@@ -442,6 +442,80 @@ async fn exec_command_does_not_expose_configured_noise_auth_token() -> Result<()Ok(())}+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn exec_command_exports_originating_call_metadata_across_later_input() -> Result<()> {+ skip_if_target_windows!(Ok(()), "uses POSIX shell and TTY fixtures");+ skip_if_no_network!(Ok(()));+ skip_if_sandbox!(Ok(()));++ let harness = TestCodexHarness::with_auto_env_builder(test_codex()).await?;+ let first_call_id = "exec-first-metadata";+ let second_call_id = "exec-second-metadata";+ let input_call_id = "exec-later-input";+ let first_args = json!({+ "cmd": "printf '%s|%s' \"$CODEX_THREAD_ID\" \"$CODEX_TOOL_CALL_ID\" > first-metadata",+ "yield_time_ms": 5_000,+ });+ let second_args = json!({+ "cmd": "printf '%s|%s' \"$CODEX_THREAD_ID\" \"$CODEX_TOOL_CALL_ID\" > second-before; IFS= read -r _; printf '%s|%s' \"$CODEX_THREAD_ID\" \"$CODEX_TOOL_CALL_ID\" > second-after",+ "yield_time_ms": 100,+ "tty": true,+ });+ let input_args = json!({+ "chars": "continue\n",+ "session_id": 1001,+ "yield_time_ms": 5_000,+ });+ let mut responses = Vec::new();+ for (response_id, call_id, tool, args) in [+ ("resp-1", first_call_id, "exec_command", first_args),+ ("resp-2", second_call_id, "exec_command", second_args),+ ("resp-3", input_call_id, "write_stdin", input_args),+ ] {+ responses.push(sse(vec![+ ev_response_created(response_id),+ ev_function_call(call_id, tool, &args.to_string()),+ ev_completed(response_id),+ ]));+ }+ responses.push(sse(vec![+ ev_response_created("resp-4"),+ ev_assistant_message("msg-1", "done"),+ ev_completed("resp-4"),+ ]));+ let _response_mock = mount_sse_sequence(harness.server(), responses).await;++ harness.submit("record execution metadata").await?;++ let outputs = collect_tool_outputs(&harness.request_bodies().await)?;+ let second_output = outputs+ .get(second_call_id)+ .context("missing second exec_command output")?;+ assert_eq!(second_output.process_id.as_deref(), Some("1001"));+ let input_output = outputs+ .get(input_call_id)+ .context("missing write_stdin output")?;+ assert_eq!(input_output.exit_code, Some(0));+ assert!(+ input_output.output.contains("continue"),+ "write_stdin did not echo the later input: {:?}",+ input_output.output+ );++ let thread_id = harness.test().session_configured.thread_id;+ for (file, call_id) in [+ ("first-metadata", first_call_id),+ ("second-before", second_call_id),+ ("second-after", second_call_id),+ ] {+ assert_eq!(+ harness.read_file_text(file).await?,+ format!("{thread_id}|{call_id}"),+ );+ }+ Ok(())+}+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn exec_command_uses_installed_environment_shell_policy_with_explicit_overrides() -> Result<()>{diff --git a/codex-rs/exec-server-protocol/src/protocol.rs b/codex-rs/exec-server-protocol/src/protocol.rsindex 476a63539e..26614350c3 100644--- a/codex-rs/exec-server-protocol/src/protocol.rs+++ b/codex-rs/exec-server-protocol/src/protocol.rs@@ -313,7 +313,7 @@ impl From<DetectedShell> for ShellInfo {}}-/// Optional tool attribution for executor telemetry, not authorization.+/// Optional tool attribution for executor telemetry and child environments, not authorization.#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]#[serde(rename_all = "camelCase")]pub struct ExecMetadata {diff --git a/codex-rs/exec-server/README.md b/codex-rs/exec-server/README.mdindex fc4419a9a2..ee497de689 100644--- a/codex-rs/exec-server/README.md+++ b/codex-rs/exec-server/README.md@@ -14,6 +14,26 @@ This crate owns the transport, protocol, and filesystem/process handlers. Thetop-level `codex` binary owns hidden helper dispatch for sandboxedfilesystem operations and `codex-linux-sandbox`.+## Command metadata++Launches expose `metadata.threadId` as `CODEX_THREAD_ID` and `metadata.toolCallId`+as `CODEX_TOOL_CALL_ID` in the initial child environment. `exec_command` supplies+the originating execution call ID, unchanged by later input. Code-mode uses the+nested execution call ID, not the outer cell ID.++These reserved labels override inherited values, policy settings, overlays, and+cached snapshots. Present metadata clears omitted fields; absent metadata preserves+thread-only context and unsets the call ID. Snapshot capture and validation helpers+keep available thread context but omit the call ID; newly captured snapshots exclude+both ID exports.+Call IDs are copied unchanged, including empty values; NUL-containing IDs are+omitted. Platform process-environment size limits apply.++Labels support correlation, not authorization. Shell startup, commands, and+descendants can change or remove them; consumers must handle missing or unusable+labels. These guarantees require an updated executor: older executors may ignore+metadata or restore stale snapshot values.+## TransportThe server speaks the exec-specific `codex-exec-server-protocol` messagediff --git a/codex-rs/exec-server/src/local_process.rs b/codex-rs/exec-server/src/local_process.rsindex f384d84d88..271f8aaaf0 100644--- a/codex-rs/exec-server/src/local_process.rs+++ b/codex-rs/exec-server/src/local_process.rs@@ -19,6 +19,7 @@ use codex_protocol::config_types::ShellEnvironmentPolicy;use codex_protocol::exec_output::ExecToolCallOutput;use codex_protocol::exec_output::StreamOutput;use codex_protocol::shell_environment;+use codex_protocol::shell_environment::CODEX_THREAD_ID_ENV_VAR;use codex_sandboxing::SandboxType;use codex_sandboxing::is_likely_sandbox_denied;use codex_utils_pty::ExecCommandSession;@@ -751,9 +752,32 @@ fn child_env(params: &ExecParams) -> HashMap<String, String> {};env.remove(crate::CODEX_EXEC_SERVER_EXIT_ON_STDIN_CLOSE_ENV_VAR);env.retain(|name, _| !shell_environment::is_non_inheritable_env_var(name));+ apply_exec_metadata(&mut env, params.metadata.as_ref());env}+pub(crate) fn apply_exec_metadata(+ env: &mut HashMap<String, String>,+ metadata: Option<&crate::protocol::ExecMetadata>,+) {+ if let Some(metadata) = metadata {+ #[cfg(windows)]+ env.retain(|name, _| !name.eq_ignore_ascii_case(CODEX_THREAD_ID_ENV_VAR));+ match metadata.thread_id {+ Some(thread_id) => {+ env.insert(CODEX_THREAD_ID_ENV_VAR.to_string(), thread_id.to_string());+ }+ None => {+ env.remove(CODEX_THREAD_ID_ENV_VAR);+ }+ }+ }+ shell_environment::set_tool_call_id_env_var(+ env,+ metadata.and_then(|metadata| metadata.tool_call_id.as_deref()),+ );+}+pub(crate) fn shell_environment_policy(env_policy: &ExecEnvPolicy) -> ShellEnvironmentPolicy {ShellEnvironmentPolicy {inherit: env_policy.inherit.clone(),@@ -1532,9 +1556,14 @@ mod tests {#[test]fn child_env_applies_policy_then_overlay() {+ let thread_id =+ codex_protocol::ThreadId::from_string("019d25f0-6728-7ce2-908f-c3c187323e5b")+ .expect("thread id");let mut params = test_exec_params(HashMap::from([("OVERLAY".to_string(), "overlay".to_string()),("POLICY_SET".to_string(), "overlay-wins".to_string()),+ ("CODEX_THREAD_ID".into(), "overlay-thread".into()),+ ("CODEX_TOOL_CALL_ID".into(), "overlay-call".into()),("openai_identity_token_file".to_string(),"/run/identity-token".to_string(),@@ -1547,13 +1576,21 @@ mod tests {r#set: HashMap::from([("POLICY_SET".to_string(), "policy".to_string()),("OpenAI_Federation_Rule_Id".to_string(), "rule".to_string()),+ ("CODEX_THREAD_ID".into(), "policy-thread".into()),+ ("CODEX_TOOL_CALL_ID".into(), "policy-call".into()),]),include_only: Vec::new(),});+ params.metadata = Some(crate::protocol::ExecMetadata {+ thread_id: Some(thread_id),+ tool_call_id: Some("current-call".into()),+ });let mut expected = HashMap::from([("OVERLAY".to_string(), "overlay".to_string()),("POLICY_SET".to_string(), "overlay-wins".to_string()),+ ("CODEX_THREAD_ID".into(), thread_id.to_string()),+ ("CODEX_TOOL_CALL_ID".into(), "current-call".into()),]);if cfg!(target_os = "windows") {expected.insert("PATHEXT".to_string(), ".COM;.EXE;.BAT;.CMD".to_string());@@ -1562,6 +1599,68 @@ mod tests {assert_eq!(child_env(¶ms), expected);}+ #[test]+ fn child_env_partial_metadata_removes_stale_counterpart() {+ let thread_id =+ codex_protocol::ThreadId::from_string("019d25f0-6728-7ce2-908f-c3c187323e5b")+ .expect("thread id");+ for (thread_id, call_id) in [+ (Some(thread_id), None),+ (None, Some("exec-call-only")),+ (None, None),+ ] {+ let mut params = test_exec_params(HashMap::from([+ ("CODEX_THREAD_ID".into(), "stale-thread".into()),+ ("Codex_Thread_Id".into(), "mixed-case-thread".into()),+ ("codex_thread_id".into(), "lowercase-thread".into()),+ ("CODEX_TOOL_CALL_ID".into(), "stale-call".into()),+ ("OTHER".into(), "unchanged".into()),+ ]));+ params.metadata = Some(crate::protocol::ExecMetadata {+ thread_id,+ tool_call_id: call_id.map(str::to_string),+ });++ let mut expected = HashMap::from([("OTHER".into(), "unchanged".into())]);+ #[cfg(not(windows))]+ expected.insert("Codex_Thread_Id".into(), "mixed-case-thread".into());+ #[cfg(not(windows))]+ expected.insert("codex_thread_id".into(), "lowercase-thread".into());+ if let Some(thread_id) = thread_id {+ expected.insert("CODEX_THREAD_ID".into(), thread_id.to_string());+ }+ if let Some(call_id) = call_id {+ expected.insert("CODEX_TOOL_CALL_ID".into(), call_id.to_string());+ }+ assert_eq!(+ child_env(¶ms),+ expected,+ "metadata: {:?}",+ params.metadata+ );+ }+ }++ #[test]+ fn child_env_without_metadata_preserves_thread_only_context() {+ let params = test_exec_params(HashMap::from([+ ("CODEX_THREAD_ID".into(), "prewarm-thread".into()),+ ("Codex_Thread_Id".into(), "mixed-case-thread".into()),+ ("CODEX_TOOL_CALL_ID".into(), "stale-call".into()),+ ("Codex_Tool_Call_Id".into(), "mixed-case-call".into()),+ ]));++ assert_eq!(+ child_env(¶ms),+ HashMap::from([+ ("CODEX_THREAD_ID".into(), "prewarm-thread".into()),+ ("Codex_Thread_Id".into(), "mixed-case-thread".into()),+ #[cfg(not(windows))]+ ("Codex_Tool_Call_Id".into(), "mixed-case-call".into()),+ ]),+ );+ }+#[tokio::test]async fn exit_before_shutdown_records_success() {let (backend, metrics, exporter) = telemetry_backend();diff --git a/codex-rs/exec-server/src/shell_snapshot.rs b/codex-rs/exec-server/src/shell_snapshot.rsindex 6619bbb733..dfb02ff92a 100644--- a/codex-rs/exec-server/src/shell_snapshot.rs+++ b/codex-rs/exec-server/src/shell_snapshot.rs@@ -16,6 +16,8 @@ use codex_network_proxy::PROXY_ACTIVE_ENV_KEY;use codex_network_proxy::strip_managed_proxy_env;use codex_protocol::config_types::ShellEnvironmentPolicyInherit;use codex_protocol::shell_environment;+use codex_protocol::shell_environment::CODEX_THREAD_ID_ENV_VAR;+use codex_protocol::shell_environment::CODEX_TOOL_CALL_ID_ENV_VAR;use codex_shell_command::shell_detect::ShellType;use codex_shell_command::shell_snapshot::CapturedSnapshot;use codex_shell_command::shell_snapshot::SnapshotCaptureOptions;@@ -29,6 +31,7 @@ use tokio::sync::OnceCell;use tokio::time::Instant;use crate::FileSystemSandboxContext;+use crate::local_process::apply_exec_metadata;use crate::local_process::shell_environment_policy;use crate::process_sandbox::PreparedExecRequest;use crate::protocol::ExecEnvPolicy;@@ -283,6 +286,7 @@ impl ShellSnapshotCache {.map(|(name, value)| (name.clone(), value.clone())),);prepared.env.extend(request_overrides);+ apply_exec_metadata(&mut prepared.env, params.metadata.as_ref());prepared.env.retain(|name, _| !shell_environment::is_non_inheritable_env_var(name));@@ -396,6 +400,7 @@ async fn capture_snapshot(.current_dir(prepared.cwd.as_path()).env_clear().envs(&prepared.env)+ .env_remove(CODEX_TOOL_CALL_ID_ENV_VAR).stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::null());@@ -558,6 +563,8 @@ fn parse_snapshot(}None => environment,};+ environment.remove(CODEX_THREAD_ID_ENV_VAR);+ environment.remove(CODEX_TOOL_CALL_ID_ENV_VAR);environment.remove("PWD");environment.remove("OLDPWD");environment.retain(|name, _| !shell_environment::is_non_inheritable_env_var(name));diff --git a/codex-rs/exec-server/src/shell_snapshot_tests.rs b/codex-rs/exec-server/src/shell_snapshot_tests.rsindex adc0ceb141..82a34ff739 100644--- a/codex-rs/exec-server/src/shell_snapshot_tests.rs+++ b/codex-rs/exec-server/src/shell_snapshot_tests.rs@@ -310,12 +310,21 @@ fn snapshot_filters_profile_exports_after_capture() {inherit: ShellEnvironmentPolicyInherit::All,ignore_default_excludes: false,exclude: vec!["PROFILE_DENIED".to_string()],- r#set: HashMap::from([("PROFILE_ALLOWED".to_string(), "override".to_string())]),- include_only: vec!["PROFILE_*".to_string()],+ r#set: HashMap::from([+ ("PROFILE_ALLOWED".to_string(), "override".to_string()),+ ("CODEX_THREAD_ID".to_string(), "policy-thread".to_string()),+ ("CODEX_TOOL_CALL_ID".to_string(), "policy-call".to_string()),+ ]),+ // Metadata must survive policy filtering so the cache owns its removal.+ include_only: vec![+ "PROFILE_*".to_string(),+ "CODEX_THREAD_ID".to_string(),+ "CODEX_TOOL_CALL_ID".to_string(),+ ],};let snapshot = parse_snapshot(ShellType::Bash,- b"profile \xff noise\n# Snapshot file\nfunction profile_helper() { :; }\n\0alias profile_alias='profile_helper'\n\0PROFILE_DENIED\0export PROFILE_DENIED=denied\n\0NON_UTF8\0export NON_UTF8='\xff'\n\0\0PROFILE_ALLOWED=profile\0PROFILE_DENIED=denied\0PROFILE_SECRET=secret\0PWD=/tmp\0NON_UTF8=\xff\0",+ b"profile \xff noise\n# Snapshot file\nfunction profile_helper() { :; }\n\0alias profile_alias='profile_helper'\n\0PROFILE_DENIED\0export PROFILE_DENIED=denied\n\0NON_UTF8\0export NON_UTF8='\xff'\n\0\0PROFILE_ALLOWED=profile\0PROFILE_DENIED=denied\0PROFILE_SECRET=secret\0PWD=/tmp\0NON_UTF8=\xff\0CODEX_THREAD_ID=capture-thread\0CODEX_TOOL_CALL_ID=profile-call\0",Some(&policy),SnapshotReplay::Environment,)@@ -380,7 +389,9 @@ fn snapshot_caches_only_unmanaged_proxy_state() {]),),] {- let output = format!("# Snapshot file\n\0\0\0{exports}");+ let output = format!(+ "# Snapshot file\n\0\0\0{exports}CODEX_THREAD_ID=capture-thread\0CODEX_TOOL_CALL_ID=profile-call\0"+ );let snapshot = parse_snapshot(ShellType::Bash,output.as_bytes(),@@ -392,6 +403,7 @@ fn snapshot_caches_only_unmanaged_proxy_state() {assert_eq!(snapshot.environment, expected);}}+use codex_shell_command::shell_detect::ShellType;#[test_case(SnapshotReplay::File, 1024 * 1024, 0, None; "file_accepts_large_state")]diff --git a/codex-rs/exec-server/tests/exec_process.rs b/codex-rs/exec-server/tests/exec_process.rsindex 8cf2a5d76f..956873ee56 100644--- a/codex-rs/exec-server/tests/exec_process.rs+++ b/codex-rs/exec-server/tests/exec_process.rs@@ -14,6 +14,7 @@ use codex_exec_server::Environment;use codex_exec_server::ExecBackend;#[cfg(unix)]use codex_exec_server::ExecEnvPolicy;+use codex_exec_server::ExecMetadata;use codex_exec_server::ExecOutputStream;use codex_exec_server::ExecParams;use codex_exec_server::ExecProcess;@@ -373,6 +374,123 @@ async fn shell_snapshot_v2_filters_profile_exports_and_stays_in_memory(Ok(())}+#[cfg(unix)]+#[test_case(false, false, false; "local_pipe")]+#[test_case(false, true, false; "local_tty")]+#[test_case(true, false, false; "remote_pipe")]+#[test_case(true, true, false; "remote_tty")]+#[test_case(true, false, true; "remote_sandbox")]+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+#[serial_test::serial(remote_exec_server)]+async fn exec_metadata_overrides_policy_and_cached_snapshot(+ use_remote: bool,+ tty: bool,+ use_sandbox: bool,+) -> Result<()> {+ if use_sandbox+ && let Some(warning) = codex_sandboxing::system_bwrap_warning(+ &PermissionProfile::workspace_write(),+ &std::env::current_dir()?,+ )+ {+ eprintln!("skipping sandbox test: {warning}");+ return Ok(());+ }+ let context = create_process_context(use_remote).await?;+ let home = TempDir::new()?;+ let cwd = PathUri::from_host_native_path(home.path())?;+ std::fs::write(+ home.path().join(".bashrc"),+ "printf '%s|%s\n' \"${CODEX_THREAD_ID-unset}\" \"${CODEX_TOOL_CALL_ID-unset}\" >> \"$HOME/capture-env\"\nexport CODEX_THREAD_ID=snapshot-thread\nexport CODEX_TOOL_CALL_ID=snapshot-call\n",+ )?;+ let policy = ExecEnvPolicy {+ inherit: ShellEnvironmentPolicyInherit::None,+ ignore_default_excludes: true,+ exclude: Vec::new(),+ r#set: HashMap::from([+ ("HOME".into(), home.path().to_string_lossy().into_owned()),+ ("PATH".into(), "/usr/bin:/bin".into()),+ ("CODEX_THREAD_ID".into(), "policy-thread".into()),+ ("CODEX_TOOL_CALL_ID".into(), "policy-call".into()),+ ]),+ include_only: Vec::new(),+ };+ let thread_id = codex_protocol::ThreadId::from_string("019d25f0-6728-7ce2-908f-c3c187323e5b")?;+ let later_thread_id =+ codex_protocol::ThreadId::from_string("019d25f0-6728-7ce2-908f-c3c187323e5c")?;++ for (attempt, call_id, expected) in [+ (0, Some(""), ""),+ (1, Some("call-λ-'\";$()"), "call-λ-'\";$()"),+ (2, None, "unset"),+ (3, Some("exec-invalid\0call"), "unset"),+ ] {+ let execution_thread_id = if attempt == 1 {+ later_thread_id+ } else {+ thread_id+ };+ let started = context+ .backend+ .start(ExecParams {+ metadata: Some(ExecMetadata {+ thread_id: Some(execution_thread_id),+ tool_call_id: call_id.map(str::to_string),+ }),+ process_id: ProcessId::from(format!("metadata-snapshot-{attempt}")),+ argv: vec![+ "/bin/bash".into(),+ "-lc".into(),+ "printf '%s|%s' \"$CODEX_THREAD_ID\" \"${CODEX_TOOL_CALL_ID-unset}\""+ .to_string(),+ ],+ cwd: cwd.clone(),+ env_policy: Some(policy.clone()),+ shell_snapshot: Some(ShellSnapshotRequest {+ scope_id: "metadata-attachment".into(),+ shell: ShellInfo {+ name: "bash".into(),+ path: "/bin/bash".into(),+ },+ }),+ env: HashMap::from([+ ("CODEX_THREAD_ID".into(), "overlay-thread".into()),+ ("CODEX_TOOL_CALL_ID".into(), "overlay-call".into()),+ ]),+ tty,+ pipe_stdin: false,+ arg0: None,+ sandbox: use_sandbox.then(|| {+ FileSystemSandboxContext::from_permission_profile(+ PermissionProfile::workspace_write(),+ cwd.clone(),+ )+ }),+ enforce_managed_network: false,+ managed_network: None,+ network_proxy: None,+ })+ .await?;+ let (stdout, stderr, status, closed) =+ collect_process_output_from_events(started.process).await?;+ assert_eq!(+ (stdout, stderr, status, closed),+ (+ format!("{execution_thread_id}|{expected}"),+ String::new(),+ Some(0),+ true,+ )+ );+ }++ assert_eq!(+ std::fs::read_to_string(home.path().join("capture-env"))?,+ "019d25f0-6728-7ce2-908f-c3c187323e5b|unset\n"+ );+ Ok(())+}+#[cfg(unix)]#[tokio::test(flavor = "multi_thread", worker_threads = 2)]#[serial_test::serial(remote_exec_server)]@@ -715,16 +833,43 @@ async fn remote_sandboxed_process_preserves_custom_arg0() -> Result<()> {async fn assert_exec_process_starts_and_exits(use_remote: bool) -> Result<()> {let context = create_process_context(use_remote).await?;+ let thread_id = codex_protocol::ThreadId::from_string("019d25f0-6728-7ce2-908f-c3c187323e5b")?;+ let call_id = "call-λ-'\";$()";+ #[cfg(unix)]+ let argv = vec![+ "/bin/sh".into(),+ "-c".into(),+ "printf '%s|%s|%s' \"$CODEX_THREAD_ID\" \"$CODEX_TOOL_CALL_ID\" \"$CUSTOM_ENV_VAR\""+ .to_string(),+ ];+ #[cfg(windows)]+ let argv = vec![+ "powershell.exe".into(),+ "-NoProfile".into(),+ "-Command".into(),+ "[Console]::OutputEncoding = [Text.UTF8Encoding]::new($false); [Console]::Write($env:CODEX_THREAD_ID + '|' + $env:CODEX_TOOL_CALL_ID + '|' + $env:CUSTOM_ENV_VAR)".into(),+ ];+ let mut env = std::env::vars().collect::<HashMap<_, _>>();+ env.extend([+ ("CODEX_THREAD_ID".into(), "stale-thread".into()),+ ("Codex_Thread_Id".into(), "mixed-case-thread".into()),+ ("CODEX_TOOL_CALL_ID".into(), "stale-call".into()),+ ("Codex_Tool_Call_Id".into(), "mixed-case-call".into()),+ ("CUSTOM_ENV_VAR".into(), "caller-owned".into()),+ ]);let session = context.backend.start(ExecParams {- metadata: Default::default(),+ metadata: Some(ExecMetadata {+ thread_id: Some(thread_id),+ tool_call_id: Some(call_id.to_string()),+ }),process_id: ProcessId::from("proc-1"),- argv: vec!["true".to_string()],+ argv,cwd: PathUri::from_host_native_path(std::env::current_dir()?)?,shell_snapshot: None,env_policy: /*env_policy*/ None,- env: Default::default(),+ env,tty: false,pipe_stdin: false,arg0: None,@@ -736,6 +881,17 @@ async fn assert_exec_process_starts_and_exits(use_remote: bool) -> Result<()> {.await?;assert_eq!(session.process.process_id().as_str(), "proc-1");let wake_rx = session.process.subscribe_wake();+ let (stdout, stderr, status, closed) =+ collect_process_output_from_events(Arc::clone(&session.process)).await?;+ assert_eq!(+ (stdout, stderr, status, closed),+ (+ format!("{thread_id}|{call_id}|caller-owned"),+ String::new(),+ Some(0),+ true,+ )+ );let (_, exit_code, closed) =collect_process_output_from_reads(session.process, wake_rx).await?;@@ -1776,7 +1932,6 @@ async fn remote_exec_process_recovers_after_transport_disconnect() -> Result<()>#[test_case(false ; "local")]#[test_case(true ; "remote")]-#[cfg_attr(not(unix), ignore = "Unix-only exec-server process test")]#[tokio::test(flavor = "multi_thread", worker_threads = 2)]// Serialize tests that launch a real exec-server process through the full CLI.#[serial_test::serial(remote_exec_server)]diff --git a/codex-rs/protocol/src/shell_environment.rs b/codex-rs/protocol/src/shell_environment.rsindex 427fe4969f..0c6c515c41 100644--- a/codex-rs/protocol/src/shell_environment.rs+++ b/codex-rs/protocol/src/shell_environment.rs@@ -5,6 +5,7 @@ use std::collections::HashMap;pub const CODEX_SESSION_ID_ENV_VAR: &str = "CODEX_SESSION_ID";pub const CODEX_THREAD_ID_ENV_VAR: &str = "CODEX_THREAD_ID";+pub const CODEX_TOOL_CALL_ID_ENV_VAR: &str = "CODEX_TOOL_CALL_ID";pub const CODEX_EXEC_SERVER_NOISE_AUTH_TOKEN_ENV_VAR: &str = "CODEX_EXEC_SERVER_NOISE_AUTH_TOKEN";pub const OPENAI_FEDERATION_RULE_ID_ENV_VAR: &str = "OPENAI_FEDERATION_RULE_ID";pub const OPENAI_IDENTITY_TOKEN_FILE_ENV_VAR: &str = "OPENAI_IDENTITY_TOKEN_FILE";@@ -26,6 +27,19 @@ pub fn is_non_inheritable_env_var(name: &str) -> bool {.any(|restricted| restricted.eq_ignore_ascii_case(name))}+pub fn set_tool_call_id_env_var(env: &mut HashMap<String, String>, tool_call_id: Option<&str>) {+ #[cfg(windows)]+ env.retain(|name, _| !name.eq_ignore_ascii_case(CODEX_TOOL_CALL_ID_ENV_VAR));+ #[cfg(not(windows))]+ env.remove(CODEX_TOOL_CALL_ID_ENV_VAR);+ if let Some(tool_call_id) = tool_call_id.filter(|tool_call_id| !tool_call_id.contains('\0')) {+ env.insert(+ CODEX_TOOL_CALL_ID_ENV_VAR.to_string(),+ tool_call_id.to_string(),+ );+ }+}+/// Configures a child command to omit non-inheritable variables from the/// process environment and explicit command overrides.///diff --git a/codex-rs/protocol/src/shell_environment_tests.rs b/codex-rs/protocol/src/shell_environment_tests.rsindex c987f631db..8167a2afa1 100644--- a/codex-rs/protocol/src/shell_environment_tests.rs+++ b/codex-rs/protocol/src/shell_environment_tests.rs@@ -9,6 +9,50 @@ const CHILD_MODE_ENV_VAR: &str = "CODEX_SHELL_ENVIRONMENT_SCRUBBER_TEST_MODE";const TEST_NAME: &str ="shell_environment::tests::command_scrubber_removes_names_from_real_child_environment";+#[test]+fn tool_call_id_replaces_platform_equivalent_names() {+ let representable = format!("exec-雪-{}", "x".repeat(512));+ for (call_id, expected_call) in [+ (None, None),+ (Some(""), Some("")),+ (Some("invalid\0call"), None),+ (Some("current-call"), Some("current-call")),+ (Some(representable.as_str()), Some(representable.as_str())),+ ] {+ let mut env = HashMap::from([+ ("CODEX_TOOL_CALL_ID".to_string(), "stale-call".to_string()),+ (+ "Codex_Tool_Call_Id".to_string(),+ "mixed-case-call".to_string(),+ ),+ (+ "codex_tool_call_id".to_string(),+ "lowercase-call".to_string(),+ ),+ ("OTHER".to_string(), "unchanged".to_string()),+ ]);++ set_tool_call_id_env_var(&mut env, call_id);++ let mut expected = HashMap::from([("OTHER".to_string(), "unchanged".to_string())]);+ #[cfg(not(windows))]+ expected.extend([+ (+ "Codex_Tool_Call_Id".to_string(),+ "mixed-case-call".to_string(),+ ),+ (+ "codex_tool_call_id".to_string(),+ "lowercase-call".to_string(),+ ),+ ]);+ if let Some(expected_call) = expected_call {+ expected.insert("CODEX_TOOL_CALL_ID".to_string(), expected_call.to_string());+ }+ assert_eq!(env, expected, "call_id: {call_id:?}");+ }+}+#[test]fn non_inheritable_environment_is_removed_after_policy_overrides() {let vars = [diff --git a/codex-rs/shell-command/src/shell_snapshot_capture.rs b/codex-rs/shell-command/src/shell_snapshot_capture.rsindex cbd1f235e9..9ffadc6074 100644--- a/codex-rs/shell-command/src/shell_snapshot_capture.rs+++ b/codex-rs/shell-command/src/shell_snapshot_capture.rs@@ -7,6 +7,8 @@ use super::literals;use super::posix_env_path_expansion_function;use crate::shell_detect::ShellType;use crate::shell_startup_script;+use codex_protocol::shell_environment::CODEX_THREAD_ID_ENV_VAR;+use codex_protocol::shell_environment::CODEX_TOOL_CALL_ID_ENV_VAR;use std::borrow::Cow;const SNAPSHOT_COMMAND_HELPER: &str = r#"__codex_snapshot_command() {@@ -362,6 +364,13 @@ impl<'a> CapturedSnapshot<'a> {});}}+ // Each launch supplies execution IDs; omit their captured exports.+ records.retain(|export| {+ !matches!(+ export.key,+ CODEX_THREAD_ID_ENV_VAR | CODEX_TOOL_CALL_ID_ENV_VAR+ )+ });return Some(Self {startup_environment,shell_type,diff --git a/codex-rs/shell-command/src/shell_snapshot_tests.rs b/codex-rs/shell-command/src/shell_snapshot_tests.rsindex 43a8952752..fc5c2259e8 100644--- a/codex-rs/shell-command/src/shell_snapshot_tests.rs+++ b/codex-rs/shell-command/src/shell_snapshot_tests.rs@@ -81,10 +81,12 @@ fn snapshot_capture_selects_declarations_and_environment() -> Result<()> {).unwrap();let output = Command::new(shell)- .args(["-c", &script])+ .args(["-c", &format!("readonly CODEX_THREAD_ID; {script}")]).env_clear().env("HOME", dir.path()).env("PATH", "/usr/bin:/bin")+ .env("CODEX_THREAD_ID", "capture-thread")+ .env("CODEX_TOOL_CALL_ID", "profile-call").env("APP_SETTING", "value").output()?;assert!(output.status.success(), "{shell}: {output:?}");@@ -103,6 +105,55 @@ fn snapshot_capture_selects_declarations_and_environment() -> Result<()> {(declarations, environment),"{shell}");+ if !declarations || !environment {+ continue;+ }++ // Both replay paths must preserve current metadata from a full capture.+ let replay_environment = HashMap::from([+ ("CODEX_THREAD_ID".to_string(), "capture-thread".to_string()),+ ("CODEX_TOOL_CALL_ID".to_string(), "profile-call".to_string()),+ ("APP_SETTING".to_string(), "value".to_string()),+ ]);+ let empty = HashMap::new();+ let brokered = prepare_snapshot_credentials(+ &captured,+ SnapshotCredentialEnvironment {+ original: &replay_environment,+ restored: &replay_environment,+ allowed: &replay_environment,+ ..empty_snapshot_credentials(&empty, &|_| true)+ },+ |_| true,+ )+ .expect("metadata is not a credential");+ for snapshot in [+ captured.render_script(+ &codex_protocol::config_types::ShellEnvironmentPolicy::default(),+ ),+ brokered.script,+ ] {+ assert!(!snapshot.contains("CODEX_THREAD_ID"), "{shell}: {snapshot}");+ assert!(+ !snapshot.contains("CODEX_TOOL_CALL_ID"),+ "{shell}: {snapshot}"+ );+ let path = dir.path().join("snapshot.sh");+ std::fs::write(&path, snapshot)?;+ let replay = Command::new(shell)+ .args(["-c", "set -e; . \"$1\"; printf '%s|%s|%s' \"$CODEX_THREAD_ID\" \"$CODEX_TOOL_CALL_ID\" \"$APP_SETTING\"", "replay"])+ .arg(&path)+ .env_clear()+ .env("PATH", "/usr/bin:/bin")+ .env("CODEX_THREAD_ID", "current-thread")+ .env("CODEX_TOOL_CALL_ID", "current-call")+ .output()?;+ assert!(replay.status.success(), "{shell}: {replay:?}");+ assert_eq!(+ replay.stdout, b"current-thread|current-call|value",+ "{shell}"+ );+ }}}Ok(())