perf: Reuse git root from worktree detection in SCM::new

The worktree detection call (git rev-parse --show-toplevel --git-common-dir)
now also queries --show-cdup in the same subprocess. The resolved git root
is stored on WorktreeInfo and threaded through CacheDirResult → Opts →
RunBuilder, so SCM::new can skip its own git rev-parse subprocess entirely.

This eliminates one fork+exec (~30ms) from the critical path.

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,
         })
     }
 }

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-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)
     }

crates/turborepo-scm/src/worktree.rs

@@ -18,6 +18,9 @@ pub struct WorktreeInfo {
     pub worktree_root: AbsoluteSystemPathBuf,
     /// The root of the main worktree
     pub main_worktree_root: AbsoluteSystemPathBuf,
+    /// The root of the git repository (resolved from `--show-cdup`).
+    /// Captured here to avoid a redundant subprocess in `SCM::new`.
+    pub git_root: AbsoluteSystemPathBuf,
 }
 
 impl WorktreeInfo {
@@ -41,17 +44,22 @@ impl WorktreeInfo {
     /// - The worktree structure cannot be determined
     #[tracing::instrument]
     pub fn detect(path: &AbsoluteSystemPath) -> Result<Self, Error> {
-        // Single git subprocess for both queries instead of two separate calls.
+        // Single git subprocess for all three queries. --show-cdup is included
+        // so that SCM::new can reuse the git root without spawning another
+        // subprocess later.
         let output = Command::new("git")
-            .args(["rev-parse", "--show-toplevel", "--git-common-dir"])
+            .args([
+                "rev-parse",
+                "--show-toplevel",
+                "--git-common-dir",
+                "--show-cdup",
+            ])
             .current_dir(path)
             .output()?;
 
         if !output.status.success() {
             let stderr = String::from_utf8_lossy(&output.stderr);
-            return Err(Error::git_error(format!(
-                "git rev-parse --show-toplevel --git-common-dir failed: {stderr}"
-            )));
+            return Err(Error::git_error(format!("git rev-parse failed: {stderr}")));
         }
 
         let stdout = String::from_utf8(output.stdout)?;
@@ -69,11 +77,24 @@ impl WorktreeInfo {
             .trim()
             .to_string();
 
+        let show_cdup = lines
+            .next()
+            .ok_or_else(|| Error::git_error("git rev-parse --show-cdup produced no output"))?
+            .trim();
+        let git_root = if show_cdup.is_empty() {
+            // Empty --show-cdup means we're already at the git root
+            path.to_owned()
+        } else {
+            let resolved = path.as_std_path().join(show_cdup);
+            AbsoluteSystemPathBuf::try_from(resolved.as_path())?.to_realpath()?
+        };
+
         let main_worktree_root = resolve_main_worktree_root(path, &git_common_dir)?;
 
         Ok(Self {
             worktree_root,
             main_worktree_root,
+            git_root,
         })
     }
 }
@@ -158,6 +179,7 @@ mod tests {
 
         assert_eq!(info.worktree_root, repo_root);
         assert_eq!(info.main_worktree_root, repo_root);
+        assert_eq!(info.git_root, repo_root);
         assert!(!info.is_linked_worktree());
     }
 
@@ -208,6 +230,8 @@ mod tests {
 
         assert_eq!(info.worktree_root, repo_root);
         assert_eq!(info.main_worktree_root, repo_root);
+        // git_root should resolve to repo_root even when called from subdir
+        assert_eq!(info.git_root, repo_root);
         assert!(!info.is_linked_worktree());
     }