diff --git a/crates/worktree/src/worktree.rs b/crates/worktree/src/worktree.rs
index dc1f208fac..974219bf9b 100644
--- a/crates/worktree/src/worktree.rs
+++ b/crates/worktree/src/worktree.rs
@@ -3964,19 +3964,22 @@ impl BackgroundScanner {
         let repo = if scanning_enabled {
             let (ignores, exclude, repo) =
                 discover_ancestor_git_repo(self.fs.clone(), &root_abs_path).await;
-            self.state
-                .lock()
-                .await
-                .snapshot
-                .ignores_by_parent_abs_path
-                .extend(ignores);
+            let mut state = self.state.lock().await;
+            state.snapshot.ignores_by_parent_abs_path.extend(ignores);
             if let Some(exclude) = exclude {
-                self.state
-                    .lock()
-                    .await
+                let work_directory_abs_path: Arc<Path> = repo
+                    .as_ref()
+                    .map(|(_, work_directory)| {
+                        state
+                            .snapshot
+                            .work_directory_abs_path(work_directory)
+                            .into()
+                    })
+                    .unwrap_or_else(|| root_abs_path.as_path().into());
+                state
                     .snapshot
                     .repo_exclude_by_work_dir_abs_path
-                    .insert(root_abs_path.as_path().into(), (exclude, false));
+                    .insert(work_directory_abs_path, (exclude, false));
             }
 
             repo
@@ -5078,12 +5081,8 @@ impl BackgroundScanner {
                         state.snapshot.ignores_by_parent_abs_path.extend(ignores);
                         if let Some((ancestor_dot_git, work_directory)) = repo {
                             if let Some(exclude) = exclude {
-                                let work_directory_abs_path = self
-                                    .state
-                                    .lock()
-                                    .await
-                                    .snapshot
-                                    .work_directory_abs_path(&work_directory);
+                                let work_directory_abs_path =
+                                    state.snapshot.work_directory_abs_path(&work_directory);
 
                                 state
                                     .snapshot
@@ -5201,7 +5200,11 @@ impl BackgroundScanner {
 
                 if *needs_update {
                     *needs_update = false;
-                    ignores_to_update.push(work_dir_abs_path.clone());
+                    if work_dir_abs_path.starts_with(abs_path.as_path()) {
+                        ignores_to_update.push(work_dir_abs_path.clone());
+                    } else {
+                        ignores_to_update.push(abs_path.as_path().into());
+                    }
 
                     if let Some((_, repository)) = repository {
                         let exclude_abs_path = repository.common_dir_abs_path.join(REPO_EXCLUDE);
@@ -5543,39 +5546,45 @@ async fn discover_ancestor_git_repo(
             .await
             .is_ok_and(|metadata| metadata.is_some())
         {
-            if index != 0 {
+            let dot_git_abs_path = if index != 0 {
                 // We canonicalize, since the FS events use the canonicalized path.
-                if let Some(ancestor_dot_git) = fs.canonicalize(&ancestor_dot_git).await.log_err() {
-                    let location_in_repo = root_abs_path
-                        .as_path()
-                        .strip_prefix(ancestor)
-                        .unwrap()
-                        .into();
-                    log::info!("inserting parent git repo for this worktree: {location_in_repo:?}");
-                    // We associate the external git repo with our root folder and
-                    // also mark where in the git repo the root folder is located.
-                    return (
-                        ignores,
-                        exclude,
-                        Some((
-                            ancestor_dot_git,
-                            WorkDirectory::AboveProject {
-                                absolute_path: ancestor.into(),
-                                location_in_repo,
-                            },
-                        )),
-                    );
-                };
-            }
+                match fs.canonicalize(&ancestor_dot_git).await.log_err() {
+                    Some(path) => path,
+                    None => continue,
+                }
+            } else {
+                ancestor_dot_git.clone()
+            };
+            let dot_git_abs_path: Arc<Path> = dot_git_abs_path.as_path().into();
+            let (_, common_dir_abs_path) = discover_git_paths(&dot_git_abs_path, fs.as_ref()).await;
 
-            let dot_git_path: Arc<Path> = ancestor_dot_git.into();
-            let (_, common_dir_abs_path) = discover_git_paths(&dot_git_path, fs.as_ref()).await;
             let repo_exclude_abs_path = common_dir_abs_path.join(REPO_EXCLUDE);
             if let Ok(repo_exclude) = build_gitignore(&repo_exclude_abs_path, fs.as_ref()).await {
                 exclude = Some(Arc::new(repo_exclude));
             }
 
-            // Reached root of git repository.
+            if index != 0 {
+                let location_in_repo = root_abs_path
+                    .as_path()
+                    .strip_prefix(ancestor)
+                    .unwrap()
+                    .into();
+                log::info!("inserting parent git repo for this worktree: {location_in_repo:?}");
+                // We associate the external git repo with our root folder and
+                // also mark where in the git repo the root folder is located.
+                return (
+                    ignores,
+                    exclude,
+                    Some((
+                        dot_git_abs_path.as_ref().into(),
+                        WorkDirectory::AboveProject {
+                            absolute_path: ancestor.into(),
+                            location_in_repo,
+                        },
+                    )),
+                );
+            }
+
             break;
         }
     }
@@ -6285,6 +6294,26 @@ fn parse_gitfile(content: &str) -> anyhow::Result<&Path> {
     Ok(Path::new(path.trim()))
 }
 
+fn resolve_gitfile_path(dot_git_abs_path: &Path, gitfile_path: &Path) -> PathBuf {
+    if gitfile_path.is_absolute() {
+        gitfile_path.into()
+    } else {
+        dot_git_abs_path
+            .parent()
+            .unwrap_or_else(|| Path::new(""))
+            .join(gitfile_path)
+    }
+}
+
+fn resolve_commondir_path(repository_dir_abs_path: &Path, commondir_path: &str) -> PathBuf {
+    let commondir_path = Path::new(commondir_path.trim());
+    if commondir_path.is_absolute() {
+        commondir_path.into()
+    } else {
+        repository_dir_abs_path.join(commondir_path)
+    }
+}
+
 pub async fn discover_root_repo_common_dir(root_abs_path: &Path, fs: &dyn Fs) -> Option<Arc<Path>> {
     let root_dot_git = root_abs_path.join(DOT_GIT);
     if !fs.metadata(&root_dot_git).await.is_ok_and(|m| m.is_some()) {
@@ -6306,17 +6335,14 @@ async fn discover_git_paths(dot_git_abs_path: &Arc<Path>, fs: &dyn Fs) -> (Arc<P
         .as_ref()
         .and_then(|contents| parse_gitfile(contents).log_err())
     {
-        let path = dot_git_abs_path
-            .parent()
-            .unwrap_or(Path::new(""))
-            .join(path);
+        let path = resolve_gitfile_path(dot_git_abs_path, path);
         if let Some(path) = fs.canonicalize(&path).await.log_err() {
             repository_dir_abs_path = Path::new(&path).into();
             common_dir_abs_path = repository_dir_abs_path.clone();
 
             if let Some(commondir_contents) = fs.load(&path.join("commondir")).await.ok()
                 && let Some(commondir_path) = fs
-                    .canonicalize(&path.join(commondir_contents.trim()))
+                    .canonicalize(&resolve_commondir_path(&path, &commondir_contents))
                     .await
                     .log_err()
             {
diff --git a/crates/worktree/tests/integration/main.rs b/crates/worktree/tests/integration/main.rs
index 7ea63f878c..87eb0fe308 100644
--- a/crates/worktree/tests/integration/main.rs
+++ b/crates/worktree/tests/integration/main.rs
@@ -1220,15 +1220,17 @@ async fn test_file_scan_inclusions(cx: &mut TestAppContext) {
         // Assert that file_scan_inclusions overrides  file_scan_exclusions.
         check_worktree_entries(
             tree,
-            &[],
-            &["target", "node_modules"],
-            &["src/lib.rs", "src/bar/bar.rs", ".gitignore"],
-            &[
-                "node_modules/prettier/package.json",
-                ".DS_Store",
-                "node_modules/.DS_Store",
-                "src/.DS_Store",
-            ],
+            WorktreeExpectations {
+                excluded_paths: &[],
+                ignored_paths: &["target", "node_modules"],
+                tracked_paths: &["src/lib.rs", "src/bar/bar.rs", ".gitignore"],
+                included_paths: &[
+                    "node_modules/prettier/package.json",
+                    ".DS_Store",
+                    "node_modules/.DS_Store",
+                    "src/.DS_Store",
+                ],
+            },
         )
     });
 }
@@ -1287,10 +1289,12 @@ async fn test_file_scan_exclusions_overrules_inclusions(cx: &mut TestAppContext)
         // Assert that file_scan_inclusions overrides  file_scan_exclusions.
         check_worktree_entries(
             tree,
-            &[".DS_Store, src/.DS_Store"],
-            &["target", "node_modules"],
-            &["src/foo/another.rs", "src/foo/foo.rs", ".gitignore"],
-            &[],
+            WorktreeExpectations {
+                excluded_paths: &[".DS_Store, src/.DS_Store"],
+                ignored_paths: &["target", "node_modules"],
+                tracked_paths: &["src/foo/another.rs", "src/foo/foo.rs", ".gitignore"],
+                included_paths: &[],
+            },
         )
     });
 }
@@ -1433,16 +1437,18 @@ async fn test_file_scan_exclusions(cx: &mut TestAppContext) {
     tree.read_with(cx, |tree, _| {
         check_worktree_entries(
             tree,
-            &[
-                "src/foo/foo.rs",
-                "src/foo/another.rs",
-                "node_modules/.DS_Store",
-                "src/.DS_Store",
-                ".DS_Store",
-            ],
-            &["target", "node_modules"],
-            &["src/lib.rs", "src/bar/bar.rs", ".gitignore"],
-            &[],
+            WorktreeExpectations {
+                excluded_paths: &[
+                    "src/foo/foo.rs",
+                    "src/foo/another.rs",
+                    "node_modules/.DS_Store",
+                    "src/.DS_Store",
+                    ".DS_Store",
+                ],
+                ignored_paths: &["target", "node_modules"],
+                tracked_paths: &["src/lib.rs", "src/bar/bar.rs", ".gitignore"],
+                included_paths: &[],
+            },
         )
     });
 
@@ -1459,22 +1465,24 @@ async fn test_file_scan_exclusions(cx: &mut TestAppContext) {
     tree.read_with(cx, |tree, _| {
         check_worktree_entries(
             tree,
-            &[
-                "node_modules/prettier/package.json",
-                "node_modules/.DS_Store",
-                "node_modules",
-            ],
-            &["target"],
-            &[
-                ".gitignore",
-                "src/lib.rs",
-                "src/bar/bar.rs",
-                "src/foo/foo.rs",
-                "src/foo/another.rs",
-                "src/.DS_Store",
-                ".DS_Store",
-            ],
-            &[],
+            WorktreeExpectations {
+                excluded_paths: &[
+                    "node_modules/prettier/package.json",
+                    "node_modules/.DS_Store",
+                    "node_modules",
+                ],
+                ignored_paths: &["target"],
+                tracked_paths: &[
+                    ".gitignore",
+                    "src/lib.rs",
+                    "src/bar/bar.rs",
+                    "src/foo/foo.rs",
+                    "src/foo/another.rs",
+                    "src/.DS_Store",
+                    ".DS_Store",
+                ],
+                included_paths: &[],
+            },
         )
     });
 }
@@ -1628,25 +1636,27 @@ async fn test_fs_events_in_exclusions(cx: &mut TestAppContext) {
     tree.read_with(cx, |tree, _| {
         check_worktree_entries(
             tree,
-            &[
-                ".git/HEAD",
-                ".git/foo",
-                "node_modules",
-                "node_modules/.DS_Store",
-                "node_modules/prettier",
-                "node_modules/prettier/package.json",
-            ],
-            &["target"],
-            &[
-                ".DS_Store",
-                "src/.DS_Store",
-                "src/lib.rs",
-                "src/foo/foo.rs",
-                "src/foo/another.rs",
-                "src/bar/bar.rs",
-                ".gitignore",
-            ],
-            &[],
+            WorktreeExpectations {
+                excluded_paths: &[
+                    ".git/HEAD",
+                    ".git/foo",
+                    "node_modules",
+                    "node_modules/.DS_Store",
+                    "node_modules/prettier",
+                    "node_modules/prettier/package.json",
+                ],
+                ignored_paths: &["target"],
+                tracked_paths: &[
+                    ".DS_Store",
+                    "src/.DS_Store",
+                    "src/lib.rs",
+                    "src/foo/foo.rs",
+                    "src/foo/another.rs",
+                    "src/bar/bar.rs",
+                    ".gitignore",
+                ],
+                included_paths: &[],
+            },
         )
     });
 
@@ -1683,31 +1693,33 @@ async fn test_fs_events_in_exclusions(cx: &mut TestAppContext) {
     tree.read_with(cx, |tree, _| {
         check_worktree_entries(
             tree,
-            &[
-                ".git/HEAD",
-                ".git/foo",
-                ".git/new_file",
-                "node_modules",
-                "node_modules/.DS_Store",
-                "node_modules/prettier",
-                "node_modules/prettier/package.json",
-                "node_modules/new_file",
-                "build_output",
-                "build_output/new_file",
-                "test_output/new_file",
-            ],
-            &["target", "test_output"],
-            &[
-                ".DS_Store",
-                "src/.DS_Store",
-                "src/lib.rs",
-                "src/foo/foo.rs",
-                "src/foo/another.rs",
-                "src/bar/bar.rs",
-                "src/new_file",
-                ".gitignore",
-            ],
-            &[],
+            WorktreeExpectations {
+                excluded_paths: &[
+                    ".git/HEAD",
+                    ".git/foo",
+                    ".git/new_file",
+                    "node_modules",
+                    "node_modules/.DS_Store",
+                    "node_modules/prettier",
+                    "node_modules/prettier/package.json",
+                    "node_modules/new_file",
+                    "build_output",
+                    "build_output/new_file",
+                    "test_output/new_file",
+                ],
+                ignored_paths: &["target", "test_output"],
+                tracked_paths: &[
+                    ".DS_Store",
+                    "src/.DS_Store",
+                    "src/lib.rs",
+                    "src/foo/foo.rs",
+                    "src/foo/another.rs",
+                    "src/bar/bar.rs",
+                    "src/new_file",
+                    ".gitignore",
+                ],
+                included_paths: &[],
+            },
         )
     });
 }
@@ -1739,14 +1751,26 @@ async fn test_fs_events_in_dot_git_worktree(cx: &mut TestAppContext) {
         .await;
     tree.flush_fs_events(cx).await;
     tree.read_with(cx, |tree, _| {
-        check_worktree_entries(tree, &[], &["HEAD", "foo"], &[], &[])
+        check_worktree_entries(
+            tree,
+            WorktreeExpectations {
+                ignored_paths: &["HEAD", "foo"],
+                ..Default::default()
+            },
+        )
     });
 
     std::fs::write(dot_git_worktree_dir.join("new_file"), "new file contents")
         .unwrap_or_else(|e| panic!("Failed to create in {dot_git_worktree_dir:?} a new file: {e}"));
     tree.flush_fs_events(cx).await;
     tree.read_with(cx, |tree, _| {
-        check_worktree_entries(tree, &[], &["HEAD", "foo", "new_file"], &[], &[])
+        check_worktree_entries(
+            tree,
+            WorktreeExpectations {
+                ignored_paths: &["HEAD", "foo", "new_file"],
+                ..Default::default()
+            },
+        )
     });
 }
 
@@ -2785,10 +2809,11 @@ async fn test_global_gitignore(executor: BackgroundExecutor, cx: &mut TestAppCon
     worktree.update(cx, |worktree, _cx| {
         check_worktree_entries(
             worktree,
-            &[],
-            &["foo", "bar", "subrepo/bar"],
-            &["sub/bar", "baz"],
-            &[],
+            WorktreeExpectations {
+                ignored_paths: &["foo", "bar", "subrepo/bar"],
+                tracked_paths: &["sub/bar", "baz"],
+                ..Default::default()
+            },
         );
     });
 
@@ -2809,10 +2834,11 @@ async fn test_global_gitignore(executor: BackgroundExecutor, cx: &mut TestAppCon
     worktree.update(cx, |worktree, _cx| {
         check_worktree_entries(
             worktree,
-            &[],
-            &["bar", "subrepo/bar"],
-            &["foo", "sub/bar", "baz"],
-            &[],
+            WorktreeExpectations {
+                ignored_paths: &["bar", "subrepo/bar"],
+                tracked_paths: &["foo", "sub/bar", "baz"],
+                ..Default::default()
+            },
         );
     });
 
@@ -2836,10 +2862,11 @@ async fn test_global_gitignore(executor: BackgroundExecutor, cx: &mut TestAppCon
     worktree.update(cx, |worktree, _cx| {
         check_worktree_entries(
             worktree,
-            &[],
-            &["bar"],
-            &["foo", "sub/bar", "baz", "subrepo/bar"],
-            &[],
+            WorktreeExpectations {
+                ignored_paths: &["bar"],
+                tracked_paths: &["foo", "sub/bar", "baz", "subrepo/bar"],
+                ..Default::default()
+            },
         );
     });
 }
@@ -2899,17 +2926,13 @@ async fn test_repo_exclude_in_worktree(executor: BackgroundExecutor, cx: &mut Te
 
     // .env.local should be ignored via info/exclude from the repo's exclude
     worktree.update(cx, |worktree, _cx| {
-        let expected_excluded_paths = [];
-        let expected_ignored_paths = [".env.local"];
-        let expected_tracked_paths = ["not-ignored.txt"];
-        let expected_included_paths = [];
-
         check_worktree_entries(
             worktree,
-            &expected_excluded_paths,
-            &expected_ignored_paths,
-            &expected_tracked_paths,
-            &expected_included_paths,
+            WorktreeExpectations {
+                ignored_paths: &[".env.local"],
+                tracked_paths: &["not-ignored.txt"],
+                ..Default::default()
+            },
         );
     });
 }
@@ -2959,17 +2982,13 @@ async fn test_repo_exclude(executor: BackgroundExecutor, cx: &mut TestAppContext
 
     // .gitignore overrides .git/info/exclude
     worktree.update(cx, |worktree, _cx| {
-        let expected_excluded_paths = [];
-        let expected_ignored_paths = [".env.local"];
-        let expected_tracked_paths = [".env.example", "README.md", "src/main.rs"];
-        let expected_included_paths = [];
-
         check_worktree_entries(
             worktree,
-            &expected_excluded_paths,
-            &expected_ignored_paths,
-            &expected_tracked_paths,
-            &expected_included_paths,
+            WorktreeExpectations {
+                ignored_paths: &[".env.local"],
+                tracked_paths: &[".env.example", "README.md", "src/main.rs"],
+                ..Default::default()
+            },
         );
     });
 
@@ -2988,37 +3007,34 @@ async fn test_repo_exclude(executor: BackgroundExecutor, cx: &mut TestAppContext
     cx.run_until_parked();
 
     worktree.update(cx, |worktree, _cx| {
-        let expected_excluded_paths = [];
-        let expected_ignored_paths = [];
-        let expected_tracked_paths = [".env.example", ".env.local", "README.md", "src/main.rs"];
-        let expected_included_paths = [];
-
         check_worktree_entries(
             worktree,
-            &expected_excluded_paths,
-            &expected_ignored_paths,
-            &expected_tracked_paths,
-            &expected_included_paths,
+            WorktreeExpectations {
+                tracked_paths: &[".env.example", ".env.local", "README.md", "src/main.rs"],
+                ..Default::default()
+            },
         );
     });
 }
 
+#[derive(Default)]
+struct WorktreeExpectations {
+    excluded_paths: &'static [&'static str],
+    ignored_paths: &'static [&'static str],
+    tracked_paths: &'static [&'static str],
+    included_paths: &'static [&'static str],
+}
+
 #[track_caller]
-fn check_worktree_entries(
-    tree: &Worktree,
-    expected_excluded_paths: &[&str],
-    expected_ignored_paths: &[&str],
-    expected_tracked_paths: &[&str],
-    expected_included_paths: &[&str],
-) {
-    for path in expected_excluded_paths {
+fn check_worktree_entries(tree: &Worktree, expectations: WorktreeExpectations) {
+    for path in expectations.excluded_paths {
         let entry = tree.entry_for_path(rel_path(path));
         assert!(
             entry.is_none(),
             "expected path '{path}' to be excluded, but got entry: {entry:?}",
         );
     }
-    for path in expected_ignored_paths {
+    for path in expectations.ignored_paths {
         let entry = tree
             .entry_for_path(rel_path(path))
             .unwrap_or_else(|| panic!("Missing entry for expected ignored path '{path}'"));
@@ -3027,7 +3043,7 @@ fn check_worktree_entries(
             "expected path '{path}' to be ignored, but got entry: {entry:?}",
         );
     }
-    for path in expected_tracked_paths {
+    for path in expectations.tracked_paths {
         let entry = tree
             .entry_for_path(rel_path(path))
             .unwrap_or_else(|| panic!("Missing entry for expected tracked path '{path}'"));
@@ -3036,7 +3052,7 @@ fn check_worktree_entries(
             "expected path '{path}' to be tracked, but got entry: {entry:?}",
         );
     }
-    for path in expected_included_paths {
+    for path in expectations.included_paths {
         let entry = tree
             .entry_for_path(rel_path(path))
             .unwrap_or_else(|| panic!("Missing entry for expected included path '{path}'"));
@@ -3047,6 +3063,134 @@ fn check_worktree_entries(
     }
 }
 
+#[gpui::test]
+async fn test_root_repo_common_dir_for_relative_gitdir(
+    executor: BackgroundExecutor,
+    cx: &mut TestAppContext,
+) {
+    init_test(cx);
+
+    let fs = FakeFs::new(executor);
+    fs.insert_tree(
+        path!("/repo"),
+        json!({
+            ".git": {
+                "HEAD": "ref: refs/heads/main",
+                "config": "[core]\n\tbare = false\n",
+                "info": {
+                    "exclude": "ignored.txt\n",
+                },
+                "worktrees": {
+                    "feature-a": {
+                        "HEAD": "ref: refs/heads/feature-a",
+                        "commondir": "../..",
+                        "gitdir": "/repo/feature-a/.git",
+                    },
+                },
+            },
+            "feature-a": {
+                ".git": "gitdir: ../.git/worktrees/feature-a",
+                "file.txt": "content",
+                "ignored.txt": "ignored",
+                "subdir": {
+                    "file.txt": "content",
+                    "ignored.txt": "ignored",
+                },
+            },
+        }),
+    )
+    .await;
+
+    let feature_tree = Worktree::local(
+        path!("/repo/feature-a").as_ref(),
+        true,
+        fs.clone(),
+        Arc::default(),
+        true,
+        WorktreeId::from_proto(0),
+        &mut cx.to_async(),
+    )
+    .await
+    .unwrap();
+    feature_tree
+        .update(cx, |tree, _| tree.as_local().unwrap().scan_complete())
+        .await;
+    cx.run_until_parked();
+
+    feature_tree.read_with(cx, |tree, _| {
+        assert_eq!(
+            tree.snapshot()
+                .root_repo_common_dir()
+                .map(|path| path.as_ref()),
+            Some(Path::new(path!("/repo/.git"))),
+        );
+        check_worktree_entries(
+            tree,
+            WorktreeExpectations {
+                ignored_paths: &["ignored.txt"],
+                tracked_paths: &["file.txt"],
+                ..Default::default()
+            },
+        );
+    });
+
+    let nested_tree = Worktree::local(
+        path!("/repo/feature-a/subdir").as_ref(),
+        true,
+        fs.clone(),
+        Arc::default(),
+        true,
+        WorktreeId::from_proto(1),
+        &mut cx.to_async(),
+    )
+    .await
+    .unwrap();
+    nested_tree
+        .update(cx, |tree, _| tree.as_local().unwrap().scan_complete())
+        .await;
+    cx.run_until_parked();
+
+    nested_tree.read_with(cx, |tree, _| {
+        check_worktree_entries(
+            tree,
+            WorktreeExpectations {
+                ignored_paths: &["ignored.txt"],
+                tracked_paths: &["file.txt"],
+                ..Default::default()
+            },
+        );
+    });
+
+    fs.write(
+        Path::new(path!("/repo/.git")).join(REPO_EXCLUDE).as_ref(),
+        "file.txt\n".as_bytes(),
+    )
+    .await
+    .unwrap();
+    cx.run_until_parked();
+
+    feature_tree.read_with(cx, |tree, _| {
+        check_worktree_entries(
+            tree,
+            WorktreeExpectations {
+                ignored_paths: &["file.txt", "subdir/file.txt"],
+                tracked_paths: &["ignored.txt", "subdir/ignored.txt"],
+                ..Default::default()
+            },
+        );
+    });
+    nested_tree.read_with(cx, |tree, _| {
+        check_worktree_entries(
+            tree,
+            WorktreeExpectations {
+                ignored_paths: &["file.txt"],
+                tracked_paths: &["ignored.txt"],
+                ..Default::default()
+            },
+        );
+    });
+}
+
 #[gpui::test]
 async fn test_root_repo_common_dir(executor: BackgroundExecutor, cx: &mut TestAppContext) {
     init_test(cx);