git: notes on large repositories

Git reopened cached directories even after confirming they contained no untracked files.

Reuse cached empty directories after confirming that their contents and ignore rules have not changed. A modified .gitignore still triggers the normal directory checks.

Git decoded its cache-tree and untracked-cache index extensions one after the other.

Decode the two independent extensions in parallel when enough index workers are available. Use the additional worker only for large extensions and leave split-index assembly unaffected.

Linked worktrees could ask the wrong filesystem-monitor daemon for change history.

Associate each daemon query with the correct worktree before using its results. Check both the canonical worktree path and its filesystem identity so linked checkouts cannot share the wrong history.

A changed directory could leave outdated .gitattributes rules cached.

Refresh cached attributes when a filesystem-monitor event affects tracked files in that directory. Unrelated directory events keep their existing fallback behavior.

Files could change while git status was scanning the worktree.

Check the filesystem monitor again after the scan so changes during the scan are not missed. If the monitor reports an intervening edit, repeat the affected scan instead of trusting the earlier result.

A cached clean status becomes invalid when relevant Git configuration changes.

Track settings that affect status and file conversion, and discard cached results when those settings change. Keep unrelated configuration changes from invalidating an otherwise usable result.

Global, system, and repository attributes can change how Git interprets tracked files.

Track those attribute files and their locations before reusing an earlier status result. Include missing files and replaced directories so a changed attribute source cannot go unnoticed.

An external attributes file could be replaced between its initial check and the later status scan.

Use the same snapshot of external attributes throughout the scan. This prevents Git from checking the index against one set of rules and collecting status against another.

A pre-commit hook can modify a tracked file after Git has already refreshed its index.

Check the filesystem monitor again after the hook so later status does not reuse stale results. This also catches edits that preserve the file's size and modification time.

A directory or worktree root can be replaced while an APFS scan is running.

Pause the scan, replace either a child directory or the worktree root, and confirm Git rejects the collected results. Normal status then falls back to a fresh filesystem scan.

A bulk scan already detects deleted files and size changes that git status otherwise checks again.

Reuse already detected deletions and size changes instead of rediscovering them later. Continue inspecting files whose metadata changed without clearly establishing whether their contents changed.

Git allocated memory for ignore and attribute files before rejecting files larger than 100 MiB.

Check file size before allocation to avoid wasted memory and allocation failures. Preserve the existing warning and retain the later size check for inputs read from the index.

Git status walked the worktree twice: once during APFS preload and again to find untracked files.

Reuse untracked-file results from the completed scan when the same ignore rules still apply. Keep the ordinary directory walk for changed ignore files, nested repositories, and unsupported reporting modes.

Linux needed one backend to coordinate bulk filesystem scans and their safety checks.

Combine directory enumeration, file metadata, anchored opens, and filesystem checks before accepting scan results. Limit the fast path to supported Linux filesystems and fall back when a required system feature is missing.

Git rechecked unchanged file contents because refreshed metadata was not written back to the index.

Update index metadata after a successful content check when Git holds the index lock. Later status runs can then trust the refreshed file information instead of reading the same contents again.

Bulk content checks could be invalidated by concurrent changes before the closing filesystem-monitor query.

Retain provisional clean states and index updates until the provider confirms the same proof epoch, then publish them only after revalidating pending paths. Provider failure or epoch changes fall back to a complete refresh.

Scoped status queries repeated work even when a root-wide clean proof already covered the requested paths.

Reuse closed clean-status and untracked-cache proofs for eligible literal path queries. Preserve ordinary invalidation for changed exclusions, complex pathspecs, sparse indexes, and unsupported directories.

Scoped status reuse needed regression coverage across root and nested working directories.

Exercise repeated tracked-directory queries after filesystem monitoring closes the selected untracked-cache subtree. Verify scoped results stay correct, avoid directory walks, preserve the index, and reject later root-wide ignore invalidation.