fix: Invalidate only when Git ignore sources change

[smasato]

Description

turbo watch treats every write to .git/config as a change to the repository's ignore state. The invalidation is unconditional, so writing a config key that has nothing to do with ignore rules flushes all watched globs and force-executes every task in the graph.

.git/config is watched because it can change core.excludesFile, and that coverage is correct. What is missing is a comparison: the watcher never checks whether the write actually changed anything it reads out of the config. This PR defers the decision to the refresh that the same event already selects, so a config write invalidates consumers only when the resolved set of ignore sources differs.

Reproduction

mkdir -p repro/packages/a repro/packages/b && cd repro

cat > package.json <<'JSON'
{
  "name": "repro-root",
  "private": true,
  "workspaces": ["packages/*"],
  "packageManager": "npm@11.16.0",
  "devDependencies": { "turbo": "2.10.8-canary.4" }
}
JSON

cat > turbo.json <<'JSON'
{
  "$schema": "https://turborepo.com/schema.json",
  "tasks": { "dev": { "cache": false, "persistent": true } }
}
JSON

for p in a b; do
  cat > "packages/$p/package.json" <<JSON
{ "name": "pkg-$p", "version": "0.0.0", "scripts": { "dev": "node -e \"console.log('pkg-$p dev started at '+new Date().toISOString()); setInterval(()=>{},1e9)\"" } }
JSON
  echo "console.log('$p');" > "packages/$p/index.js"
done

printf 'node_modules\n.turbo\n' > .gitignore
git init -q . && git add -A && git commit -qm init
npm install

npx turbo watch dev --ui=stream

With turbo watch dev running, from another shell in the same repository:

git config foo.bar 1

Expected behavior

foo.bar does not affect Git's ignore rules, so nothing about the watched file set changed and no task re-runs.

Actual behavior

Every write to .git/config invalidates all globs and force-executes every task:

 WARNING  encountered filewatching error, flushing all globs: Git index or exclude state changed
 ERROR  file event error: NotifyError { error: Error { kind: Generic("Git index or exclude state changed"), paths: [] }, invalidation: true }
pkg-a:dev: cache bypass, force executing f28ac356e48a93e6
pkg-b:dev: cache bypass, force executing b99eb5e3ec09a157
pkg-a:dev: pkg-a dev started at 2026-08-01T06:09:43.928Z
pkg-b:dev: pkg-b dev started at 2026-08-01T06:09:43.927Z

Two controls were run in the same session:

• Appending a line to the tracked file packages/a/index.js: no task restarts. dev is persistent and not interruptible, so this is the expected behavior — and it shows that an unrelated config write restarts tasks that a real source change deliberately does not.
• git config core.excludesFile <path>: invalidation and restart. This is correct; the ignore rules did change.

Measured on 2.10.7 and 2.10.8-canary.4; five out of five unrelated git config writes restarted both persistent tasks in each run.

Cause

.git/config and .git/config.worktree are registered as Git control paths, with a comment noting that they are watched because they can change core.excludesFile:

turborepo/crates/turborepo-filewatch/src/repository_ignore.rs

Lines 230 to 246 in c6fbc97

	fn control_paths(&self, root: &Path) -> HashSet<PathBuf> {
	let mut paths = HashSet::new();
	paths.extend(self.index.iter().cloned());
	paths.extend(self.info_exclude.iter().cloned());
	paths.extend(self.global_exclude.iter().cloned());
	// These files can change core.excludesFile. They are also useful
	// controls in linked worktrees, where the administrative directory is
	// outside the worktree.
	paths.extend(git_path(root, "config"));
	paths.extend(git_path(root, "config.worktree"));
	paths.extend(
	directories_between(&self.worktree_root, root)
	.into_iter()
	.map(|directory| directory.join(".gitignore")),
	);
	paths
	}

invalidates_consumers returns true for every control path except the index, so any event on a config file is reported as requiring conservative invalidation:

turborepo/crates/turborepo-filewatch/src/repository_ignore.rs

Lines 117 to 139 in c6fbc97

	/// Returns whether changing `path` requires conservative invalidation.
	///
	/// Ignore files inside the Turbo root are ordinary filesystem inputs: once
	/// the snapshot is refreshed, consumers can apply their normal scoped
	/// semantics to the event. An inherited ignore file cannot be represented
	/// by an in-root event (and may change the relevance of the root itself),
	/// so it must invalidate every consumer.
	pub fn invalidates_consumers(&self, path: &Path) -> bool {
	if self.is_control_path(path) {
	let path = normalize_event_path(&self.root, &self.match_root, path);
	return self
	.index_path
	.read()
	.unwrap_or_else(|poisoned| poisoned.into_inner())
	.as_ref()
	!= Some(&path);
	}
	if !Self::is_gitignore(path) {
	return false;
	}
	let path = normalize_event_path(&self.root, &self.match_root, path);
	!path.starts_with(self.match_root.as_path())
	}

Every route that classifies an event ORs that result into the invalidation decision, so the refresh cannot override it. WatchEventSender::send additionally short-circuits, and never refreshes at all:

turborepo/crates/turborepo-filewatch/src/lib.rs

Lines 444 to 470 in c6fbc97

	pub fn send(
	&self,
	event: Result<Event, NotifyError>,
	) -> Result<(), broadcast::error::SendError<Result<Event, NotifyError>>> {
	let git_control_changed =
	if let (Some(repository_ignore), Ok(event)) = (&self.repository_ignore, &event) {
	let invalidates = event
	.paths
	.iter()
	.any(|path| repository_ignore.invalidates_consumers(path));
	let refresh = event
	.paths
	.iter()
	.any(|path| repository_ignore.should_refresh(path));
	invalidates || (refresh && repository_ignore.refresh())
	} else {
	false
	};
	if git_control_changed {
	route_event(
	&self.registry,
	Err(NotifyError::invalidation(
	"Git index or exclude state changed",
	)),
	);
	return Ok(());
	}

In other words, the fact that a write happened is taken as evidence that the ignore rules changed; what the config now resolves to is never compared against what it resolved to before.

Fix

The index is already handled this way: an index event refreshes the snapshot, and refresh reports whether the tracked set changed in a way that matters for ignore relevance. The config files fit the same shape — their entire contribution is the set of ignore sources they name — so this PR groups them with the index:

• GitContext resolves the config paths once during discovery and exposes derived_controls: control paths whose contribution a refresh re-derives in full (the index, and the config files).
• invalidates_consumers no longer invalidates for those paths; they are left to the refresh that should_refresh already selects them for.
• refresh compares the resolved control paths before and after re-discovery. Changing, adding, or removing core.excludesFile changes that set. It also compares the effective worktree root so core.worktree changes invalidate even when the control-path set remains stable.\n- Refresh-derived state is published atomically under one lock, and refreshes are serialized before discovery so an older refresh cannot overwrite newer state.

Content changes to an exclude file (.git/info/exclude, the global excludes file) and to inherited .gitignore files are unaffected: those arrive as events on their own paths and still invalidate conservatively.

Tests

config_refresh_invalidates_only_when_ignore_sources_change in crates/turborepo-filewatch/src/repository_ignore.rs asserts that .git/config is a refresh trigger but not an invalidation trigger, that a write to an unrelated key reports no change, and that setting and then unsetting core.excludesFile both report a change and are reflected in is_relevant. Additional regressions verify that changing core.worktree invalidates consumers and that refresh serialization covers state discovery.

Validation

• cargo test -p turborepo-filewatch — 74 passed, 0 failed

• cargo clippy -p turborepo-filewatch --all-targets --all-features -- -D warnings

• cargo fmt --all -- --check

• The reproduction above, driven by a script that writes foo.bar five times, then edits a tracked source file, then sets core.excludesFile. Counted over the whole session:

  	2.10.7	2.10.8-canary.4	this branch
  flushing all globs after the 5 unrelated git config writes	10	10	0
  task restarts after those writes	5 rounds (both tasks each)	5 rounds	0
  flushing all globs after git config core.excludesFile	2	2	1
  task restarts after core.excludesFile	1 round	1 round	1 round
  task restarts after editing a tracked source file	0	0	0

Impact

Tools that persist state in .git/config are increasingly common. While such a tool is running, turbo watch restarts every persistent task on every write, which makes watch mode unusable alongside a development server. The reproduction uses git config foo.bar 1 because the key is irrelevant — any writer of an ignore-unrelated key produces the same result.

Testing Instructions

1. Build this branch and run the reproduction above with the built binary (turbo --skip-infer watch dev --ui=stream).
2. From another shell in the same repository, run git config foo.bar 1 a few times. No flushing all globs warning appears and no task re-runs.
3. Run git config core.excludesFile /tmp/globalignore. The invalidation and restart still happen.
4. cargo test -p turborepo-filewatch --lib

Environment

CLI:
   Version: 2.10.8-canary.4
   Package manager: npm

Platform:
   Architecture: aarch64
   Operating system: macos (26.5.2)
   Available memory (MB): 20214
   Available CPU cores: 12

Environment:
   Node.js version: v24.18.1
   git version 2.55.0

---

🤖 Generated with Claude Code

[vercel]

@smasato is attempting to deploy a commit to the Vercel Team on Vercel.

A member of the Team first needs to authorize it.

[anthonyshew]

Hi, thanks for reporting this and making a PR. I made a slight refactor in the interest of maintainability/correctness. Looks good, let's get this merged!

[smasato]

@anthonyshew thanks!