perf: Reduce git subprocess calls on startup (#11934)

## Summary

Reduces the number of sequential git subprocess calls on the critical
startup path from 5 to 1.

| Repo size | Before | After | Speedup |
|---|---|---|---|
| Small (1 package) | 868ms ± 27ms | 757ms ± 25ms | **1.14x** |
| Medium (~10 packages) | 1.233s ± 0.063s | 1.127s ± 0.038s | **1.09x**
|
| Large (~50 packages) | 1.896s ± 0.124s | 1.735s ± 0.086s | **1.09x** |

Measured with `hyperfine --warmup 5` on `turbo run <task> --skip-infer
--dry`. "Before" is main with the shared HTTP client optimization
already applied.

## What changed

### 1. Combined worktree detection into a single git call

`WorktreeInfo::detect` previously spawned two separate `git rev-parse`
subprocesses (`--show-toplevel` and `--git-common-dir`). Now it runs a
single `git rev-parse --show-toplevel --git-common-dir --show-cdup` and
parses all three results from the output. The `--show-cdup` result (git
root) is stored on `WorktreeInfo` so it can be reused later by
`SCM::new`.

### 2. Deferred run summary git calls to finish time

`RunTracker::new` previously called `SCMState::get()` eagerly, which
spawns `git branch --show-current` and `git rev-parse HEAD` — two
subprocesses purely for run summary metadata. These have no impact on
task execution or caching. They're now computed in `to_summary()`, after
tasks complete.

### 3. Reuse git root from worktree detection in SCM::new

`SCM::new` previously spawned its own `git rev-parse --show-cdup` to
find the git root — the same information already resolved during
worktree detection. Now the git root flows from `WorktreeInfo` →
`CacheDirResult` → `Opts` → `RunBuilder`, and `SCM::new_with_git_root`
skips the redundant subprocess entirely.

Together this reduces 5 sequential subprocess spawns on the critical
path to 1 (the combined worktree detection call), with the 2 summary
calls deferred to after task execution.

## Testing

- All 5 worktree tests pass with new `git_root` assertions (main
worktree, linked worktree, subdirectories, non-git directories)
- The deferred SCMState has no early readers — the `scm` field was
removed from `RunTracker` entirely

Author: anthonyshew

crates/turborepo-config/src/lib.rs

@@ -63,6 +63,9 @@ pub struct CacheDirResult {
     /// This is used for messaging to inform users when worktree cache sharing
     /// is active.
     pub is_shared_worktree: bool,
+    /// The git repository root, if detected during worktree resolution.
+    /// Captured here so `SCM::new` can skip its own `git rev-parse` call.
+    pub git_root: Option<AbsoluteSystemPathBuf>,
 }
 
 /// Configuration errors for turborepo.
@@ -393,6 +396,7 @@ impl ConfigurationOptions {
             return CacheDirResult {
                 path: explicit_cache_dir.clone(),
                 is_shared_worktree: false,
+                git_root: None,
             };
         }
 
@@ -405,6 +409,7 @@ impl ConfigurationOptions {
                     worktree_info.main_worktree_root,
                     worktree_info.is_linked_worktree()
                 );
+                let git_root = Some(worktree_info.git_root.clone());
                 if worktree_info.is_linked_worktree() {
                     // We're in a linked worktree - use the main worktree's cache
                     // Use turbopath's join_component to ensure consistent path separators
@@ -415,6 +420,7 @@ impl ConfigurationOptions {
                     let result = CacheDirResult {
                         path: Utf8PathBuf::from(main_cache_path.as_str()),
                         is_shared_worktree: true,
+                        git_root,
                     };
                     debug!("Using shared worktree cache at: {}", result.path);
                     result
@@ -427,6 +433,7 @@ impl ConfigurationOptions {
                     CacheDirResult {
                         path: Utf8PathBuf::from(Self::DEFAULT_CACHE_DIR),
                         is_shared_worktree: false,
+                        git_root,
                     }
                 }
             }
@@ -440,6 +447,7 @@ impl ConfigurationOptions {
                 CacheDirResult {
                     path: Utf8PathBuf::from(Self::DEFAULT_CACHE_DIR),
                     is_shared_worktree: false,
+                    git_root: None,
                 }
             }
         }

crates/turborepo-lib/src/opts.rs

@@ -4,7 +4,7 @@ use camino::Utf8PathBuf;
 use serde::Serialize;
 use thiserror::Error;
 use tracing::debug;
-use turbopath::{AbsoluteSystemPath, AnchoredSystemPathBuf};
+use turbopath::{AbsoluteSystemPath, AbsoluteSystemPathBuf, AnchoredSystemPathBuf};
 use turborepo_api_client::APIAuth;
 use turborepo_cache::{CacheOpts, RemoteCacheOpts};
 // Re-export RunCacheOpts from turborepo-run-cache
@@ -66,6 +66,9 @@ pub struct Opts {
     pub scope_opts: ScopeOpts,
     pub tui_opts: TuiOpts,
     pub future_flags: FutureFlags,
+    /// Pre-resolved git root from worktree detection, if available.
+    /// Allows `SCM::new` to skip its own `git rev-parse` subprocess.
+    pub git_root: Option<AbsoluteSystemPathBuf>,
 }
 
 impl Opts {
@@ -189,6 +192,7 @@ impl Opts {
             api_client_opts,
             tui_opts,
             future_flags,
+            git_root: cache_dir_result.git_root,
         })
     }
 }
@@ -733,6 +737,7 @@ mod test {
             runcache_opts,
             tui_opts,
             future_flags: Default::default(),
+            git_root: None,
         };
         let synthesized = opts.synthesize_command();
         assert_eq!(synthesized, expected);

crates/turborepo-lib/src/run/builder.rs

@@ -203,8 +203,12 @@ impl RunBuilder {
 
         let scm_task = {
             let repo_root = self.repo_root.clone();
+            let git_root = self.opts.git_root.clone();
             tokio::task::spawn_blocking(move || {
-                let scm = SCM::new(&repo_root);
+                let scm = match git_root {
+                    Some(root) => SCM::new_with_git_root(&repo_root, root),
+                    None => SCM::new(&repo_root),
+                };
                 let repo_index = scm.build_repo_index_eager();
                 (scm, repo_index)
             })

crates/turborepo-lib/src/run/mod.rs

@@ -698,11 +698,8 @@ impl Run {
         let run_tracker = RunTracker::new(
             self.start_at,
             self.opts.synthesize_command(),
-            &self.env_at_execution_start,
-            &self.repo_root,
             self.version,
             Vendor::get_user(),
-            &self.scm,
         );
 
         let mut visitor = Visitor::new(
@@ -766,6 +763,7 @@ impl Run {
                 global_hash_inputs,
                 &self.engine,
                 &self.env_at_execution_start,
+                &self.scm,
                 self.opts.scope_opts.pkg_inference_root.as_deref(),
             )
             .await?;

crates/turborepo-lib/src/task_graph/visitor/mod.rs

@@ -24,6 +24,7 @@ use turborepo_errors::TURBO_SITE;
 use turborepo_process::ProcessManager;
 use turborepo_repository::package_graph::{PackageGraph, PackageName, ROOT_PKG_NAME};
 use turborepo_run_summary::{self as summary, GlobalHashSummary, RunTracker};
+use turborepo_scm::SCM;
 // Re-export output types and shared functions from turborepo-task-executor
 pub use turborepo_task_executor::{turbo_regex, StdWriter, TaskOutput};
 use turborepo_task_id::TaskId;
@@ -369,7 +370,8 @@ impl<'a> Visitor<'a> {
         packages,
         global_hash_inputs,
         engine,
-        env_at_execution_start
+        env_at_execution_start,
+        scm,
     ))]
     pub(crate) async fn finish(
         self,
@@ -378,6 +380,7 @@ impl<'a> Visitor<'a> {
         global_hash_inputs: GlobalHashableInputs<'_>,
         engine: &Engine,
         env_at_execution_start: &EnvironmentVariableMap,
+        scm: &SCM,
         pkg_inference_root: Option<&AnchoredSystemPath>,
     ) -> Result<(), Error> {
         let Self {
@@ -427,6 +430,7 @@ impl<'a> Visitor<'a> {
                 engine,
                 &task_hasher.task_hash_tracker(),
                 env_at_execution_start,
+                scm,
                 is_watch,
             )
             .await?)

crates/turborepo-run-summary/src/scm.rs

@@ -19,6 +19,11 @@ pub struct SCMState {
 }
 
 impl SCMState {
+    /// Resolve SCM state from CI environment variables, falling back to git
+    /// subprocess calls if not in CI. The git fallback spawns two subprocesses
+    /// (`git branch --show-current` and `git rev-parse HEAD`), so callers
+    /// should defer this until the data is actually needed (e.g., summary
+    /// generation) rather than calling it eagerly at run start.
     pub fn get(env_vars: &EnvironmentVariableMap, scm: &SCM, dir: &AbsoluteSystemPath) -> Self {
         let mut state = SCMState {
             ty: SCMType::Git,

crates/turborepo-run-summary/src/tracker.rs

@@ -86,7 +86,6 @@ pub struct RunSummary<'a> {
 /// We use this to track the run, so it's constructed before the run.
 #[derive(Debug)]
 pub struct RunTracker {
-    scm: SCMState,
     version: &'static str,
     started_at: DateTime<Local>,
     execution_tracker: ExecutionTracker,
@@ -95,20 +94,13 @@ pub struct RunTracker {
 }
 
 impl RunTracker {
-    #[allow(clippy::too_many_arguments)]
     pub fn new(
         started_at: DateTime<Local>,
         synthesized_command: String,
-        env_at_execution_start: &EnvironmentVariableMap,
-        repo_root: &AbsoluteSystemPath,
         version: &'static str,
         user: Option<String>,
-        scm: &SCM,
     ) -> Self {
-        let scm = SCMState::get(env_at_execution_start, scm, repo_root);
-
         RunTracker {
-            scm,
             version,
             started_at,
             execution_tracker: ExecutionTracker::new(),
@@ -137,6 +129,8 @@ impl RunTracker {
         global_hash_summary: GlobalHashSummary<'a>,
         global_env_mode: EnvMode,
         task_factory: TaskSummaryFactory<'a, E, H, R>,
+        env_at_execution_start: &EnvironmentVariableMap,
+        scm: &SCM,
     ) -> Result<RunSummary<'a>, Error>
     where
         E: EngineInfo,
@@ -152,6 +146,10 @@ impl RunTracker {
             Some(DryRunMode::Text) => RunType::DryText,
         };
 
+        // Deferred to summary time so we don't pay the cost of git subprocess
+        // calls (branch + sha) during the critical path of task execution.
+        let scm_state = SCMState::get(env_at_execution_start, scm, repo_root);
+
         let summary_state = self.execution_tracker.finish().await?;
 
         let tasks = summary_state
@@ -179,7 +177,7 @@ impl RunTracker {
             framework_inference: run_opts.framework_inference(),
             tasks,
             global_hash_summary,
-            scm: self.scm,
+            scm: scm_state,
             user: self.user.unwrap_or_default(),
             monorepo: !single_package,
             repo_root,
@@ -196,7 +194,8 @@ impl RunTracker {
         global_hash_summary,
         engine,
         hash_tracker,
-        env_at_execution_start
+        env_at_execution_start,
+        scm,
     ))]
     #[allow(clippy::too_many_arguments)]
     pub async fn finish<'a, E, H, R>(
@@ -213,6 +212,7 @@ impl RunTracker {
         engine: &'a E,
         hash_tracker: &'a H,
         env_at_execution_start: &'a EnvironmentVariableMap,
+        scm: &SCM,
         is_watch: bool,
     ) -> Result<(), Error>
     where
@@ -242,6 +242,8 @@ impl RunTracker {
                 global_hash_summary,
                 global_env_mode,
                 task_factory,
+                env_at_execution_start,
+                scm,
             )
             .await?;
 

crates/turborepo-scm/src/lib.rs

@@ -293,6 +293,29 @@ impl SCM {
             })
     }
 
+    /// Creates an SCM instance using a pre-resolved git root, avoiding the
+    /// `git rev-parse --show-cdup` subprocess call that `new` would perform.
+    /// Falls back to `new` if the git binary cannot be found.
+    #[tracing::instrument]
+    pub fn new_with_git_root(
+        path_in_repo: &AbsoluteSystemPath,
+        git_root: AbsoluteSystemPathBuf,
+    ) -> SCM {
+        match GitRepo::find_bin() {
+            Ok(bin) => SCM::Git(GitRepo {
+                root: git_root,
+                bin,
+            }),
+            Err(e) => {
+                debug!(
+                    "git binary not found: {}, continuing with manual hashing",
+                    e
+                );
+                SCM::Manual
+            }
+        }
+    }
+
     pub fn is_manual(&self) -> bool {
         matches!(self, SCM::Manual)
     }