[BUG] push resends common history after repack during pre-push (2.54.0, 2.56.0)

Hello Git developers,

A push can resend common history if its pre-push hook repacks the local object database and removes previously loose common objects. I reproduced this with Apple Git 2.54.0 (Apple Git-157) and an unmodified build of the current upstream Git 2.56.0 release on macOS 27.0 / arm64.

The attached inline Python script creates fresh local repositories, seeds a bare receiver with a deterministic, incompressible 4-MiB historical blob, and pushes one tiny text-file commit. The common base is initially loose. The receiver uses receive.unpackLimit=1 so the added pack is measurable. Each case starts from a separate fresh repository pair. All pushes succeed and the receiver ends at the expected tip.

Observed added receiver pack sizes, in bytes:

                        Apple Git 2.54.0    upstream Git 2.56.0
  no hook                      300                  300
  repack in pre-push      4,196,026            4,196,026
  repack + negotiate     4,196,026            4,196,026

The repacking hook is simply:

  #!/bin/sh
  set -eu
  cat >/dev/null
  git repack -adq
  git prune-packed

Expected: the already-advertised common history should still be excluded
when its storage moves from loose objects to a newly created pack.
Actual: the historical blob is transmitted again. The receiver stores a
new pack roughly the size of the historical blob. Enabling
push.negotiate=true does not prevent the redundant transfer in this test.

Possible mechanism, based on source inspection:

In 2.54.0, send-pack.c:feed_object() drops negative OIDs when odb_has_object(..., 0) returns false. In 2.56.0, the same quick check is in append_negative_object(). In both versions, odb_has_object() uses OBJECT_INFO_QUICK unless ODB_HAS_OBJECT_RECHECK_PACKED is set. A parent process with a stale pack catalogue may therefore miss the base after the hook removes the loose copy; the fresh pack generator then sees the new pack and walks history without that excluded base. This is a proposed explanation of the measured effect, not an instrumented proof of the parent process's in-memory state.

Relevant release source: https://github.com/git/git/blob/v2.54.0/send-pack.c https://github.com/git/git/blob/v2.56.0/send-pack.c https://github.com/git/git/blob/v2.56.0/odb.c

The upstream 2.56.0 binary was built from the kernel.org release tarball with optional gettext, curl, Tcl/Tk, Perl, Python and Rust components disabled. Neither global Git configuration nor the installed system Git was changed. The script isolates system/global Git configuration and uses only local transport. Measurements are receiver pack-file sizes, rather than network-byte counters. A separate large-repository incident motivated this test, but this report includes only synthetic fixtures.

To reproduce, save the inline script as reproduce.py and run:

  python3 reproduce.py --git /path/to/git

For a Git binary built in-place, add:

  --exec-path /path/to/git/build/directory

The script requires Python 3 and Git; its default mode removes only its own temporary test repositories when the run completes. To retain all fixture repositories and push logs, pass --output with a new directory.

Minimal reproducer follows:

#!/usr/bin/env python3 """Reproduce redundant push history after loose objects move into a new pack.

Uses fresh local test repositories only. Requires Python 3 and Git.
Example: python3 reproduce.py --git /path/to/git --output /new/results/path
For an uninstalled Git build, add --exec-path /path/to/build/directory.
"""

import argparse import hashlib import json import os from pathlib import Path import platform import shutil import subprocess import tempfile import time

def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--git", default=shutil.which("git"))
    parser.add_argument("--exec-path")
    parser.add_argument("--output", type=Path)
    args = parser.parse_args()
    binary = str(Path(args.git).resolve())
    temporary = None
    if args.output:
        root = args.output.resolve()
        root.mkdir(parents=True, exist_ok=False)
    else:
        temporary = tempfile.TemporaryDirectory(prefix="git-push-repack-repro-")
        root = Path(temporary.name)

    env = {key: value for key, value in os.environ.items()
           if not key.startswith("GIT_")}
    env.update(GIT_CONFIG_NOSYSTEM="1", GIT_CONFIG_GLOBAL=os.devnull,
               GIT_AUTHOR_DATE="2001-01-01T00:00:00+0000",
               GIT_COMMITTER_DATE="2001-01-01T00:00:00+0000")
    env["PATH"] = str(Path(binary).parent) + os.pathsep + env.get("PATH", "")
    if args.exec_path:
        env["GIT_EXEC_PATH"] = str(Path(args.exec_path).resolve())

    def git(cwd, *words):
        return subprocess.run([binary, *words], cwd=cwd, env=env,
                              text=True, capture_output=True, check=True,
                              timeout=60)

    results = []
    for mode in ("no-hook", "repack", "repack-negotiate"):
        case = root / mode
        case.mkdir()
        repo, remote = case / "repo", case / "remote.git"
        git(case, "init", "-q", "-b", "main", str(repo))
        git(case, "init", "-q", "--bare", "-b", "main", str(remote))
        for key, value in (("user.name", "Git bug reproduction"),
                           ("user.email", "test@example.invalid"),
                           ("commit.gpgsign", "false"), ("gc.auto", "0"),
                           ("core.hooksPath", str(repo / ".git/hooks"))):
            git(repo, "config", key, value)
        git(remote, "config", "gc.auto", "0")
        git(remote, "config", "receive.unpackLimit", "1")
        (repo / "history.bin").write_bytes(
            hashlib.shake_256(b"historical fixture").digest(4 * 1024 * 1024))
        git(repo, "add", "--", "history.bin")
        git(repo, "commit", "-q", "-m", "historical seed", "--", "history.bin")
        base = git(repo, "rev-parse", "HEAD").stdout.strip()
        git(repo, "push", "-q", str(remote), "HEAD:refs/heads/main")
        (repo / "change.txt").write_text("tiny change\n")
        git(repo, "add", "--", "change.txt")
        git(repo, "commit", "-q", "-m", "tiny change", "--", "change.txt")
        tip = git(repo, "rev-parse", "HEAD").stdout.strip()
        assert (repo / ".git/objects" / base[:2] / base[2:]).is_file()
        if mode != "no-hook":
            hook = repo / ".git/hooks/pre-push"
            hook.parent.mkdir(parents=True, exist_ok=True)
            hook.write_text("#!/bin/sh\nset -eu\ncat >/dev/null\n"
                            "git repack -adq\ngit prune-packed\n")
            hook.chmod(0o700)
        before = set((remote / "objects/pack").glob("*.pack"))
        config = ["-c", "push.negotiate=true"] if mode ==
"repack-negotiate" else []
        start = time.monotonic()
        result = git(repo, *config, "push", "--progress", str(remote),
                     "HEAD:refs/heads/main")
        elapsed = time.monotonic() - start
        (case / "push.log").write_text(result.stdout + result.stderr)
        packs = set((remote / "objects/pack").glob("*.pack")) - before
        remote_tip = git(remote, "rev-parse", "refs/heads/main").stdout.strip()
        assert remote_tip == tip
        results.append({"case": mode, "push_rc": result.returncode,
                        "new_remote_pack_bytes": sum(p.stat().st_size
for p in packs),
                        "elapsed_seconds": round(elapsed, 6),
                        "remote_tip_matches": True})
    report = {"git_version": git(root, "version",
"--build-options").stdout.strip(),
              "platform": {"system": platform.system(), "machine":
platform.machine(),
                           "macos": platform.mac_ver()[0]},
              "fixture_bytes": 4 * 1024 * 1024,
              "transport": "local bare repository", "results": results}
    encoded = json.dumps(report, indent=2) + "\n"
    (root / "results.json").write_text(encoded)
    print(encoded, end="")
    if temporary:
        temporary.cleanup()

if __name__ == "__main__":
    main()

Thank you.