refactor: introduce Orchestrator to support multi-mode execution

Add an Orchestrator struct that owns the shared run-time state
(provider, system_info, logger) and drives the full execution
lifecycle: setup → run all modes → upload all results → poll.

This replaces the monolithic ExecutionContext with a leaner per-mode
context, and wires up the mode/shell-session APIs to accept Vec<RunnerMode>
so that multiple modes can be requested in a single CLI invocation.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: GuillaumeLagrange

src/cli/exec/mod.rs

@@ -91,20 +91,19 @@ pub async fn run(
 /// result polling. It is used by both `codspeed exec` directly and by `codspeed run` when
 /// executing targets defined in codspeed.yaml.
 pub async fn execute_with_harness(
-    config: crate::executor::Config,
+    mut config: crate::executor::Config,
     api_client: &CodSpeedAPIClient,
     codspeed_config: &CodSpeedConfig,
     setup_cache_dir: Option<&Path>,
 ) -> Result<()> {
-    let mut execution_context =
-        executor::ExecutionContext::new(config, codspeed_config, api_client).await?;
+    let orchestrator =
+        executor::Orchestrator::new(&mut config, codspeed_config, api_client).await?;
 
-    if !execution_context.is_local() {
+    if !orchestrator.is_local() {
         super::show_banner();
     }
 
-    debug!("config: {:#?}", execution_context.config);
-    let executor = executor::get_executor_from_mode(&execution_context.config.mode);
+    debug!("config: {config:#?}");
 
     let get_exec_harness_installer_url = || {
         format!(
@@ -125,13 +124,9 @@ pub async fn execute_with_harness(
         poll_results(api_client, upload_result, &poll_opts).await
     };
 
-    executor::execute_benchmarks(
-        executor.as_ref(),
-        &mut execution_context,
-        setup_cache_dir,
-        poll_results_fn,
-    )
-    .await?;
+    orchestrator
+        .execute(&mut config, setup_cache_dir, poll_results_fn)
+        .await?;
 
     Ok(())
 }

src/cli/run/logger.rs

@@ -1,11 +1,10 @@
-use crate::executor::ExecutionContext;
 use crate::logger::{GROUP_TARGET, OPENED_GROUP_TARGET};
 use crate::prelude::*;
 use crate::run_environment::RunEnvironmentProvider;
 use log::LevelFilter;
 use simplelog::{CombinedLogger, WriteLogger};
 use std::fs::copy;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use tempfile::NamedTempFile;
 
 pub struct Logger {
@@ -34,11 +33,7 @@ impl Logger {
         Ok(Self { log_file_path })
     }
 
-    pub fn persist_log_to_profile_folder(
-        &self,
-        execution_context: &ExecutionContext,
-    ) -> Result<()> {
-        let profile_folder = execution_context.profile_folder.clone();
+    pub fn persist_log_to_profile_folder(&self, profile_folder: &Path) -> Result<()> {
         let dest_log_file_path = profile_folder.join("runner.log");
         debug!("Persisting log file to {}", dest_log_file_path.display());
         log::logger().flush();

src/cli/run/mod.rs

@@ -70,7 +70,7 @@ impl RunArgs {
                 repository: None,
                 provider: None,
                 working_directory: None,
-                mode: Some(RunnerMode::Simulation),
+                mode: vec![RunnerMode::Simulation],
                 simulation_tool: None,
                 profile_folder: None,
                 skip_upload: false,
@@ -141,31 +141,23 @@ pub async fn run(
 
     match run_target {
         RunTarget::SingleCommand(args) => {
-            let config = Config::try_from(args)?;
+            let mut config = Config::try_from(args)?;
 
-            // Create execution context
-            let mut execution_context =
-                executor::ExecutionContext::new(config, codspeed_config, api_client).await?;
+            let orchestrator =
+                executor::Orchestrator::new(&mut config, codspeed_config, api_client).await?;
 
-            if !execution_context.is_local() {
+            if !orchestrator.is_local() {
                 super::show_banner();
             }
-            debug!("config: {:#?}", execution_context.config);
-
-            // Execute benchmarks
-            let executor = executor::get_executor_from_mode(&execution_context.config.mode);
+            debug!("config: {config:#?}");
 
             let poll_opts = PollResultsOptions::for_run(output_json);
             let poll_results_fn = async |upload_result: &UploadResult| {
                 poll_results(api_client, upload_result, &poll_opts).await
             };
-            executor::execute_benchmarks(
-                executor.as_ref(),
-                &mut execution_context,
-                setup_cache_dir,
-                poll_results_fn,
-            )
-            .await?;
+            orchestrator
+                .execute(&mut config, setup_cache_dir, poll_results_fn)
+                .await?;
         }
 
         RunTarget::ConfigTargets {

src/cli/shared.rs

@@ -55,8 +55,14 @@ pub struct ExecAndRunSharedArgs {
 
     /// The mode to run the benchmarks in.
     /// If not provided, the mode will be loaded from the shell session (set via `codspeed use <mode>`).
-    #[arg(short, long, value_enum, env = "CODSPEED_RUNNER_MODE")]
-    pub mode: Option<RunnerMode>,
+    #[arg(
+        short,
+        long,
+        value_enum,
+        env = "CODSPEED_RUNNER_MODE",
+        value_delimiter = ','
+    )]
+    pub mode: Vec<RunnerMode>,
 
     /// The Valgrind simulation tool to use (callgrind or tracegrind).
     #[arg(long, value_enum, env = "CODSPEED_SIMULATION_TOOL", hide = true)]
@@ -98,25 +104,26 @@ pub struct ExecAndRunSharedArgs {
 }
 
 impl ExecAndRunSharedArgs {
-    /// Resolves the runner mode from CLI argument, shell session, or returns an error.
+    /// Resolves the runner modes from CLI argument, shell session, or returns an error.
     ///
     /// Priority:
     /// 1. CLI argument (--mode or -m)
     /// 2. Shell session mode (set via `codspeed use <mode>`)
     /// 3. Error if neither is available
-    pub fn resolve_mode(&self) -> Result<RunnerMode> {
-        if let Some(mode) = &self.mode {
-            return Ok(mode.clone());
+    pub fn resolve_modes(&self) -> Result<Vec<RunnerMode>> {
+        if !self.mode.is_empty() {
+            return Ok(self.mode.clone());
         }
 
-        if let Some(mode) = load_shell_session_mode()? {
-            debug!("Loaded mode from shell session: {mode:?}");
-            return Ok(mode);
+        let modes = load_shell_session_mode()?;
+
+        if modes.is_empty() {
+            return Err(anyhow!(
+                "No runner mode specified. Use --mode <mode> or set the mode for this shell session with `codspeed use <mode>`."
+            ));
         }
 
-        Err(anyhow!(
-            "No runner mode specified. Use --mode <mode> or set the mode for this shell session with `codspeed use <mode>`."
-        ))
+        Ok(modes)
     }
 }
 

src/cli/show.rs

@@ -1,12 +1,17 @@
 use crate::prelude::*;
 
 pub fn run() -> Result<()> {
-    let shell_session_mode = crate::runner_mode::load_shell_session_mode()?;
+    let modes = crate::runner_mode::load_shell_session_mode()?;
 
-    if let Some(mode) = shell_session_mode {
-        info!("{mode:?}");
-    } else {
+    if modes.is_empty() {
         info!("No mode set for this shell session");
+    } else {
+        let modes_str = modes
+            .iter()
+            .map(|m| format!("{m:?}"))
+            .collect::<Vec<_>>()
+            .join(", ");
+        info!("{modes_str}");
     }
 
     Ok(())

src/cli/use_mode.rs

@@ -6,9 +6,11 @@ use clap::Args;
 
 #[derive(Debug, Args)]
 pub struct UseArgs {
-    /// Set the CodSpeed runner mode for this shell session. If not provided, the current mode will
-    /// be displayed.
-    pub mode: RunnerMode,
+    /// Set the CodSpeed runner mode(s) for this shell session.
+    /// Multiple modes can be provided as separate arguments (e.g. `simulation walltime`)
+    /// or comma-separated (e.g. `simulation,walltime`).
+    #[arg(value_delimiter = ',', required = true)]
+    pub mode: Vec<RunnerMode>,
 }
 
 pub fn run(args: UseArgs) -> Result<()> {

src/executor/config.rs

@@ -27,15 +27,15 @@ pub enum SimulationTool {
 /// for controlling the execution flow. It is typically constructed from command-line
 /// arguments via [`RunArgs`] and combined with [`CodSpeedConfig`] to create an
 /// [`ExecutionContext`].
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Config {
     pub upload_url: Url,
     pub token: Option<String>,
     pub repository_override: Option<RepositoryOverride>,
     pub working_directory: Option<String>,
     pub command: String,
 
-    pub mode: RunnerMode,
+    pub modes: Vec<RunnerMode>,
     pub instruments: Instruments,
     pub enable_perf: bool,
     /// Stack unwinding mode for perf (if enabled)
@@ -53,7 +53,7 @@ pub struct Config {
     pub go_runner_version: Option<Version>,
 }
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct RepositoryOverride {
     pub owner: String,
     pub repository: String,
@@ -81,6 +81,13 @@ impl Config {
     pub fn set_token(&mut self, token: Option<String>) {
         self.token = token;
     }
+
+    /// Create a clone of this config pinned to a single mode.
+    pub fn for_mode(&self, mode: &RunnerMode) -> Config {
+        let mut c = self.clone();
+        c.modes = vec![mode.clone()];
+        c
+    }
 }
 
 #[cfg(test)]
@@ -93,7 +100,7 @@ impl Config {
             repository_override: None,
             working_directory: None,
             command: "".into(),
-            mode: RunnerMode::Simulation,
+            modes: vec![RunnerMode::Simulation],
             instruments: Instruments::test(),
             perf_unwinding_mode: None,
             enable_perf: false,
@@ -114,7 +121,7 @@ impl TryFrom<RunArgs> for Config {
     type Error = Error;
     fn try_from(args: RunArgs) -> Result<Self> {
         let instruments = Instruments::try_from(&args)?;
-        let mode = args.shared.resolve_mode()?;
+        let modes = args.shared.resolve_modes()?;
         let raw_upload_url = args
             .shared
             .upload_url
@@ -131,7 +138,7 @@ impl TryFrom<RunArgs> for Config {
                 .map(|repo| RepositoryOverride::from_arg(repo, args.shared.provider))
                 .transpose()?,
             working_directory: args.shared.working_directory,
-            mode,
+            modes,
             instruments,
             perf_unwinding_mode: args.shared.perf_run_args.perf_unwinding_mode,
             enable_perf: args.shared.perf_run_args.enable_perf,
@@ -153,7 +160,7 @@ impl Config {
         args: crate::cli::exec::ExecArgs,
         command: String,
     ) -> Result<Self> {
-        let mode = args.shared.resolve_mode()?;
+        let modes = args.shared.resolve_modes()?;
         let raw_upload_url = args
             .shared
             .upload_url
@@ -170,7 +177,7 @@ impl Config {
                 .map(|repo| RepositoryOverride::from_arg(repo, args.shared.provider))
                 .transpose()?,
             working_directory: args.shared.working_directory,
-            mode,
+            modes,
             instruments: Instruments { mongodb: None }, // exec doesn't support MongoDB
             perf_unwinding_mode: args.shared.perf_run_args.perf_unwinding_mode,
             enable_perf: args.shared.perf_run_args.enable_perf,
@@ -210,7 +217,7 @@ mod tests {
                 repository: None,
                 provider: None,
                 working_directory: None,
-                mode: Some(RunnerMode::Simulation),
+                mode: vec![RunnerMode::Simulation],
                 simulation_tool: None,
                 profile_folder: None,
                 skip_upload: false,
@@ -250,7 +257,7 @@ mod tests {
                 repository: Some("owner/repo".into()),
                 provider: Some(RepositoryProvider::GitLab),
                 working_directory: Some("/tmp".into()),
-                mode: Some(RunnerMode::Simulation),
+                mode: vec![RunnerMode::Simulation],
                 simulation_tool: None,
                 profile_folder: Some("./codspeed.out".into()),
                 skip_upload: true,
@@ -334,7 +341,7 @@ mod tests {
                 repository: None,
                 provider: None,
                 working_directory: None,
-                mode: Some(RunnerMode::Simulation),
+                mode: vec![RunnerMode::Simulation],
                 simulation_tool: None,
                 profile_folder: None,
                 skip_upload: false,