`git repack -A` (such as invoked by `git gc`) loosens unreachable objects from packfiles. `git maintenance`'s `loose-objects` task consolidates loose objects into a packfile. As neither process takes a lock or is otherwise aware of the existence of the other, there is a race condition: 1. `git repack -A` creates loose objects 2. `git maintenance`'s `loose-objects` task deletes those loose objects 3. `git repack -A` fails to find the loose objects it just created and aborts with `fatal: unable to add recent objects` I see this failure with regularity in a custom environment where high mutation volume repositories invoke `git maintenance run` with regularity (effectively in reaction to repo mutations). We have a Git housekeeping strategy that frequently invokes `git maintenance` with all but the `gc` task. On a ~daily frequency, we invoke `git gc` to purge accumulated garbage. This `git gc` frequently fails due to the aforementioned race condition since the long wall time of `git gc` practically guarantees a `git maintenance` would have been triggered since the repo is mutated with such high frequency. In my scenario, I believe we have a workaround by omitting `--task=loose-objects` from the frequent `git maintenance` invocation if there exists a `gc.pid` file. However, this is only a partial solution, as `git repack` and the `loose-objects` task aren't aware of each other. (I suppose running the `gc` maintenance task and relying on the maintenance lock file could also work. However, we're invoking `git gc` explicitly since `git maintenance` doesn't allow passing custom arguments through to `git gc`.) Gregory
