From 1d423c493e3fc067b8bf39b61529ea1a6bbf224e Mon Sep 17 00:00:00 2001
From: Elijah Newren <newren@gmail.com>
Date: Sat, 30 May 2026 22:37:37 -0700
Subject: [PATCH 01/18] pack-objects: honor a ".baddeltas" marker in
 try_delta()

When considering delta compression, try_delta() skips pairs of
non-delta objects from the same pack, assuming an earlier delta search
already rejected them.  Packs written by fast-import, bulk check-in,
or pack-objects --window=0 need not satisfy that assumption, as Jeff
King discussed:

    https://lore.kernel.org/git/20231009202149.GA3281325@coredump.intra.peff.net/

Recognize a .baddeltas sidecar to disable this shortcut for marked
packs.  Existing deltas remain reusable.

Assisted-by: Claude Opus 4.7
Signed-off-by: Elijah Newren <newren@gmail.com>
---
 Documentation/gitformat-pack.adoc |  26 ++++++
 builtin/pack-objects.c            |   6 ++
 odb/source-packed.c               |   3 +-
 packfile.c                        |  12 ++-
 packfile.h                        |   3 +-
 repack.c                          |   1 +
 t/meson.build                     |   1 +
 t/t5337-pack-baddeltas.sh         | 136 ++++++++++++++++++++++++++++++
 8 files changed, 183 insertions(+), 5 deletions(-)
 create mode 100755 t/t5337-pack-baddeltas.sh

diff --git a/Documentation/gitformat-pack.adoc b/Documentation/gitformat-pack.adoc
index 3416edceab82e9..d1ab3ff923d1b3 100644
--- a/Documentation/gitformat-pack.adoc
+++ b/Documentation/gitformat-pack.adoc
@@ -12,6 +12,7 @@ SYNOPSIS
 $GIT_DIR/objects/pack/pack-*.{pack,idx}
 $GIT_DIR/objects/pack/pack-*.rev
 $GIT_DIR/objects/pack/pack-*.mtimes
+$GIT_DIR/objects/pack/pack-*.baddeltas
 $GIT_DIR/objects/pack/multi-pack-index
 
 DESCRIPTION
@@ -357,6 +358,31 @@ All 4-byte numbers are in network byte order.
     and a checksum of all of the above (each having length according
     to the specified hash function).
 
+== pack-*.baddeltas files
+
+The optional `.baddeltas` file is an empty marker sitting alongside a
+`pack-*.pack` (and its `.idx`). It signals to `git pack-objects` that
+the delta layout of the pack should not be trusted: even when two
+objects appear together in the same pack and neither is stored as a
+delta, the next packing run should still call out to its delta search
+routine for the pair instead of assuming a prior pack-objects already
+considered (and rejected) the pair.
+
+This is intended for producers that intentionally skip delta search
+when writing a pack (for example, processes that bulk-import objects
+or aggregate multiple existing packs without recomputing deltas).
+Without this marker, the same-pack delta skip in `git pack-objects`
+would silently inherit those producers' lack of delta search into
+future repacks.
+
+The contents of the file are currently ignored. Producers should
+write an empty file; consumers must tolerate (and ignore) any
+content.
+
+The marker only affects whether `git pack-objects` will attempt to
+compute new deltas for object pairs that share the marked pack. It
+does not disable reuse of existing on-disk deltas.
+
 == multi-pack-index (MIDX) files have the following format:
 
 The multi-pack-index files refer to multiple pack-files and loose objects.
diff --git a/builtin/pack-objects.c b/builtin/pack-objects.c
index af9390a46b9a69..7c45167c29f21a 100644
--- a/builtin/pack-objects.c
+++ b/builtin/pack-objects.c
@@ -2827,9 +2827,15 @@ static int try_delta(struct unpacked *trg, struct unpacked *src,
 	 * be considered, as even if we produce a suboptimal delta against
 	 * it, we will still save the transfer cost, as we already know
 	 * the other side has it and we won't send src_entry at all.
+	 *
+	 * If the source pack carries a ".baddeltas" marker, we treat its
+	 * existing delta layout as untrusted: even if the two objects are
+	 * in the same pack and neither is a delta, we have no reason to
+	 * believe a previous packing run actually considered the pair.
 	 */
 	if (reuse_delta && IN_PACK(trg_entry) &&
 	    IN_PACK(trg_entry) == IN_PACK(src_entry) &&
+	    !IN_PACK(trg_entry)->has_bad_deltas &&
 	    !src_entry->preferred_base &&
 	    trg_entry->in_pack_type != OBJ_REF_DELTA &&
 	    trg_entry->in_pack_type != OBJ_OFS_DELTA)
diff --git a/odb/source-packed.c b/odb/source-packed.c
index 61d68eca044442..2d3d4e1f8fdadc 100644
--- a/odb/source-packed.c
+++ b/odb/source-packed.c
@@ -775,7 +775,8 @@ static void prepare_pack(const char *full_name, size_t full_name_len,
 	    ends_with(file_name, ".bitmap") ||
 	    ends_with(file_name, ".keep") ||
 	    ends_with(file_name, ".promisor") ||
-	    ends_with(file_name, ".mtimes"))
+	    ends_with(file_name, ".mtimes") ||
+	    ends_with(file_name, ".baddeltas"))
 		string_list_append(data->garbage, full_name);
 	else
 		report_garbage(PACKDIR_FILE_GARBAGE, full_name);
diff --git a/packfile.c b/packfile.c
index 4fa5fd67c8497f..abb0a01e4408f7 100644
--- a/packfile.c
+++ b/packfile.c
@@ -367,7 +367,9 @@ void close_pack(struct packed_git *p)
 
 void unlink_pack_path(const char *pack_name, int force_delete)
 {
-	static const char *exts[] = {".idx", ".pack", ".rev", ".keep", ".bitmap", ".promisor", ".mtimes"};
+	static const char *exts[] = {".idx", ".pack", ".rev", ".keep",
+				     ".bitmap", ".promisor", ".mtimes",
+				     ".baddeltas"};
 	int i;
 	struct strbuf buf = STRBUF_INIT;
 	size_t plen;
@@ -723,10 +725,10 @@ struct packed_git *add_packed_git(struct repository *r, const char *path,
 		return NULL;
 
 	/*
-	 * ".promisor" is long enough to hold any suffix we're adding (and
+	 * ".baddeltas" is long enough to hold any suffix we're adding (and
 	 * the use xsnprintf double-checks that)
 	 */
-	alloc = st_add3(path_len, strlen(".promisor"), 1);
+	alloc = st_add3(path_len, strlen(".baddeltas"), 1);
 	p = alloc_packed_git(r, alloc);
 	memcpy(p->pack_name, path, path_len);
 
@@ -753,6 +755,10 @@ struct packed_git *add_packed_git(struct repository *r, const char *path,
 	if (!access(p->pack_name, F_OK))
 		p->is_cruft = 1;
 
+	xsnprintf(p->pack_name + path_len, alloc - path_len, ".baddeltas");
+	if (!access(p->pack_name, F_OK))
+		p->has_bad_deltas = 1;
+
 	xsnprintf(p->pack_name + path_len, alloc - path_len, ".pack");
 	if (stat(p->pack_name, &st) || !S_ISREG(st.st_mode)) {
 		free(p);
diff --git a/packfile.h b/packfile.h
index 6d30d15a0053b3..370b21c281e201 100644
--- a/packfile.h
+++ b/packfile.h
@@ -34,7 +34,8 @@ struct packed_git {
 		 do_not_close:1,
 		 pack_promisor:1,
 		 multi_pack_index:1,
-		 is_cruft:1;
+		 is_cruft:1,
+		 has_bad_deltas:1;
 	unsigned char hash[GIT_MAX_RAWSZ];
 	struct revindex_entry *revindex;
 	const uint32_t *revindex_data;
diff --git a/repack.c b/repack.c
index d2aa58e13484fd..d17eaa06c167a4 100644
--- a/repack.c
+++ b/repack.c
@@ -330,6 +330,7 @@ static struct {
 	{".mtimes", 1},
 	{".bitmap", 1},
 	{".promisor", 1},
+	{".baddeltas", 1},
 	{".idx"},
 };
 
diff --git a/t/meson.build b/t/meson.build
index 7f53cca7d1f891..90d4c7c39708f8 100644
--- a/t/meson.build
+++ b/t/meson.build
@@ -639,6 +639,7 @@ integration_tests = [
   't5333-pseudo-merge-bitmaps.sh',
   't5334-incremental-multi-pack-index.sh',
   't5335-compact-multi-pack-index.sh',
+  't5337-pack-baddeltas.sh',
   't5351-unpack-large-objects.sh',
   't5400-send-pack.sh',
   't5401-update-hooks.sh',
diff --git a/t/t5337-pack-baddeltas.sh b/t/t5337-pack-baddeltas.sh
new file mode 100755
index 00000000000000..7f5af219b4a92c
--- /dev/null
+++ b/t/t5337-pack-baddeltas.sh
@@ -0,0 +1,136 @@
+#!/bin/sh
+
+test_description='`.baddeltas` sidecar disables the same-pack try_delta() skip'
+
+. ./test-lib.sh
+
+# Two similar but distinct blobs.  The contents are deliberately large
+# enough and similar enough that a real delta search will find a useful
+# delta between them.
+generate_blobs () {
+	{
+		printf "header\n" &&
+		i=0 &&
+		while test $i -lt 200
+		do
+			printf "line %d padding-padding-padding-padding\n" $i &&
+			i=$((i + 1)) || return 1
+		done
+	} >a &&
+	cp a b &&
+	printf "tail-line\n" >>b
+}
+
+# Build a pack from the two blobs without doing any delta search, and
+# echo the basename of the resulting .pack file.
+build_input_pack () {
+	A=$(git hash-object -w a) &&
+	B=$(git hash-object -w b) &&
+	pack_hash=$(printf "%s\n%s\n" "$A" "$B" |
+		git pack-objects --window=0 .git/objects/pack/pack) &&
+	git prune-packed &&
+	echo "pack-$pack_hash.pack"
+}
+
+# Count delta entries in a pack idx.  "git verify-pack -v" prints one
+# line per object with 5 fields for non-delta entries (oid, type, size,
+# size-in-pack, offset) and 7 fields for delta entries (... depth
+# base-oid).
+count_deltas () {
+	git verify-pack -v "$1" |
+	awk 'NF == 7 { n++ } END { print n + 0 }'
+}
+
+# Repack just the two blobs from the existing pack into a fresh pack
+# with prefix "out".  Echo the basename of the resulting .pack file.
+repack_blobs () {
+	A=$(git hash-object a) &&
+	B=$(git hash-object b) &&
+	pack_hash=$(printf "%s\n%s\n" "$A" "$B" |
+		git pack-objects .git/objects/pack/out) &&
+	echo "out-$pack_hash.pack"
+}
+
+test_expect_success 'set up two similar blobs' '
+	git init repo &&
+	(
+		cd repo &&
+		generate_blobs
+	)
+'
+
+test_expect_success 'without .baddeltas, same-pack pair is skipped' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		input_pack=$(build_input_pack) &&
+		test 0 -eq "$(count_deltas .git/objects/pack/${input_pack%.pack}.idx)" &&
+		out_pack=$(repack_blobs) &&
+		test 0 -eq "$(count_deltas .git/objects/pack/${out_pack%.pack}.idx)"
+	)
+'
+
+test_expect_success 'with .baddeltas, same-pack pair gets reconsidered' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		input_pack=$(build_input_pack) &&
+		test 0 -eq "$(count_deltas .git/objects/pack/${input_pack%.pack}.idx)" &&
+		>.git/objects/pack/${input_pack%.pack}.baddeltas &&
+		out_pack=$(repack_blobs) &&
+		test 1 -le "$(count_deltas .git/objects/pack/${out_pack%.pack}.idx)"
+	)
+'
+
+test_expect_success '.baddeltas does not trigger garbage warnings' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		input_pack=$(build_input_pack) &&
+		>.git/objects/pack/${input_pack%.pack}.baddeltas &&
+		git count-objects -v 2>warnings &&
+		test_grep ! -i garbage warnings
+	)
+'
+
+test_expect_success 'repacking an unchanged pack removes .baddeltas' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		# Tiny blobs leave no useful deltas to find.
+		for i in 1 2 3 4
+		do
+			oid=$(echo "marker-$i" | git hash-object -w --stdin) &&
+			git update-ref "refs/tags/blob-$i" "$oid" || return 1
+		done &&
+		git repack -ad &&
+		ls .git/objects/pack/pack-*.pack >before &&
+		test_line_count = 1 before &&
+		read pack <before &&
+		>"${pack%.pack}.baddeltas" &&
+		git repack -ad &&
+		ls .git/objects/pack/pack-*.pack >after &&
+		test_cmp before after &&
+		test_path_is_missing "${pack%.pack}.baddeltas" &&
+		git fsck
+	)
+'
+
+test_expect_success '.baddeltas is removed by git repack -d' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		input_pack=$(build_input_pack) &&
+		>.git/objects/pack/${input_pack%.pack}.baddeltas &&
+		git repack -ad &&
+		test_path_is_missing .git/objects/pack/${input_pack%.pack}.baddeltas &&
+		test_path_is_missing .git/objects/pack/$input_pack
+	)
+'
+
+test_done

From 2eb7a743b02df47916a8af87d3e914a1f9837663 Mon Sep 17 00:00:00 2001
From: Elijah Newren <newren@gmail.com>
Date: Mon, 21 Sep 2026 11:48:38 -0700
Subject: [PATCH 02/18] pack-write: share creation of pack marker files

index-pack creates .keep and .promisor markers without overwriting
existing files.  Extract this writer into pack-write.c so other pack
producers can reuse it, leaving filename selection and output reporting
in index-pack.

Signed-off-by: Elijah Newren <newren@gmail.com>
---
 builtin/index-pack.c | 20 ++------------------
 pack-write.c         | 19 +++++++++++++++++++
 pack.h               |  7 +++++++
 3 files changed, 28 insertions(+), 18 deletions(-)

diff --git a/builtin/index-pack.c b/builtin/index-pack.c
index 6b2a87e2d39355..9a3dd9ecc58d87 100644
--- a/builtin/index-pack.c
+++ b/builtin/index-pack.c
@@ -1561,30 +1561,14 @@ static void write_special_file(const char *suffix, const char *msg,
 {
 	struct strbuf name_buf = STRBUF_INIT;
 	const char *filename;
-	int fd;
-	int msg_len = strlen(msg);
 
 	if (pack_name)
 		filename = derive_filename(pack_name, "pack", suffix, &name_buf);
 	else
 		filename = odb_pack_name(the_repository, &name_buf, hash, suffix);
 
-	fd = safe_create_file_with_leading_directories(the_repository, filename);
-	if (fd < 0) {
-		if (errno != EEXIST)
-			die_errno(_("cannot write %s file '%s'"),
-				  suffix, filename);
-	} else {
-		if (msg_len > 0) {
-			write_or_die(fd, msg, msg_len);
-			write_or_die(fd, "\n", 1);
-		}
-		if (close(fd) != 0)
-			die_errno(_("cannot close written %s file '%s'"),
-				  suffix, filename);
-		if (report)
-			*report = suffix;
-	}
+	if (write_pack_marker_file(the_repository, filename, msg) && report)
+		*report = suffix;
 	strbuf_release(&name_buf);
 }
 
diff --git a/pack-write.c b/pack-write.c
index 85674e4b726bab..d33a648a87f822 100644
--- a/pack-write.c
+++ b/pack-write.c
@@ -599,6 +599,25 @@ void stage_tmp_packfiles(struct repository *repo,
 	free(mtimes_tmp_name);
 }
 
+int write_pack_marker_file(struct repository *repo, const char *filename,
+			   const char *msg)
+{
+	int fd = safe_create_file_with_leading_directories(repo, filename);
+
+	if (fd < 0) {
+		if (errno == EEXIST)
+			return 0;
+		die_errno(_("cannot write file '%s'"), filename);
+	}
+	if (*msg) {
+		write_or_die(fd, msg, strlen(msg));
+		write_or_die(fd, "\n", 1);
+	}
+	if (close(fd))
+		die_errno(_("cannot close written file '%s'"), filename);
+	return 1;
+}
+
 void write_promisor_file(const char *promisor_name, struct ref **sought, int nr_sought)
 {
 	int i, err;
diff --git a/pack.h b/pack.h
index ada506b5c5d0db..bc42618aee2507 100644
--- a/pack.h
+++ b/pack.h
@@ -111,6 +111,13 @@ char *index_pack_lockfile(struct odb_source *source, int fd,
 
 struct ref;
 
+/*
+ * Create a pack marker containing msg followed by a newline, or an empty
+ * marker if msg is empty. Leave existing files untouched. Return 1 if
+ * created, 0 if already present; die on other errors.
+ */
+int write_pack_marker_file(struct repository *repo, const char *filename,
+			   const char *msg);
 void write_promisor_file(const char *promisor_name, struct ref **sought, int nr_sought);
 
 char *write_rev_file(struct repository *repo,

From 3bd9d62b9739bc8132ce08688c9e940951a44bab Mon Sep 17 00:00:00 2001
From: Elijah Newren <newren@gmail.com>
Date: Sat, 30 May 2026 22:40:13 -0700
Subject: [PATCH 03/18] pack-objects: add a --mark-bad-deltas option

Packs written without a full delta search need a way to request
reconsideration during later repacks.  Add --mark-bad-deltas to
write an empty .baddeltas marker beside each output pack.  This
option is incompatible with --stdout.

Publish the marker before the index so readers discover the pack
with its marker already in place.

Assisted-by: Claude Opus 4.7
Signed-off-by: Elijah Newren <newren@gmail.com>
---
 Documentation/git-pack-objects.adoc |  8 +++++++
 builtin/pack-objects.c              | 15 +++++++++++++
 t/t5337-pack-baddeltas.sh           | 34 +++++++++++++++++++++++++++++
 3 files changed, 57 insertions(+)

diff --git a/Documentation/git-pack-objects.adoc b/Documentation/git-pack-objects.adoc
index 65cd00c152f495..0196849510406b 100644
--- a/Documentation/git-pack-objects.adoc
+++ b/Documentation/git-pack-objects.adoc
@@ -143,6 +143,14 @@ options which imply `--revs`.
 	have an mtime older than `<approxidate>`. If unspecified (and
 	given `--cruft`), then no objects are eliminated.
 
+--mark-bad-deltas::
+	Write a `.baddeltas` marker file alongside each output pack. The
+	marker signals that objects within the pack have not been fully
+	delta-searched against other objects within the same pack and
+	that future repacking should consider them. Any deltas that do
+	exist within this pack can still be reused, however.
+	Incompatible with `--stdout`.
+
 --window=<n>::
 --depth=<n>::
 	These two options affect how the objects contained in
diff --git a/builtin/pack-objects.c b/builtin/pack-objects.c
index 7c45167c29f21a..ac881b0f5ed6df 100644
--- a/builtin/pack-objects.c
+++ b/builtin/pack-objects.c
@@ -44,6 +44,7 @@
 #include "pack-mtimes.h"
 #include "parse-options.h"
 #include "pkt-line.h"
+#include "path.h"
 #include "blob.h"
 #include "tree.h"
 #include "path-walk.h"
@@ -212,6 +213,7 @@ static int keep_unreachable, unpack_unreachable, include_tag;
 static timestamp_t unpack_unreachable_expiration;
 static int pack_loose_unreachable;
 static int cruft;
+static int mark_bad_deltas;
 static int shallow = 0;
 static timestamp_t cruft_expiration;
 static int local;
@@ -1470,6 +1472,14 @@ static void write_pack_file(void)
 					    &pack_idx_opts, hash,
 					    &idx_tmp_name);
 
+			if (mark_bad_deltas) {
+				size_t tmpname_len = tmpname.len;
+
+				strbuf_addstr(&tmpname, "baddeltas");
+				write_pack_marker_file(the_repository, tmpname.buf, "");
+				strbuf_setlen(&tmpname, tmpname_len);
+			}
+
 			if (write_bitmap_index) {
 				size_t tmpname_len = tmpname.len;
 
@@ -5207,6 +5217,8 @@ int cmd_pack_objects(int argc,
 		  N_("unpack unreachable objects newer than <time>"),
 		  PARSE_OPT_OPTARG, option_parse_unpack_unreachable),
 		OPT_BOOL(0, "cruft", &cruft, N_("create a cruft pack")),
+		OPT_BOOL(0, "mark-bad-deltas", &mark_bad_deltas,
+			 N_("write a .baddeltas marker alongside the output pack(s)")),
 		OPT_CALLBACK_F(0, "cruft-expiration", NULL, N_("time"),
 		  N_("expire cruft objects older than <time>"),
 		  PARSE_OPT_OPTARG, option_parse_cruft_expiration),
@@ -5397,6 +5409,9 @@ int cmd_pack_objects(int argc,
 	if (!pack_to_stdout && thin)
 		die(_("--thin cannot be used to build an indexable pack"));
 
+	die_for_incompatible_opt2(mark_bad_deltas, "--mark-bad-deltas",
+				  pack_to_stdout, "--stdout");
+
 	die_for_incompatible_opt2(keep_unreachable, "--keep-unreachable",
 				  unpack_unreachable, "--unpack-unreachable");
 	if (!rev_list_all || !rev_list_reflog || !rev_list_index)
diff --git a/t/t5337-pack-baddeltas.sh b/t/t5337-pack-baddeltas.sh
index 7f5af219b4a92c..2947b52e75bfb3 100755
--- a/t/t5337-pack-baddeltas.sh
+++ b/t/t5337-pack-baddeltas.sh
@@ -133,4 +133,38 @@ test_expect_success '.baddeltas is removed by git repack -d' '
 	)
 '
 
+test_expect_success 'pack-objects --mark-bad-deltas writes .baddeltas' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		A=$(git hash-object -w a) &&
+		B=$(git hash-object -w b) &&
+		printf "%s\n%s\n" "$A" "$B" |
+			git pack-objects --window=0 --mark-bad-deltas \
+				.git/objects/pack/pack >pack.hash &&
+		pack="pack-$(cat pack.hash).pack" &&
+		test_path_is_file .git/objects/pack/${pack%.pack}.baddeltas &&
+		test_must_be_empty .git/objects/pack/${pack%.pack}.baddeltas &&
+		test 0 -eq "$(count_deltas .git/objects/pack/${pack%.pack}.idx)" &&
+		git prune-packed &&
+
+		out_pack=$(repack_blobs) &&
+		test 1 -le "$(count_deltas .git/objects/pack/${out_pack%.pack}.idx)"
+	)
+'
+
+test_expect_success 'pack-objects --mark-bad-deltas is incompatible with --stdout' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		A=$(git hash-object -w a) &&
+		printf "%s\n" "$A" >in &&
+		test_must_fail git pack-objects --mark-bad-deltas --stdout \
+			<in >/dev/null 2>err &&
+		test_grep "cannot be used together" err
+	)
+'
+
 test_done

From 7212e56175750efa07427ac70e73b5ede4d9b644 Mon Sep 17 00:00:00 2001
From: Elijah Newren <newren@gmail.com>
Date: Sat, 30 May 2026 15:49:09 -0700
Subject: [PATCH 04/18] pack-objects: skip --stdin-packs hint walk when delta
 search is off

With --stdin-packs, the revision walk supplies namehash hints for
delta selection and, with --stdin-packs=follow, finds reachable
objects outside the listed packs.

Skip the walk when --stdin-packs=follow is not in use and delta search
is disabled by --window=0 or --depth=0.

Skipping the walk alone does not eliminate all the unnecessary work:
seeding via add_pending_oid() still parses commits and looks up
objects.  These lookups can map every pack index in the object store,
which in some cases can even exhaust the per-process mapping limit.
Skip the commit seeding as well.

On a repository with about 35 million objects, packing 14,174 objects
from 316 packs in a store of 1,427 packs gave:

    variant                        time     max RSS
    -----------------------------  -------  --------
    seed and walk (before)          176s    8.2 GiB
    skip walk, still seed          0.38s    154 MiB
    skip walk and seeding (after)  0.31s     66 MiB

In the worst case, skipping seeding also reduced distinct pack-index
mappings from 1,427 to 316.  The output pack was byte-identical in all
three runs.

Assisted-by: Claude Opus 4.7
Signed-off-by: Elijah Newren <newren@gmail.com>
---
 builtin/pack-objects.c        | 24 ++++++++----
 t/t5331-pack-objects-stdin.sh | 74 +++++++++++++++++++++++++++++++++++
 2 files changed, 91 insertions(+), 7 deletions(-)

diff --git a/builtin/pack-objects.c b/builtin/pack-objects.c
index ac881b0f5ed6df..4ae929c76ebe9a 100644
--- a/builtin/pack-objects.c
+++ b/builtin/pack-objects.c
@@ -3820,6 +3820,8 @@ static int git_pack_config(const char *k, const char *v,
 static int stdin_packs_found_nr;
 static int stdin_packs_hints_nr;
 
+static int stdin_packs_need_walk;
+
 static int add_object_entry_from_pack(const struct object_id *oid,
 				      struct packed_git *p,
 				      uint32_t pos,
@@ -3842,7 +3844,7 @@ static int add_object_entry_from_pack(const struct object_id *oid,
 	if (packed_object_info(NULL, p, ofs, &oi) < 0) {
 		die(_("could not get type of object %s in pack %s"),
 		    oid_to_hex(oid), p->pack_name);
-	} else if (type == OBJ_COMMIT) {
+	} else if (type == OBJ_COMMIT && stdin_packs_need_walk) {
 		struct rev_info *revs = _data;
 		/*
 		 * commits in included packs are used as starting points
@@ -4128,7 +4130,13 @@ static void read_stdin_packs(struct repository *repo,
 	 * That may cause us to avoid populating all of the namehash fields of
 	 * all included objects, but our goal is best-effort, since this is only
 	 * an optimization during delta selection.
+	 *
+	 * Skip both commit seeding and walking unless delta search needs
+	 * namehash hints or FOLLOW mode needs reachability.
 	 */
+	stdin_packs_need_walk = (window && depth) ||
+				mode == STDIN_PACKS_MODE_FOLLOW;
+
 	revs.no_kept_objects = 1;
 	revs.keep_pack_cache_flags |= KEPT_PACK_IN_CORE;
 	revs.blob_objects = 1;
@@ -4151,12 +4159,14 @@ static void read_stdin_packs(struct repository *repo,
 	if (rev_list_unpacked)
 		add_unreachable_loose_objects(&revs);
 
-	if (prepare_revision_walk(&revs))
-		die(_("revision walk setup failed"));
-	traverse_commit_list(&revs,
-			     show_commit_pack_hint,
-			     show_object_pack_hint,
-			     &mode);
+	if (stdin_packs_need_walk) {
+		if (prepare_revision_walk(&revs))
+			die(_("revision walk setup failed"));
+		traverse_commit_list(&revs,
+				     show_commit_pack_hint,
+				     show_object_pack_hint,
+				     &mode);
+	}
 
 	release_revisions(&revs);
 
diff --git a/t/t5331-pack-objects-stdin.sh b/t/t5331-pack-objects-stdin.sh
index c74b5861af322f..943e14db6eb65b 100755
--- a/t/t5331-pack-objects-stdin.sh
+++ b/t/t5331-pack-objects-stdin.sh
@@ -520,4 +520,78 @@ test_expect_success '--stdin-packs with !-delimited pack without follow' '
 	)
 '
 
+test_expect_success 'setup for --stdin-packs hint walks' '
+	git init hint-walk &&
+	(
+		cd hint-walk &&
+
+		for c in A B C D
+		do
+			test_commit "$c" || return 1
+		done &&
+
+		A="$(echo A | git pack-objects --revs $packdir/pack)" &&
+		B="$(echo A..B | git pack-objects --revs $packdir/pack)" &&
+		C="$(echo B..C | git pack-objects --revs $packdir/pack)" &&
+		D="$(echo C..D | git pack-objects --revs $packdir/pack)" &&
+		git prune-packed &&
+
+		cat >in <<-EOF &&
+		pack-$B.pack
+		^pack-$C.pack
+		pack-$D.pack
+		EOF
+
+		objects_in_packs $B $D >expect-standard &&
+		objects_in_packs $A $B $D >expect-follow
+	)
+'
+
+test_expect_success '--stdin-packs skips rev walk when delta search is off' '
+	(
+		cd hint-walk &&
+
+		# Without =follow, disabling delta search needs no namehash hints.
+		default_pack=$(GIT_TRACE2_EVENT="$(pwd)/walk-default.event" \
+			git pack-objects --stdin-packs pack <in) &&
+		test_grep ! "\"key\":\"stdin_packs_hints\",\"value\":\"0\"" walk-default.event &&
+
+		no_window_pack=$(GIT_TRACE2_EVENT="$(pwd)/walk-window.event" \
+			git pack-objects --stdin-packs --window=0 pack <in) &&
+		test_grep "\"key\":\"stdin_packs_hints\",\"value\":\"0\"" walk-window.event &&
+
+		no_depth_pack=$(GIT_TRACE2_EVENT="$(pwd)/walk-depth.event" \
+			git pack-objects --stdin-packs --depth=0 pack <in) &&
+		test_grep "\"key\":\"stdin_packs_hints\",\"value\":\"0\"" walk-depth.event &&
+
+		packed_objects "pack-$default_pack.idx" >actual &&
+		test_cmp expect-standard actual &&
+		packed_objects "pack-$no_window_pack.idx" >actual &&
+		test_cmp expect-standard actual &&
+		packed_objects "pack-$no_depth_pack.idx" >actual &&
+		test_cmp expect-standard actual
+	)
+'
+
+test_expect_success '--stdin-packs=follow walks even with delta search off' '
+	(
+		cd hint-walk &&
+
+		# Follow mode must still include the reachable objects in pack A.
+		default_pack=$(git pack-objects --stdin-packs=follow pack <in) &&
+		packed_objects "pack-$default_pack.idx" >actual &&
+		test_cmp expect-follow actual &&
+
+		no_window_pack=$(git pack-objects --stdin-packs=follow --window=0 \
+			pack <in) &&
+		packed_objects "pack-$no_window_pack.idx" >actual &&
+		test_cmp expect-follow actual &&
+
+		no_depth_pack=$(git pack-objects --stdin-packs=follow --depth=0 \
+			pack <in) &&
+		packed_objects "pack-$no_depth_pack.idx" >actual &&
+		test_cmp expect-follow actual
+	)
+'
+
 test_done

From 675e60605c4edbcebfe4c1105ddeabc6c1935648 Mon Sep 17 00:00:00 2001
From: Elijah Newren <newren@gmail.com>
Date: Thu, 23 Jul 2026 21:54:36 -0700
Subject: [PATCH 05/18] pack-objects: add --prefer-reused-deltas to keep delta
 copies

When combining packs with --stdin-packs --window=0, pack-objects
reuses existing deltas without searching for new ones.  However, if
an object appears in multiple included packs, it uses the first copy
it finds, even if that copy stores the object in full and another
pack stores it as a delta.

Add --prefer-reused-deltas to prefer a copy stored as a delta over
one stored in full.  It has no effect with --no-reuse-delta.

On a roughly 37-million-object repository, first-copy selection lost
25,310 existing deltas while combining 7,253 input packs.  Adding
--prefer-reused-deltas retained 20,547 of them (81%).

Assisted-by: Claude Opus 4.8 & GPT-5.6 Sol
Signed-off-by: Elijah Newren <newren@gmail.com>
---
 Documentation/git-pack-objects.adoc |  7 ++++
 builtin/pack-objects.c              | 54 ++++++++++++++++++++++++-
 t/t5300-pack-object.sh              | 61 +++++++++++++++++++++++++++++
 3 files changed, 121 insertions(+), 1 deletion(-)

diff --git a/Documentation/git-pack-objects.adoc b/Documentation/git-pack-objects.adoc
index 0196849510406b..bb6bcb30d27415 100644
--- a/Documentation/git-pack-objects.adoc
+++ b/Documentation/git-pack-objects.adoc
@@ -254,6 +254,13 @@ depth is 4095.
 	wholesale enforcement of a different compression level on the
 	packed data is desired.
 
+--prefer-reused-deltas::
+	Only meaningful with `--stdin-packs`. When the same object is
+	present as a base in one included pack and a delta in another,
+	record the delta copy rather than the base. This costs a
+	cheap object-header read per duplicate, and has no effect
+	under `--no-reuse-delta`.
+
 --compression=<n>::
 	Specifies compression level for newly-compressed data in the
 	generated pack.  If not specified,  pack compression level is
diff --git a/builtin/pack-objects.c b/builtin/pack-objects.c
index 4ae929c76ebe9a..6a84f83d6d6643 100644
--- a/builtin/pack-objects.c
+++ b/builtin/pack-objects.c
@@ -209,6 +209,7 @@ static uint32_t write_layer;
 
 static int non_empty;
 static int reuse_delta = 1, reuse_object = 1;
+static int prefer_reused_deltas;
 static int keep_unreachable, unpack_unreachable, include_tag;
 static timestamp_t unpack_unreachable_expiration;
 static int pack_loose_unreachable;
@@ -3822,6 +3823,51 @@ static int stdin_packs_hints_nr;
 
 static int stdin_packs_need_walk;
 
+/* Read only the object header to identify delta copies. */
+static int pack_entry_is_delta(struct packed_git *p, off_t offset)
+{
+	struct pack_window *w_curs = NULL;
+	size_t avail, size;
+	enum object_type type;
+	unsigned char *buf;
+	int is_delta = 0;
+
+	buf = use_pack(p, &w_curs, offset, &avail);
+	if (unpack_object_header_buffer(buf, avail, &type, &size))
+		is_delta = (type == OBJ_OFS_DELTA || type == OBJ_REF_DELTA);
+	unuse_pack(&w_curs);
+	return is_delta;
+}
+
+/*
+ * Packs are visited newest-first. Prefer a later delta copy over the
+ * first full copy. check_object() may still reject delta reuse if the
+ * base is unavailable.
+ */
+static void maybe_prefer_delta_copy(const struct object_id *oid,
+				    struct packed_git *p, uint32_t pos)
+{
+	struct object_entry *entry;
+	off_t ofs;
+
+	if (!reuse_delta)
+		return;
+	entry = packlist_find(&to_pack, oid);
+	if (!entry || entry->preferred_base || !IN_PACK(entry))
+		return;
+
+	/* Only switch a plain base copy over to a delta copy. */
+	if (pack_entry_is_delta(IN_PACK(entry), entry->in_pack_offset))
+		return;
+
+	ofs = nth_packed_object_offset(p, pos);
+	if (!pack_entry_is_delta(p, ofs))
+		return;
+
+	oe_set_in_pack(&to_pack, entry, p);
+	entry->in_pack_offset = ofs;
+}
+
 static int add_object_entry_from_pack(const struct object_id *oid,
 				      struct packed_git *p,
 				      uint32_t pos,
@@ -3833,8 +3879,11 @@ static int add_object_entry_from_pack(const struct object_id *oid,
 
 	display_progress(progress_state, ++nr_seen);
 
-	if (have_duplicate_entry(oid, 0))
+	if (have_duplicate_entry(oid, 0)) {
+		if (prefer_reused_deltas)
+			maybe_prefer_delta_copy(oid, p, pos);
 		return 0;
+	}
 
 	stdin_packs_found_nr++;
 
@@ -5190,6 +5239,9 @@ int cmd_pack_objects(int argc,
 			    N_("maximum length of delta chain allowed in the resulting pack")),
 		OPT_BOOL(0, "reuse-delta", &reuse_delta,
 			 N_("reuse existing deltas")),
+		OPT_BOOL(0, "prefer-reused-deltas", &prefer_reused_deltas,
+			 N_("when an object is in several included packs, "
+			    "prefer a copy stored as a delta")),
 		OPT_BOOL(0, "reuse-object", &reuse_object,
 			 N_("reuse existing objects")),
 		OPT_BOOL(0, "delta-base-offset", &allow_ofs_delta,
diff --git a/t/t5300-pack-object.sh b/t/t5300-pack-object.sh
index aac139e6a096eb..43806688571c40 100755
--- a/t/t5300-pack-object.sh
+++ b/t/t5300-pack-object.sh
@@ -188,6 +188,67 @@ test_expect_success 'pack-objects with bogus arguments' '
 	test_must_fail git pack-objects --window=0 test-1 blah blah <obj-list
 '
 
+# Echo "delta" or "base" for how object $2 is stored in pack index $1.
+obj_repr () {
+	git verify-pack -v "$1" |
+	awk -v o="$2" '$1 == o {
+		if (NF >= 7 && $7 ~ /^[0-9a-f]+$/)
+			print "delta"
+		else
+			print "base"
+	}'
+}
+
+test_expect_success '--prefer-reused-deltas keeps a delta copy of a duplicated object' '
+	test_when_finished "rm -rf prefer-reused" &&
+	git init prefer-reused &&
+	(
+		cd prefer-reused &&
+
+		# O is a prefix of X (genrandom is deterministic on its
+		# seed), so O deltifies cheaply against X.
+		test-tool genrandom foo 8192 >x.bin &&
+		test-tool genrandom foo 4096 >o.bin &&
+		x=$(git hash-object -w x.bin) &&
+		o=$(git hash-object -w o.bin) &&
+
+		# One pack stores O as a plain base ...
+		echo "$o" |
+			git pack-objects --window=0 .git/objects/pack/pack >base.hash &&
+		# ... another stores O as a delta against X.
+		printf "%s\n%s\n" "$x" "$o" |
+			git pack-objects .git/objects/pack/pack >delta.hash &&
+		git prune-packed &&
+
+		base="pack-$(cat base.hash)" &&
+		delta="pack-$(cat delta.hash)" &&
+
+		# Precondition: the two packs really do disagree on how O
+		# is stored.
+		test "$(obj_repr ".git/objects/pack/$base.idx" "$o")" = base &&
+		test "$(obj_repr ".git/objects/pack/$delta.idx" "$o")" = delta &&
+
+		# Packs are enumerated newest-mtime first, so make the base
+		# pack the newer one to ensure its copy is seen first.
+		test-tool chmtime -200 ".git/objects/pack/$delta.pack" &&
+		printf "%s.pack\n%s.pack\n" "$base" "$delta" >packs.in &&
+
+		# Default: the first-seen (base) copy wins, dropping the delta.
+		git pack-objects --stdin-packs --window=0 out.default \
+			<packs.in >default.hash &&
+		test "$(obj_repr "out.default-$(cat default.hash).idx" "$o")" = base &&
+
+		# With the option, the delta copy is preferred and reused.
+		git pack-objects --stdin-packs --window=0 --prefer-reused-deltas \
+			out.prefer <packs.in >prefer.hash &&
+		test "$(obj_repr "out.prefer-$(cat prefer.hash).idx" "$o")" = delta &&
+
+		# The resulting pack must still be valid (the reused delta
+		# resolves against X, which is included).
+		git verify-pack "out.prefer-$(cat prefer.hash).idx"
+	)
+'
+
 check_unpack () {
 	local packname="$1" &&
 	local object_list="$2" &&

From 9f2b2ae5e602b2c9cd6148af6bf97c056740840c Mon Sep 17 00:00:00 2001
From: Elijah Newren <newren@gmail.com>
Date: Fri, 24 Jul 2026 16:55:51 -0700
Subject: [PATCH 06/18] pack-objects: avoid 2-cycles when preferring reused
 deltas

When combining packs, one pack can store A as a delta against B
while another stores B as a delta against A.  --prefer-reused-deltas
can select both representations, creating a two-object delta cycle.

break_delta_chains() repairs this by dropping one delta.  However,
the object whose delta is dropped then needs to be recompressed,
rather than reusing a copy stored in full.

Reject a candidate delta when its base is already selected as a
delta against the same object.  This preserves the selected full
copy and avoids the recompression, while still retaining one delta
for the pair.

Limit this check to two-object cycles so each candidate requires
only inspecting its base's selected representation, not walking a
delta chain.  Longer cycles remain handled by break_delta_chains().
This is a bounded optimization of delta selection, not a replacement
for the general cycle-breaking pass.

In a synthetic 1,000-pack workload with 50 reciprocal pairs of 1 MiB
objects, this avoided 50 MiB of recompression and reduced median
elapsed time from 1.86s to 0.44s, without changing the delta count or
output size.  A separate workload with 10,000 candidate deltas but no
cycles showed no measurable slowdown.  These timings used a warm disk
cache.

Assisted-by: Claude Opus 4.8
Signed-off-by: Elijah Newren <newren@gmail.com>
---
 builtin/pack-objects.c       | 40 +++++++++++++++++++++++++++++++++--
 packfile.c                   | 12 +++++------
 packfile.h                   |  3 +++
 t/t5309-pack-delta-cycles.sh | 41 +++++++++++++++++++++++++++++++++++-
 4 files changed, 87 insertions(+), 9 deletions(-)

diff --git a/builtin/pack-objects.c b/builtin/pack-objects.c
index 6a84f83d6d6643..06b85ed434bb97 100644
--- a/builtin/pack-objects.c
+++ b/builtin/pack-objects.c
@@ -3839,6 +3839,29 @@ static int pack_entry_is_delta(struct packed_git *p, off_t offset)
 	return is_delta;
 }
 
+/*
+ * Resolve the delta base into base_out and return 1, or return 0 for a
+ * non-delta or error. The cost is just an object-header parse, plus an
+ * offset lookup using the reverse index for OFS deltas.
+ */
+static int pack_entry_delta_base(struct packed_git *p, off_t offset,
+				 struct object_id *base_out)
+{
+	struct pack_window *w_curs = NULL;
+	off_t curpos = offset;
+	size_t size;
+	enum object_type type;
+	int ret = 0;
+
+	type = unpack_object_header(p, &w_curs, &curpos, &size);
+	if ((type == OBJ_OFS_DELTA || type == OBJ_REF_DELTA) &&
+	    !get_delta_base_oid(p, &w_curs, curpos, base_out, type, offset))
+		ret = 1;
+
+	unuse_pack(&w_curs);
+	return ret;
+}
+
 /*
  * Packs are visited newest-first. Prefer a later delta copy over the
  * first full copy. check_object() may still reject delta reuse if the
@@ -3847,7 +3870,8 @@ static int pack_entry_is_delta(struct packed_git *p, off_t offset)
 static void maybe_prefer_delta_copy(const struct object_id *oid,
 				    struct packed_git *p, uint32_t pos)
 {
-	struct object_entry *entry;
+	struct object_entry *entry, *base_entry;
+	struct object_id cand_base, base_of_base;
 	off_t ofs;
 
 	if (!reuse_delta)
@@ -3861,7 +3885,19 @@ static void maybe_prefer_delta_copy(const struct object_id *oid,
 		return;
 
 	ofs = nth_packed_object_offset(p, pos);
-	if (!pack_entry_is_delta(p, ofs))
+	if (!pack_entry_delta_base(p, ofs, &cand_base))
+		return;
+
+	/*
+	 * Reject a delta against cand_base if its selected copy already
+	 * depends on oid. Either choice keeps only one delta; avoid
+	 * creating a cycle just to break it.
+	 */
+	base_entry = packlist_find(&to_pack, &cand_base);
+	if (base_entry && !base_entry->preferred_base && IN_PACK(base_entry) &&
+	    pack_entry_delta_base(IN_PACK(base_entry),
+				  base_entry->in_pack_offset, &base_of_base) &&
+	    oideq(&base_of_base, oid))
 		return;
 
 	oe_set_in_pack(&to_pack, entry, p);
diff --git a/packfile.c b/packfile.c
index abb0a01e4408f7..28cfc5313f98b0 100644
--- a/packfile.c
+++ b/packfile.c
@@ -1036,12 +1036,12 @@ off_t get_delta_base(struct packed_git *p,
  * the final object lookup), but more expensive for OFS deltas (we
  * have to load the revidx to convert the offset back into a sha1).
  */
-static int get_delta_base_oid(struct packed_git *p,
-			      struct pack_window **w_curs,
-			      off_t curpos,
-			      struct object_id *oid,
-			      enum object_type type,
-			      off_t delta_obj_offset)
+int get_delta_base_oid(struct packed_git *p,
+		       struct pack_window **w_curs,
+		       off_t curpos,
+		       struct object_id *oid,
+		       enum object_type type,
+		       off_t delta_obj_offset)
 {
 	if (type == OBJ_REF_DELTA) {
 		unsigned char *base = use_pack(p, w_curs, curpos, NULL);
diff --git a/packfile.h b/packfile.h
index 370b21c281e201..119c88942641da 100644
--- a/packfile.h
+++ b/packfile.h
@@ -307,6 +307,9 @@ int unpack_object_header(struct packed_git *, struct pack_window **, off_t *, si
 off_t get_delta_base(struct packed_git *p, struct pack_window **w_curs,
 		     off_t *curpos, enum object_type type,
 		     off_t delta_obj_offset);
+int get_delta_base_oid(struct packed_git *p, struct pack_window **w_curs,
+		       off_t curpos, struct object_id *oid,
+		       enum object_type type, off_t delta_obj_offset);
 
 int packfile_read_object_stream(struct odb_stream **out,
 				const struct object_id *oid,
diff --git a/t/t5309-pack-delta-cycles.sh b/t/t5309-pack-delta-cycles.sh
index 6b03675d91b5e1..348b5f8ada5138 100755
--- a/t/t5309-pack-delta-cycles.sh
+++ b/t/t5309-pack-delta-cycles.sh
@@ -1,6 +1,6 @@
 #!/bin/sh
 
-test_description='test index-pack handling of delta cycles in packfiles'
+test_description='test handling of delta cycles in packfiles'
 
 . ./test-lib.sh
 . "$TEST_DIRECTORY"/lib-pack.sh
@@ -36,6 +36,45 @@ test_expect_success 'index-pack works with a single delta (B->A)' '
 	git cat-file -t $B
 '
 
+pack_delta_bases () {
+	git verify-pack -v "$1" >verify &&
+	awk '$2 == "blob" { print $1, (NF == 7 ? $7 : "base") }' verify
+}
+
+test_expect_success '--prefer-reused-deltas retains the selected delta instead of forming a cycle' '
+	clear_packs &&
+	git index-pack --stdin <ab.pack >ab.hash &&
+	git index-pack --stdin <ba.pack >ba.hash &&
+	ab="pack-$(cut -f2 ab.hash)" &&
+	ba="pack-$(cut -f2 ba.hash)" &&
+
+	cat >expect-ab <<-EOF &&
+	$A $B
+	$B base
+	EOF
+	cat >expect-ba <<-EOF &&
+	$A base
+	$B $A
+	EOF
+	pack_delta_bases ".git/objects/pack/$ab.idx" >actual &&
+	test_cmp expect-ab actual &&
+	pack_delta_bases ".git/objects/pack/$ba.idx" >actual &&
+	test_cmp expect-ba actual &&
+
+	# Visit ba first: A is a base, then B is a delta against A.
+	# Switching to the A-against-B copy in ab would form a cycle.
+	test-tool chmtime =1000000000 ".git/objects/pack/$ab.pack" &&
+	test-tool chmtime =1000000200 ".git/objects/pack/$ba.pack" &&
+	printf "%s.pack\n%s.pack\n" "$ba" "$ab" >packs &&
+	git pack-objects --stdin-packs --window=0 --prefer-reused-deltas \
+		out <packs >out.hash &&
+
+	# Keep B against A. Forming and then breaking the cycle would
+	# instead keep A against B, since A was enumerated first.
+	pack_delta_bases "out-$(cat out.hash).idx" >actual &&
+	test_cmp expect-ba actual
+'
+
 test_expect_success 'index-pack detects missing base objects' '
 	clear_packs &&
 	{

From c6cb0724239a1d8c04331f62354fa399ec70d0bf Mon Sep 17 00:00:00 2001
From: Elijah Newren <newren@gmail.com>
Date: Sat, 6 Jun 2026 12:31:11 -0700
Subject: [PATCH 07/18] pack-aggregate: introduce a builtin for cheap
 object/pack aggregation

Repositories that have gone without maintenance can accumulate large
numbers of loose objects and small packfiles.  Unrelated Git commands
then pay the cost of scanning the resulting sprawl in `objects/` and
`objects/pack/`, even when those commands would otherwise be quick.

Introduce a new plumbing builtin, `git pack-aggregate`, as a cheap
cleanup pass.  With `--once`, it performs two steps:

  1. Bundle local loose objects into new packs with `pack-objects
     --window=0 --mark-bad-deltas --delta-base-offset
     --no-write-bitmap-index`, then unlink the loose copies.

  2. Aggregate local packs, excluding packs in the
     multi-pack-index and packs carrying `.keep`, `.promisor`,
     `.mtimes`, or `.bitmap` sidecars, then unlink the source packs.

Both steps skip delta search and reuse packed representations where
possible; loose objects still need compression.  Either step can
produce multiple packs under `pack.packSizeLimit`.  Each output carries
a `.baddeltas` marker so a later thorough repack knows to reconsider its
intra-pack deltas.

If packing loose objects produces just one pack, allow it to participate
in the subsequent pack aggregation.  If it produces multiple packs,
likely due to `pack.packSizeLimit`, skip those new packs instead.

Make this a separate builtin rather than another `git repack` mode.  Its
contract is deliberately narrow and cheap, unlike repack's range of
optimization modes.  A later integration will run both processes at
once; distinct command names make their roles clear in process listings
and traces, while keeping the aggregator's looping and coordination
options out of repack's already broad option and configuration surface.

Use `pipe_command()` and run-command's child-cleanup machinery to avoid
I/O deadlocks and orphaned `pack-objects` processes.

Delete only the consumed pack's `.pack`, `.idx`, `.rev`, and
`.baddeltas` files after rechecking its protective sidecars.
`unlink_pack_path()` is not suitable here: its non-force mode protects
only `.keep` and otherwise also removes `.bitmap`, `.promisor`, and
`.mtimes` sidecars that cause aggregation to leave a pack alone.

Like `git repack`, `git pack-aggregate` takes no locks of its own.  Do
not run it concurrently with other pack-rewriting maintenance.

Assisted-by: Claude Opus 4.7 & GPT-5.6 Sol
Signed-off-by: Elijah Newren <newren@gmail.com>
---
 .gitignore                            |   1 +
 Documentation/git-pack-aggregate.adoc |  72 ++++
 Documentation/meson.build             |   1 +
 Makefile                              |   1 +
 builtin.h                             |   1 +
 builtin/pack-aggregate.c              | 483 ++++++++++++++++++++++++++
 command-list.txt                      |   1 +
 git.c                                 |   1 +
 meson.build                           |   1 +
 t/meson.build                         |   1 +
 t/t5336-pack-aggregate.sh             | 253 ++++++++++++++
 11 files changed, 816 insertions(+)
 create mode 100644 Documentation/git-pack-aggregate.adoc
 create mode 100644 builtin/pack-aggregate.c
 create mode 100755 t/t5336-pack-aggregate.sh

diff --git a/.gitignore b/.gitignore
index 4da58c6754899e..3db5d3635125b1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -119,6 +119,7 @@
 /git-name-rev
 /git-notes
 /git-p4
+/git-pack-aggregate
 /git-pack-redundant
 /git-pack-objects
 /git-pack-refs
diff --git a/Documentation/git-pack-aggregate.adoc b/Documentation/git-pack-aggregate.adoc
new file mode 100644
index 00000000000000..66a3115c404204
--- /dev/null
+++ b/Documentation/git-pack-aggregate.adoc
@@ -0,0 +1,72 @@
+git-pack-aggregate(1)
+=====================
+
+NAME
+----
+git-pack-aggregate - Quickly roll up loose objects and small packs
+without doing any delta compression or search
+
+SYNOPSIS
+--------
+[verse]
+'git pack-aggregate' --once [--min-loose=<n>] [--min-packs=<n>]
+
+DESCRIPTION
+-----------
+
+`git pack-aggregate` rolls accumulated loose objects and small
+packfiles into new packs in two steps:
+
+1. Bundle local loose objects into new packs and unlink the loose copies.
+2. Aggregate small local packs (minus those referenced by the
+   multi-pack-index or carrying a `.keep`, `.promisor`, `.mtimes`, or
+   `.bitmap` sidecar) into new packs and unlink the source packs.
+   If step 1 writes a single pack, it is naturally a candidate here
+   and will normally be folded into the step-2 output.  Multiple
+   loose-rollup packs are left for a later aggregation pass.
+
+No delta search is performed and no bitmaps or commit-graphs are updated.
+Existing packed representations are reused where possible.  When an
+object has both delta and full-object representations in the input
+packs, aggregation prefers the existing delta.  All output packs are
+written with `pack-objects --window=0 --mark-bad-deltas`, so each one
+ships with a `.baddeltas` sidecar (see linkgit:gitformat-pack[5]).  A
+subsequent thorough repack (linkgit:git-repack[1]) honors that marker
+and reconsiders intra-pack deltas at that time.
+
+The `pack.packSizeLimit` setting can split either step's output into
+multiple packs.  All outputs from a batch are installed before its
+input packs or loose objects are removed.  Size-based splitting may
+require expanding deltas whose bases are in another output pack.
+
+This command provides a quick recovery step for a repository that has
+accumulated many loose objects or small packs.  It reduces the number
+of files that unrelated `git` operations must scan, while leaving a
+later thorough linkgit:git-repack[1] to optimize deltas and pack layout.
+
+Like `git repack`, `git pack-aggregate` takes no locks of its own.  Do
+not run it concurrently with other pack-rewriting maintenance.
+
+OPTIONS
+-------
+
+--once::
+	Run one aggregation pass and exit.  This option is required.
+
+--min-loose=<n>::
+	Skip aggregation of loose objects if fewer than `<n>` are present.
+	Defaults to 5.
+
+--min-packs=<n>::
+	Skip aggregation of small packfiles if fewer than `<n>` aggregatable
+	packs are present.
+	Defaults to 5.
+
+SEE ALSO
+--------
+linkgit:git-repack[1], linkgit:git-pack-objects[1],
+linkgit:gitformat-pack[5]
+
+GIT
+---
+Part of the linkgit:git[1] suite
diff --git a/Documentation/meson.build b/Documentation/meson.build
index f4854f802d455f..c1c7d2bf1ea68b 100644
--- a/Documentation/meson.build
+++ b/Documentation/meson.build
@@ -99,6 +99,7 @@ manpages = {
   'git-name-rev.adoc' : 1,
   'git-notes.adoc' : 1,
   'git-p4.adoc' : 1,
+  'git-pack-aggregate.adoc' : 1,
   'git-pack-objects.adoc' : 1,
   'git-pack-refs.adoc' : 1,
   'git-patch-id.adoc' : 1,
diff --git a/Makefile b/Makefile
index d4b775953d3842..179ce2b33b2161 100644
--- a/Makefile
+++ b/Makefile
@@ -1465,6 +1465,7 @@ BUILTIN_OBJS += builtin/multi-pack-index.o
 BUILTIN_OBJS += builtin/mv.o
 BUILTIN_OBJS += builtin/name-rev.o
 BUILTIN_OBJS += builtin/notes.o
+BUILTIN_OBJS += builtin/pack-aggregate.o
 BUILTIN_OBJS += builtin/pack-objects.o
 ifndef WITH_BREAKING_CHANGES
 BUILTIN_OBJS += builtin/pack-redundant.o
diff --git a/builtin.h b/builtin.h
index 4e47a4ebd30ba3..8fdd14b49360cf 100644
--- a/builtin.h
+++ b/builtin.h
@@ -224,6 +224,7 @@ int cmd_multi_pack_index(int argc, const char **argv, const char *prefix, struct
 int cmd_mv(int argc, const char **argv, const char *prefix, struct repository *repo);
 int cmd_name_rev(int argc, const char **argv, const char *prefix, struct repository *repo);
 int cmd_notes(int argc, const char **argv, const char *prefix, struct repository *repo);
+int cmd_pack_aggregate(int argc, const char **argv, const char *prefix, struct repository *repo);
 int cmd_pack_objects(int argc, const char **argv, const char *prefix, struct repository *repo);
 int cmd_pack_redundant(int argc, const char **argv, const char *prefix, struct repository *repo);
 int cmd_patch_id(int argc, const char **argv, const char *prefix, struct repository *repo);
diff --git a/builtin/pack-aggregate.c b/builtin/pack-aggregate.c
new file mode 100644
index 00000000000000..af791e168685bf
--- /dev/null
+++ b/builtin/pack-aggregate.c
@@ -0,0 +1,483 @@
+#define USE_THE_REPOSITORY_VARIABLE
+
+#include "builtin.h"
+#include "gettext.h"
+#include "hash.h"
+#include "hex.h"
+#include "midx.h"
+#include "object-file.h"
+#include "odb.h"
+#include "oid-array.h"
+#include "packfile.h"
+#include "parse-options.h"
+#include "path.h"
+#include "repository.h"
+#include "run-command.h"
+#include "strbuf.h"
+#include "string-list.h"
+#include "strmap.h"
+#include "strvec.h"
+#include "tempfile.h"
+#include "wrapper.h"
+
+static const char *const pack_aggregate_usage[] = {
+	N_("git pack-aggregate --once [--min-loose=<n>] [--min-packs=<n>]"),
+	NULL
+};
+
+static int has_sidecar(const char *packdir, const char *basename,
+		       const char *ext)
+{
+	struct strbuf buf = STRBUF_INIT;
+	struct stat st;
+	int ret;
+
+	strbuf_addf(&buf, "%s/%s.%s", packdir, basename, ext);
+	ret = !lstat(buf.buf, &st);
+	strbuf_release(&buf);
+	return ret;
+}
+
+static int has_protective_sidecar(const char *packdir, const char *basename)
+{
+	/*
+	 * Ignore packs with sidecars that mean "don't touch me". .baddeltas
+	 * is intentionally absent: rolling those up is the point.
+	 */
+	static const char *exts[] = {
+		"keep", "promisor", "mtimes", "bitmap", NULL
+	};
+	int i;
+
+	for (i = 0; exts[i]; i++)
+		if (has_sidecar(packdir, basename, exts[i]))
+			return 1;
+	return 0;
+}
+
+static int has_idx(const char *packdir, const char *basename)
+{
+	return has_sidecar(packdir, basename, "idx");
+}
+
+/*
+ * Re-read the multi-pack-index (and any incremental layers) and
+ * populate `set` with the basenames of every referenced pack.  The
+ * strset is cleared first so this is safe to call once per cycle.
+ */
+static void refresh_midx_exclusions(struct repository *repo,
+				    struct strset *set)
+{
+	struct odb_source *source;
+
+	strset_clear(set);
+
+	odb_reprepare(repo->objects);
+	for (source = repo->objects->sources; source; source = source->next) {
+		struct odb_source_files *files = odb_source_files_downcast(source);
+		struct multi_pack_index *m = get_multi_pack_index(files->packed);
+		for (; m; m = m->base_midx) {
+			uint32_t i;
+			for (i = 0; i < m->num_packs; i++) {
+				struct strbuf base = STRBUF_INIT;
+				strbuf_addstr(&base, m->pack_names[i]);
+				strbuf_strip_suffix(&base, ".idx");
+				strbuf_strip_suffix(&base, ".pack");
+				strset_add(set, base.buf);
+				strbuf_release(&base);
+			}
+		}
+	}
+}
+
+/* ---------- loose-object pre-pass ---------- */
+
+struct loose_scan {
+	struct oid_array *oids;
+	struct string_list *paths;
+};
+
+static int loose_scan_cb(const struct object_id *oid, const char *path,
+			 void *cb_data)
+{
+	struct loose_scan *data = cb_data;
+
+	oid_array_append(data->oids, oid);
+	string_list_append(data->paths, path);
+	return 0;
+}
+
+static int run_pack_objects(const char *packtmp, int stdin_packs,
+			    const struct strbuf *input,
+			    struct string_list *out_hashes)
+{
+	struct child_process cmd = CHILD_PROCESS_INIT;
+	struct strbuf output = STRBUF_INIT;
+	int ret;
+
+	strvec_push(&cmd.args, "pack-objects");
+	if (stdin_packs)
+		strvec_pushl(&cmd.args, "--stdin-packs",
+			     "--prefer-reused-deltas", NULL);
+	strvec_pushl(&cmd.args,
+		     "--window=0",
+		     "--mark-bad-deltas",
+		     "--delta-base-offset",
+		     "--no-write-bitmap-index",
+		     "--quiet",
+		     packtmp,
+		     NULL);
+	cmd.git_cmd = 1;
+	cmd.clean_on_exit = 1;
+
+	/*
+	 * pipe_command() pumps stdin and stdout concurrently.  Its
+	 * clean-on-exit handling also terminates the child if we exit
+	 * before it does.
+	 */
+	ret = pipe_command(&cmd, input->buf, input->len, &output, 0, NULL, 0);
+
+	if (!ret && output.len) {
+		strbuf_strip_suffix(&output, "\n");
+		string_list_split(out_hashes, output.buf, "\n", -1);
+	}
+
+	strbuf_release(&output);
+	return ret;
+}
+
+static int run_pack_objects_loose(const char *packtmp, struct oid_array *oids,
+				  struct string_list *out_hashes)
+{
+	struct strbuf input = STRBUF_INIT;
+	size_t i;
+	int ret;
+
+	for (i = 0; i < oids->nr; i++)
+		strbuf_addf(&input, "%s\n", oid_to_hex(&oids->oid[i]));
+	ret = run_pack_objects(packtmp, 0, &input, out_hashes);
+	strbuf_release(&input);
+	return ret;
+}
+
+static void unlink_loose_paths(const struct string_list *paths)
+{
+	size_t i;
+
+	for (i = 0; i < paths->nr; i++) {
+		const char *p = paths->items[i].string;
+		if (unlink(p) < 0 && errno != ENOENT)
+			warning_errno(_("could not unlink loose object '%s'"),
+				      p);
+	}
+}
+
+/* ---------- pack aggregation ---------- */
+
+static void collect_pack_candidates(struct repository *repo,
+				    const char *packdir,
+				    struct strset *cycle_exclude,
+				    struct strset *midx_exclude,
+				    struct string_list *candidates)
+{
+	struct packed_git *p;
+	struct strbuf base = STRBUF_INIT;
+
+	repo_for_each_pack(repo, p) {
+		if (!p->pack_local)
+			continue;
+
+		strbuf_reset(&base);
+		strbuf_addstr(&base, pack_basename(p));
+		if (!strbuf_strip_suffix(&base, ".pack"))
+			continue;
+
+		if (strset_contains(cycle_exclude, base.buf))
+			continue;
+		if (strset_contains(midx_exclude, base.buf))
+			continue;
+		if (has_protective_sidecar(packdir, base.buf))
+			continue;
+		if (!has_idx(packdir, base.buf))
+			continue;
+
+		string_list_append(candidates, base.buf);
+	}
+
+	strbuf_release(&base);
+}
+
+static int run_pack_objects_packs(const char *packtmp,
+				  const struct string_list *bases,
+				  struct string_list *out_hashes)
+{
+	struct strbuf input = STRBUF_INIT;
+	size_t i;
+	int ret;
+
+	for (i = 0; i < bases->nr; i++)
+		strbuf_addf(&input, "%s.pack\n", bases->items[i].string);
+	ret = run_pack_objects(packtmp, 1, &input, out_hashes);
+	strbuf_release(&input);
+	return ret;
+}
+
+/*
+ * pack-objects writes its output as <packtmp>-<hash>.<ext>; rename it
+ * into place as <packdir>/pack-<hash>.<ext>.  .idx is renamed last so
+ * a concurrent reader scanning the pack directory never sees a .idx
+ * without its companion .pack.
+ */
+static int install_pack(struct repository *repo, const char *packtmp,
+			const char *packdir, const char *hash)
+{
+	static const char *exts[] = {
+		".pack", ".rev", ".baddeltas", ".idx"
+	};
+	struct tempfile *files[ARRAY_SIZE(exts)] = { 0 };
+	size_t i;
+
+	for (i = 0; i < ARRAY_SIZE(exts); i++) {
+		struct strbuf src = STRBUF_INIT;
+		struct stat st;
+
+		strbuf_addf(&src, "%s-%s%s", packtmp, hash, exts[i]);
+		if (!stat(src.buf, &st)) {
+			files[i] = register_tempfile(src.buf);
+			if (adjust_shared_perm(repo, src.buf)) {
+				error_errno(_("unable to adjust permissions for '%s'"),
+					    src.buf);
+				strbuf_release(&src);
+				goto cleanup;
+			}
+		} else if (errno != ENOENT) {
+			error_errno(_("could not stat '%s'"), src.buf);
+			strbuf_release(&src);
+			goto cleanup;
+		}
+		strbuf_release(&src);
+	}
+
+	for (i = 0; i < ARRAY_SIZE(exts); i++) {
+		struct strbuf dst = STRBUF_INIT;
+
+		if (!files[i])
+			continue;
+
+		strbuf_addf(&dst, "%s/pack-%s%s", packdir, hash, exts[i]);
+		if (rename_tempfile(&files[i], dst.buf)) {
+			error_errno(_("renaming pack to '%s' failed"), dst.buf);
+			strbuf_release(&dst);
+			goto cleanup;
+		}
+		strbuf_release(&dst);
+	}
+	return 0;
+
+cleanup:
+	for (i = 0; i < ARRAY_SIZE(files); i++)
+		if (files[i])
+			delete_tempfile(&files[i]);
+	return -1;
+}
+
+static int install_packs(struct repository *repo, const char *packtmp,
+			 const char *packdir,
+			 const struct string_list *hashes,
+			 struct strset *output_bases)
+{
+	struct string_list_item *item;
+	struct strbuf base = STRBUF_INIT;
+	int ret = 0;
+
+	for_each_string_list_item(item, hashes) {
+		struct object_id oid;
+
+		if (strlen(item->string) != repo->hash_algo->hexsz ||
+		    get_oid_hex_algop(item->string, &oid, repo->hash_algo))
+			return error(_("pack-objects returned an invalid pack hash"));
+	}
+
+	for_each_string_list_item(item, hashes) {
+		if (install_pack(repo, packtmp, packdir, item->string)) {
+			ret = -1;
+			break;
+		}
+		strbuf_reset(&base);
+		strbuf_addf(&base, "pack-%s", item->string);
+		strset_add(output_bases, base.buf);
+	}
+
+	strbuf_release(&base);
+	return ret;
+}
+
+static void unlink_consumed_packs(const char *packdir,
+				  const struct string_list *bases,
+				  struct strset *keep_basenames)
+{
+	static const char *exts[] = {
+		"pack", "idx", "rev", "baddeltas", NULL
+	};
+	size_t i;
+
+	for (i = 0; i < bases->nr; i++) {
+		const char *base = bases->items[i].string;
+		int j;
+
+		/*
+		 * Recheck protective sidecars: a .keep (or similar) may
+		 * have appeared between scan and now, in which case the
+		 * pack must stay.
+		 */
+		if (has_protective_sidecar(packdir, base))
+			continue;
+		/*
+		 * An output can be byte-identical to an input, so deleting
+		 * that input would delete the output too.
+		 */
+		if (strset_contains(keep_basenames, base))
+			continue;
+
+		for (j = 0; exts[j]; j++) {
+			struct strbuf fname = STRBUF_INIT;
+			strbuf_addf(&fname, "%s/%s.%s", packdir, base,
+				    exts[j]);
+			if (unlink(fname.buf) < 0 && errno != ENOENT)
+				warning_errno(_("could not unlink '%s'"),
+					      fname.buf);
+			strbuf_release(&fname);
+		}
+	}
+}
+
+static int run_aggregation(struct repository *repo, const char *packdir,
+			   struct strset *midx_exclude,
+			   int min_loose, int min_packs)
+{
+	struct oid_array loose_oids = OID_ARRAY_INIT;
+	struct string_list loose_paths = STRING_LIST_INIT_DUP;
+	struct loose_scan loose_data = {
+		.oids = &loose_oids,
+		.paths = &loose_paths,
+	};
+	struct strset loose_rollup_exclude = STRSET_INIT;
+	struct strset output_bases = STRSET_INIT;
+	struct string_list candidates = STRING_LIST_INIT_DUP;
+	struct string_list output_hashes = STRING_LIST_INIT_DUP;
+	char *packtmp_loose = NULL;
+	char *packtmp_packs = NULL;
+	int ret = 0;
+
+	/*
+	 * Step 1: bundle local loose objects into new packs and remove
+	 * the on-disk loose copies only after all outputs are installed.
+	 */
+	for_each_loose_file_in_source(repo->objects->sources,
+				      loose_scan_cb, NULL, NULL, &loose_data);
+	if ((int)loose_oids.nr >= min_loose) {
+		packtmp_loose = mkpathdup("%s/.tmp-%d-loose-pack",
+					  packdir, (int)getpid());
+		if (run_pack_objects_loose(packtmp_loose, &loose_oids,
+					   &output_hashes)) {
+			ret = error(_("pack-objects failed during "
+				      "loose-object rollup"));
+			goto out;
+		}
+		if (output_hashes.nr) {
+			if (install_packs(repo, packtmp_loose, packdir,
+					  &output_hashes, &loose_rollup_exclude)) {
+				ret = -1;
+				goto out;
+			}
+			unlink_loose_paths(&loose_paths);
+		}
+	}
+
+	if (strset_get_size(&loose_rollup_exclude) == 1)
+		strset_clear(&loose_rollup_exclude);
+
+	/*
+	 * Step 2: aggregate small packs. Let a single pack produced from loose
+	 * objects participate, but defer multiple packs to avoid copying
+	 * them twice.
+	 * Refresh MIDX exclusions before collecting candidates.
+	 */
+	refresh_midx_exclusions(repo, midx_exclude);
+	collect_pack_candidates(repo, packdir,
+				&loose_rollup_exclude, midx_exclude, &candidates);
+
+	if ((int)candidates.nr < min_packs)
+		goto out;
+
+	packtmp_packs = mkpathdup("%s/.tmp-%d-pack",
+				  packdir, (int)getpid());
+	string_list_clear(&output_hashes, 0);
+	if (run_pack_objects_packs(packtmp_packs, &candidates,
+				   &output_hashes)) {
+		ret = error(_("pack-objects failed during "
+			      "pack aggregation"));
+		goto out;
+	}
+	if (output_hashes.nr) {
+		if (install_packs(repo, packtmp_packs, packdir,
+				  &output_hashes, &output_bases)) {
+			ret = -1;
+			goto out;
+		}
+		unlink_consumed_packs(packdir, &candidates, &output_bases);
+	}
+
+out:
+	free(packtmp_loose);
+	free(packtmp_packs);
+	string_list_clear(&output_hashes, 0);
+	strset_clear(&loose_rollup_exclude);
+	strset_clear(&output_bases);
+	string_list_clear(&candidates, 0);
+	oid_array_clear(&loose_oids);
+	string_list_clear(&loose_paths, 0);
+	return ret;
+}
+
+int cmd_pack_aggregate(int argc, const char **argv,
+		       const char *prefix, struct repository *repo)
+{
+	int min_packs = 5;
+	int min_loose = 5;
+	int once = 0;
+	struct option options[] = {
+		OPT_BOOL(0, "once", &once,
+			 N_("run a single cycle and exit")),
+		OPT_INTEGER(0, "min-loose", &min_loose,
+			    N_("skip loose-object rollup if fewer "
+			       "candidates (default 5)")),
+		OPT_INTEGER(0, "min-packs", &min_packs,
+			    N_("skip pack aggregation if fewer "
+			       "candidates (default 5)")),
+		OPT_END(),
+	};
+	struct strset midx_exclude = STRSET_INIT;
+	char *packdir;
+	int ret = 0;
+
+	argc = parse_options(argc, argv, prefix, options,
+			     pack_aggregate_usage, 0);
+	if (argc > 0)
+		usage_with_options(pack_aggregate_usage, options);
+	if (!once)
+		die(_("--once is required"));
+	if (min_loose < 1)
+		die(_("--min-loose must be at least 1"));
+	if (min_packs < 1)
+		die(_("--min-packs must be at least 1"));
+
+	packdir = mkpathdup("%s/pack", repo_get_object_directory(repo));
+
+	ret = run_aggregation(repo, packdir, &midx_exclude,
+			      min_loose, min_packs);
+
+	strset_clear(&midx_exclude);
+	free(packdir);
+	return ret ? 1 : 0;
+}
diff --git a/command-list.txt b/command-list.txt
index 21b802c42026b3..95fc35c2e8dc7c 100644
--- a/command-list.txt
+++ b/command-list.txt
@@ -148,6 +148,7 @@ git-mv                                  mainporcelain           worktree
 git-name-rev                            plumbinginterrogators
 git-notes                               mainporcelain
 git-p4                                  foreignscminterface
+git-pack-aggregate                      plumbingmanipulators
 git-pack-objects                        plumbingmanipulators
 git-pack-redundant                      plumbinginterrogators
 git-pack-refs                           ancillarymanipulators
diff --git a/git.c b/git.c
index d7b5f88e52ae87..85c424c2d71501 100644
--- a/git.c
+++ b/git.c
@@ -621,6 +621,7 @@ static struct cmd_struct commands[] = {
 	{ "mv", cmd_mv, RUN_SETUP | NEED_WORK_TREE },
 	{ "name-rev", cmd_name_rev, RUN_SETUP },
 	{ "notes", cmd_notes, RUN_SETUP },
+	{ "pack-aggregate", cmd_pack_aggregate, RUN_SETUP },
 	{ "pack-objects", cmd_pack_objects, RUN_SETUP },
 #ifndef WITH_BREAKING_CHANGES
 	{ "pack-redundant", cmd_pack_redundant, RUN_SETUP | NO_PARSEOPT | DEPRECATED },
diff --git a/meson.build b/meson.build
index 0a95d90d211fd6..d9971eb708dd68 100644
--- a/meson.build
+++ b/meson.build
@@ -677,6 +677,7 @@ builtin_sources = [
   'builtin/mv.c',
   'builtin/name-rev.c',
   'builtin/notes.c',
+  'builtin/pack-aggregate.c',
   'builtin/pack-objects.c',
   'builtin/pack-refs.c',
   'builtin/patch-id.c',
diff --git a/t/meson.build b/t/meson.build
index 90d4c7c39708f8..600b8ba61ef791 100644
--- a/t/meson.build
+++ b/t/meson.build
@@ -639,6 +639,7 @@ integration_tests = [
   't5333-pseudo-merge-bitmaps.sh',
   't5334-incremental-multi-pack-index.sh',
   't5335-compact-multi-pack-index.sh',
+  't5336-pack-aggregate.sh',
   't5337-pack-baddeltas.sh',
   't5351-unpack-large-objects.sh',
   't5400-send-pack.sh',
diff --git a/t/t5336-pack-aggregate.sh b/t/t5336-pack-aggregate.sh
new file mode 100755
index 00000000000000..39846a827f328d
--- /dev/null
+++ b/t/t5336-pack-aggregate.sh
@@ -0,0 +1,253 @@
+#!/bin/sh
+
+test_description='`git pack-aggregate` rolls up small packs and loose objects'
+
+. ./test-lib.sh
+
+# Build N tiny packs in objects/pack/, each containing one distinct
+# blob.  Echoes the basenames (without .pack) one per line.
+build_n_packs () {
+	n=$1 &&
+	mkdir -p .git/objects/pack &&
+	i=0 &&
+	while test $i -lt "$n"
+	do
+		blob=$(echo "content-$i-$$" | git hash-object -w --stdin) &&
+		echo "$blob" |
+		git pack-objects --window=0 .git/objects/pack/pack \
+			>pack_hash &&
+		hash=$(cat pack_hash) &&
+		test -n "$hash" &&
+		test_path_is_file .git/objects/pack/pack-${hash}.pack &&
+		git prune-packed &&
+		echo "pack-$hash" &&
+		i=$((i + 1)) || return 1
+	done
+}
+
+# Create N loose objects in the repository.  Echoes the OIDs one per
+# line.
+build_n_loose () {
+	n=$1 &&
+	i=0 &&
+	while test $i -lt "$n"
+	do
+		echo "loose-$i-$$" | git hash-object -w --stdin &&
+		i=$((i + 1)) || return 1
+	done
+}
+
+count_packs () {
+	ls .git/objects/pack/pack-*.pack 2>/dev/null | wc -l
+}
+
+count_baddeltas () {
+	ls .git/objects/pack/pack-*.baddeltas 2>/dev/null | wc -l
+}
+
+count_loose () {
+	find .git/objects \
+		-type f \
+		-name '[0-9a-f]*' \
+		-not -path '.git/objects/pack/*' \
+		-not -path '.git/objects/info/*' |
+	wc -l
+}
+
+test_expect_success 'setup an empty repo' '
+	git init repo
+'
+
+test_expect_success '--once is required' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		test_must_fail git pack-aggregate 2>err &&
+		test_grep -- "--once is required" err
+	)
+'
+
+test_expect_success '--once below --min-packs is a no-op for packs' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		build_n_packs 3 >/dev/null &&
+		test 3 -eq "$(count_packs)" &&
+		git pack-aggregate --once --min-loose=1000 &&
+		test 3 -eq "$(count_packs)" &&
+		test 0 -eq "$(count_baddeltas)"
+	)
+'
+
+test_expect_success '--once aggregates above --min-packs' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		build_n_packs 5 >packs.txt &&
+		test 5 -eq "$(count_packs)" &&
+		git pack-aggregate --once \
+			--min-loose=1000 --min-packs=5 &&
+		test 1 -eq "$(count_packs)" &&
+		test 1 -eq "$(count_baddeltas)" &&
+		git fsck
+	)
+'
+
+test_expect_success '--once prefers an existing delta over a duplicate base copy' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		# The shared seed makes o.bin a prefix of x.bin, so O can be
+		# stored as a small delta against X.
+		test-tool genrandom foo 8192 >x.bin &&
+		test-tool genrandom foo 4096 >o.bin &&
+		x=$(git hash-object -w x.bin) &&
+		o=$(git hash-object -w o.bin) &&
+
+		echo "$o" |
+		git pack-objects --window=0 .git/objects/pack/pack >base.hash &&
+		printf "%s\n%s\n" "$x" "$o" |
+		git pack-objects .git/objects/pack/pack >delta.hash &&
+		git prune-packed &&
+
+		delta=".git/objects/pack/pack-$(cat delta.hash)" &&
+		git verify-pack -v "$delta.idx" >before &&
+		# Delta entries end with their base OID; full-object entries do not.
+		test_grep "^$o .* $x$" before &&
+
+		# The base copy must be encountered before the delta copy.
+		test-tool chmtime -200 "$delta.pack" &&
+		git pack-aggregate --once --min-packs=2 --min-loose=1000 &&
+		test 1 -eq "$(count_packs)" &&
+		git verify-pack -v .git/objects/pack/pack-*.idx >after &&
+		test_grep "^$o .* $x$" after
+	)
+'
+
+for input_mode in loose packed
+do
+	test_expect_success "pack.packSizeLimit splits $input_mode aggregation outputs" '
+		test_when_finished "rm -fr work" &&
+		cp -R repo work &&
+		(
+			cd work &&
+			# Each blob fits in 1 MiB, but no pair does.
+			for i in 1 2 3
+			do
+				test-tool genrandom "split-$i" 716800 >blob &&
+				oid=$(git hash-object -w blob) &&
+				test-tool chmtime -1 \
+					".git/objects/$(test_oid_to_path "$oid")" &&
+				echo "$oid" || return 1
+			done >oids &&
+			if test "$input_mode" = packed
+			then
+				git pack-objects --window=0 .git/objects/pack/pack \
+					<oids >input.hash &&
+				git prune-packed
+			fi &&
+			sort oids >expect &&
+
+			# On the second pass, all three output names match inputs.
+			for pass in 1 2
+			do
+				git -c pack.packSizeLimit=1m pack-aggregate --once \
+					--min-loose=1 --min-packs=1 &&
+				test 3 -eq "$(count_packs)" &&
+				test 3 -eq "$(count_baddeltas)" &&
+				test 0 -eq "$(count_loose)" &&
+				find .git/objects/pack -name ".tmp-*" >temporary &&
+				test_must_be_empty temporary &&
+				git verify-pack .git/objects/pack/pack-*.idx &&
+				git cat-file --batch-all-objects \
+					--batch-check="%(objectname)" >actual.raw &&
+				sort actual.raw >actual &&
+				test_cmp expect actual || return 1
+			done
+		)
+	'
+done
+
+test_expect_success 'sidecar-marked packs are skipped' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		build_n_packs 6 >packs.txt &&
+		first=$(head -n 1 packs.txt) &&
+		>.git/objects/pack/${first}.keep &&
+		git pack-aggregate --once \
+			--min-loose=1000 --min-packs=4 &&
+		test_path_is_file .git/objects/pack/${first}.pack &&
+		test_path_is_file .git/objects/pack/${first}.keep &&
+		# 1 kept + 1 aggregate = 2 packs total.
+		test 2 -eq "$(count_packs)" &&
+		git fsck
+	)
+'
+
+test_expect_success 'aggregate re-rolls up .baddeltas packs' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		build_n_packs 5 >/dev/null &&
+		git pack-aggregate --once \
+			--min-loose=1000 --min-packs=5 &&
+		test 1 -eq "$(count_packs)" &&
+		test 1 -eq "$(count_baddeltas)" &&
+		# Now add more small packs and aggregate again.  The
+		# previous .baddeltas pack should NOT be protected (we
+		# want to keep rolling them up).
+		build_n_packs 4 >/dev/null &&
+		test 5 -eq "$(count_packs)" &&
+		git pack-aggregate --once \
+			--min-loose=1000 --min-packs=5 &&
+		test 1 -eq "$(count_packs)" &&
+		test 1 -eq "$(count_baddeltas)" &&
+		git fsck
+	)
+'
+
+test_expect_success 'aggregates loose objects above --min-loose' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		build_n_loose 5 >/dev/null &&
+		test 5 -eq "$(count_loose)" &&
+		git pack-aggregate --once \
+			--min-loose=1 --min-packs=1000 &&
+		test 0 -eq "$(count_loose)" &&
+		test 1 -eq "$(count_packs)" &&
+		test 1 -eq "$(count_baddeltas)" &&
+		git fsck
+	)
+'
+
+test_expect_success 'loose then pack aggregation in one cycle' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		build_n_loose 5 >/dev/null &&
+		build_n_packs 5 >/dev/null &&
+		test 5 -eq "$(count_loose)" &&
+		test 5 -eq "$(count_packs)" &&
+		git pack-aggregate --once \
+			--min-loose=1 --min-packs=5 &&
+		# Step 1 creates one pack from the loose objects, then
+		# step 2 sweeps that pack plus the five existing ones
+		# into a single aggregate.
+		test 0 -eq "$(count_loose)" &&
+		test 1 -eq "$(count_packs)" &&
+		test 1 -eq "$(count_baddeltas)" &&
+		git fsck
+	)
+'
+
+test_done

From 44c494c97bcfc865669f70b0a910af6bd6323b52 Mon Sep 17 00:00:00 2001
From: Elijah Newren <newren@gmail.com>
Date: Wed, 10 Jun 2026 23:11:39 -0700
Subject: [PATCH 08/18] repack: demote .baddeltas packs into geometric rollup

A .baddeltas pack can sit above the geometric split indefinitely,
so pack-objects never gets a chance to reconsider its delta layout.
Include marked packs in the rollup even when their size would
otherwise keep them out.

If their inclusion breaks the estimated progression,
include one more eligible pack, without consuming smaller candidates
unnecessarily.  Keep the retained region sorted for
`pack_geometry_preferred_pack()`.

`.keep`-marked packs are still excluded from the rollup by the
existing `pack_kept_objects` / `remove_redundant_packs` paths, so
a user who really wants to pin a `.baddeltas` pack in place has
that escape hatch.

Promisor packs are intentionally not touched: the aggregator skips
them, and rolling a promisor pack up into a normal pack would
silently strip its "objects may live remotely" semantics.

Add tests for forced demotion, geometric balancing, and preservation
of unaffected packs.

Assisted-by: Claude Opus 4.7 & GPT-5.6 Sol
Signed-off-by: Elijah Newren <newren@gmail.com>
---
 Documentation/git-repack.adoc |   3 +
 repack-geometry.c             |  94 ++++++++++++++++++++
 t/t5336-pack-aggregate.sh     | 163 ++++++++++++++++++++++++++++++++++
 3 files changed, 260 insertions(+)

diff --git a/Documentation/git-repack.adoc b/Documentation/git-repack.adoc
index a1f9e64f668750..2e4e79cf3921bc 100644
--- a/Documentation/git-repack.adoc
+++ b/Documentation/git-repack.adoc
@@ -274,6 +274,9 @@ picks the smallest set of packfiles such that as many of the larger
 packfiles (by count of objects contained in that pack) may be left
 intact.
 +
+Selection also accounts for packs forced into the roll-up by `.baddeltas`
+markers, including another pack if needed to preserve the progression.
++
 Unlike other repack modes, the set of objects to pack is determined
 uniquely by the set of packs being "rolled-up"; in other words, the
 packs determined to need to be combined in order to restore a geometric
diff --git a/repack-geometry.c b/repack-geometry.c
index 15b34129506d2a..de3f49ad824700 100644
--- a/repack-geometry.c
+++ b/repack-geometry.c
@@ -110,6 +110,99 @@ void pack_geometry_init(struct pack_geometry *geometry,
 	strbuf_release(&buf);
 }
 
+static uint32_t find_rebalancing_pack(struct packed_git **pack,
+				    uint32_t pack_nr, uint64_t total_size,
+				    int split_factor)
+{
+	uint32_t i;
+	int rebalance = 0;
+
+	if (split_factor < 2)
+		return pack_nr;
+
+	for (i = 0; i < pack_nr; i++) {
+		uint64_t size = pack_geometry_weight(pack[i]);
+		uint64_t combined_size, next_size;
+
+		if (!rebalance) {
+			if (size <= total_size / split_factor)
+				continue;
+			if (total_size <= size / split_factor)
+				break;
+			rebalance = 1;
+		}
+
+		/*
+		 * Smaller kept packs fit below this pack's estimated output.
+		 * Evaluate each candidate alone, rather than accumulating them.
+		 */
+		combined_size = u64_add(total_size, size);
+		if (i + 1 == pack_nr)
+			return i;
+		next_size = pack_geometry_weight(pack[i + 1]);
+		if (combined_size <= next_size / split_factor)
+			return i;
+	}
+	return pack_nr;
+}
+
+/*
+ * Roll up marked packs even above the normal geometric split.
+ * Include another pack if needed to preserve the progression,
+ * and keep retained packs sorted for preferred-pack selection.
+ */
+static void demote_bad_delta_packs(struct pack_geometry *geometry)
+{
+	struct packed_git **demoted, **retained;
+	uint32_t d_nr = 0, r_nr = 0, kept_nr;
+	uint32_t k;
+	uint64_t total_size = 0;
+
+	if (geometry->split == geometry->pack_nr)
+		return;
+
+	kept_nr = geometry->pack_nr - geometry->split;
+	for (k = geometry->split; k < geometry->pack_nr; k++) {
+		if (geometry->pack[k]->has_bad_deltas)
+			d_nr++;
+	}
+	if (!d_nr)
+		return;
+
+	ALLOC_ARRAY(demoted, st_add(d_nr, 1));
+	ALLOC_ARRAY(retained, kept_nr - d_nr);
+	for (k = 0; k < geometry->split; k++)
+		total_size = u64_add(total_size,
+				    pack_geometry_weight(geometry->pack[k]));
+
+	d_nr = 0;
+	for (k = geometry->split; k < geometry->pack_nr; k++) {
+		struct packed_git *p = geometry->pack[k];
+
+		if (p->has_bad_deltas) {
+			demoted[d_nr++] = p;
+			total_size = u64_add(total_size,
+					    pack_geometry_weight(p));
+		} else
+			retained[r_nr++] = p;
+	}
+
+	k = find_rebalancing_pack(retained, r_nr, total_size,
+				  geometry->split_factor);
+	if (k < r_nr) {
+		demoted[d_nr++] = retained[k];
+		MOVE_ARRAY(retained + k, retained + k + 1, r_nr - k - 1);
+		r_nr--;
+	}
+
+	COPY_ARRAY(&geometry->pack[geometry->split], demoted, d_nr);
+	COPY_ARRAY(&geometry->pack[geometry->split + d_nr], retained, r_nr);
+	geometry->split += d_nr;
+
+	free(demoted);
+	free(retained);
+}
+
 static uint32_t compute_pack_geometry_split(struct packed_git **pack, size_t pack_nr,
 					    int split_factor)
 {
@@ -192,6 +285,7 @@ void pack_geometry_split(struct pack_geometry *geometry)
 {
 	geometry->split = compute_pack_geometry_split(geometry->pack, geometry->pack_nr,
 						      geometry->split_factor);
+	demote_bad_delta_packs(geometry);
 	geometry->promisor_split = compute_pack_geometry_split(geometry->promisor_pack,
 							       geometry->promisor_pack_nr,
 							       geometry->split_factor);
diff --git a/t/t5336-pack-aggregate.sh b/t/t5336-pack-aggregate.sh
index 39846a827f328d..6af76243ffba45 100755
--- a/t/t5336-pack-aggregate.sh
+++ b/t/t5336-pack-aggregate.sh
@@ -250,4 +250,167 @@ test_expect_success 'loose then pack aggregation in one cycle' '
 	)
 '
 
+# ---- geometric .baddeltas demotion ----
+
+# Helper for the geometric tests: pack N unique blobs (default 1) into
+# one packfile.  The `tag` parameter must differ between callers so
+# that the blob contents do not collide with one another (otherwise
+# `git pack-objects --stdin-packs` would see the "rollup" objects
+# already present in the kept pack and emit nothing).
+make_unique_pack () {
+	tag=$1 &&
+	n=${2:-1} &&
+	i=0 &&
+	while test "$i" -lt "$n"
+	do
+		echo "unique-${tag}-${i}-$$" | git hash-object -w --stdin &&
+		i=$((i + 1)) || return 1
+	done >oids &&
+	git pack-objects --window=0 .git/objects/pack/pack \
+		<oids >pack_hash &&
+	git prune-packed
+}
+
+for scenario in middle already-geometric largest boundary larger-candidate \
+	multiple-markers factor-three factor-one
+do
+	test_expect_success "geometric demotion preserves spacing ($scenario)" '
+		test_when_finished "rm -fr work" &&
+		cp -R repo work &&
+		(
+			cd work &&
+			factor=2 &&
+			case "$scenario" in
+			middle)
+				sizes="1 1 4 8 16" &&
+				marked="8" &&
+				expected="4 26"
+				;;
+			already-geometric|factor-one)
+				sizes="1 2 4 8 16" &&
+				marked="4" &&
+				expected="$sizes" &&
+				if test "$scenario" = factor-one
+				then
+					factor=1
+				fi
+				;;
+			largest)
+				sizes="1 2 4 8 16" &&
+				marked="16" &&
+				expected="$sizes"
+				;;
+			boundary)
+				sizes="1 1 4 8 20" &&
+				marked="8" &&
+				expected="4 10 20"
+				;;
+			larger-candidate)
+				sizes="1 1 4 8 16 32 96" &&
+				marked="8" &&
+				expected="4 16 42 96"
+				;;
+			multiple-markers)
+				sizes="1 2 4 8 16 32 64" &&
+				marked="4 16" &&
+				expected="1 2 8 32 84"
+				;;
+			factor-three)
+				factor=3 &&
+				sizes="1 1 6 18 54" &&
+				marked="18" &&
+				expected="6 74"
+				;;
+			esac &&
+			batch=0 &&
+			for size in $sizes
+			do
+				make_unique_pack "batch-$batch" "$size" &&
+				hash=$(cat pack_hash) &&
+				pack_base=".git/objects/pack/pack-$hash" &&
+				case " $marked " in
+				*" $size "*)
+					>"$pack_base.baddeltas"
+					;;
+				esac &&
+				batch=$((batch + 1)) || return 1
+			done &&
+			git cat-file --batch-all-objects \
+				--batch-check="%(objectname)" >before &&
+			git repack -d --geometric="$factor" &&
+			for idx in .git/objects/pack/pack-*.idx
+			do
+				git show-index <"$idx" >index &&
+				awk "END { print NR }" index || return 1
+			done >counts &&
+			sort -n counts >actual &&
+			for size in $expected
+			do
+				echo "$size" || return 1
+			done >expect &&
+			test_cmp expect actual &&
+			test 0 -eq "$(count_baddeltas)" &&
+			git cat-file --batch-all-objects \
+				--batch-check="%(objectname)" >after &&
+			test_cmp before after &&
+			git fsck
+		)
+	'
+done
+
+test_expect_success 'geometric repack demotes .baddeltas packs into rollup' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		# Build several small packs and consolidate them into
+		# one larger pack that would normally sit above the
+		# geometric split.
+		build_n_packs 8 >/dev/null &&
+		git repack -d --geometric=2 &&
+		test 1 -eq "$(count_packs)" &&
+		big=$(ls .git/objects/pack/pack-*.pack) &&
+		# Drop a .baddeltas marker on it (simulating an
+		# aggregator output).
+		>"${big%.pack}.baddeltas" &&
+		test 1 -eq "$(count_baddeltas)" &&
+		# Add small packs that are individually far smaller
+		# than the big one; ordinarily the big pack would be
+		# kept above the geometric split.
+		make_unique_pack a &&
+		make_unique_pack b &&
+		make_unique_pack c &&
+		test 4 -eq "$(count_packs)" &&
+		# With the .baddeltas demotion, the big pack is rolled
+		# up despite being above the natural split, and the
+		# resulting pack carries no .baddeltas marker.
+		git repack -d --geometric=2 &&
+		test 1 -eq "$(count_packs)" &&
+		test 0 -eq "$(count_baddeltas)" &&
+		git fsck
+	)
+'
+
+test_expect_success 'geometric repack leaves non-baddeltas packs above the split alone' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		build_n_packs 8 >/dev/null &&
+		git repack -d --geometric=2 &&
+		test 1 -eq "$(count_packs)" &&
+		# Add small packs; without any .baddeltas marker the
+		# big pack should be preserved above the split.
+		make_unique_pack a &&
+		make_unique_pack b &&
+		make_unique_pack c &&
+		test 4 -eq "$(count_packs)" &&
+		git repack -d --geometric=2 &&
+		# 1 kept big pack + 1 newly-aggregated rollup = 2.
+		test 2 -eq "$(count_packs)" &&
+		test 0 -eq "$(count_baddeltas)" &&
+		git fsck
+	)
+'
+
 test_done

From 28eebb5c2bcb1e5399a4db684f485fd946da3524 Mon Sep 17 00:00:00 2001
From: Elijah Newren <newren@gmail.com>
Date: Mon, 13 Jul 2026 10:55:23 -0700
Subject: [PATCH 09/18] pack-aggregate: cap aggregation by pack object count

`git pack-aggregate` can select packs with millions of objects outside
the multi-pack-index, even in otherwise well-maintained repositories.
Enumerating those objects and rebuilding their indexes costs work for
little reduction in pack count.

Add a `--max-objects=<n>` cap (and matching `pack.aggregateMaxObjects`
config, default 100000, 0 to disable) to bound that per-object work.
Leave packs above the cap untouched.

Estimate the object count from the size of the pack's `.idx` file,
reusing the `lstat()` already needed to confirm it exists.  This avoids
opening and mapping every candidate index just to read its object count,
saving work and avoiding exhaustion of `vm.max_map_count` when there are
many packs.

Assisted-by: Claude Opus 4.8 & GPT-5.6 Sol
Signed-off-by: Elijah Newren <newren@gmail.com>
---
 Documentation/config/pack.adoc        |  4 ++
 Documentation/git-pack-aggregate.adoc | 14 ++++
 builtin/pack-aggregate.c              | 66 ++++++++++++++++---
 t/t5336-pack-aggregate.sh             | 92 +++++++++++++++++++++++++++
 4 files changed, 168 insertions(+), 8 deletions(-)

diff --git a/Documentation/config/pack.adoc b/Documentation/config/pack.adoc
index 22384c2d2f0773..16c62a539f10d8 100644
--- a/Documentation/config/pack.adoc
+++ b/Documentation/config/pack.adoc
@@ -39,6 +39,10 @@ is set to "multi", reuse parts of just the bitmapped packfile. This
 can reduce memory and CPU usage to serve fetches, but might result in
 sending a slightly larger pack. Defaults to true.
 
+pack.aggregateMaxObjects::
+	Default for linkgit:git-pack-aggregate[1]'s `--max-objects`
+	option. Defaults to `100000`; see that option for details.
+
 pack.island::
 	An extended regular expression configuring a set of delta
 	islands. See "DELTA ISLANDS" in linkgit:git-pack-objects[1]
diff --git a/Documentation/git-pack-aggregate.adoc b/Documentation/git-pack-aggregate.adoc
index 66a3115c404204..29794a6eed81f3 100644
--- a/Documentation/git-pack-aggregate.adoc
+++ b/Documentation/git-pack-aggregate.adoc
@@ -10,6 +10,7 @@ SYNOPSIS
 --------
 [verse]
 'git pack-aggregate' --once [--min-loose=<n>] [--min-packs=<n>]
+                   [--max-objects=<n>]
 
 DESCRIPTION
 -----------
@@ -62,6 +63,19 @@ OPTIONS
 	packs are present.
 	Defaults to 5.
 
+--max-objects=<n>::
+	Skip any pack that contains more than `<n>` objects, leaving it
+	untouched by step 2.  The object count is estimated cheaply from
+	the size of the pack's `.idx` file rather than by opening it.
+	This keeps `git pack-aggregate` focused on rolling up the small
+	packs it is meant for, instead of repacking a large base pack
+	(which would amount to a near-full repack).  Defaults to the
+	`pack.aggregateMaxObjects` configuration value, or 100000 if that
+	is unset.  A value of `0` disables the limit.  Note that packs
+	already referenced by the multi-pack-index are excluded
+	regardless of this setting, so on a normally-maintained
+	repository the large base pack is skipped anyway.
+
 SEE ALSO
 --------
 linkgit:git-repack[1], linkgit:git-pack-objects[1],
diff --git a/builtin/pack-aggregate.c b/builtin/pack-aggregate.c
index af791e168685bf..4b62f7db563931 100644
--- a/builtin/pack-aggregate.c
+++ b/builtin/pack-aggregate.c
@@ -1,6 +1,7 @@
 #define USE_THE_REPOSITORY_VARIABLE
 
 #include "builtin.h"
+#include "config.h"
 #include "gettext.h"
 #include "hash.h"
 #include "hex.h"
@@ -21,10 +22,13 @@
 #include "wrapper.h"
 
 static const char *const pack_aggregate_usage[] = {
-	N_("git pack-aggregate --once [--min-loose=<n>] [--min-packs=<n>]"),
+	N_("git pack-aggregate --once [--min-loose=<n>] [--min-packs=<n>]\n"
+	   "                         [--max-objects=<n>]"),
 	NULL
 };
 
+#define DEFAULT_MAX_OBJECTS 100000
+
 static int has_sidecar(const char *packdir, const char *basename,
 		       const char *ext)
 {
@@ -55,9 +59,39 @@ static int has_protective_sidecar(const char *packdir, const char *basename)
 	return 0;
 }
 
-static int has_idx(const char *packdir, const char *basename)
+static int idx_file_size(const char *packdir, const char *basename,
+			 off_t *size)
+{
+	struct strbuf buf = STRBUF_INIT;
+	struct stat st;
+	int ret;
+
+	strbuf_addf(&buf, "%s/%s.idx", packdir, basename);
+	ret = !lstat(buf.buf, &st);
+	if (ret)
+		*size = st.st_size;
+	strbuf_release(&buf);
+	return ret;
+}
+
+/*
+ * Convert the object-count cap to a v2 index size for comparison with
+ * idx_file_size().  For N objects:
+ *
+ *   size = 8 (header) + 1024 (fanout) + N*(rawsz + 8) + 2*rawsz (trailer)
+ *
+ * Ignore the extra 8 bytes per offset >= 2GiB.  This overestimates N
+ * for packs with large offsets, favoring skipping borderline packs.
+ * A cap of 0 disables the limit and returns 0.
+ */
+static off_t max_objects_to_idx_size(const struct git_hash_algo *algo,
+				     int max_objects)
 {
-	return has_sidecar(packdir, basename, "idx");
+	off_t rawsz = algo->rawsz;
+
+	if (!max_objects)
+		return 0;
+	return 8 + 1024 + 2 * rawsz + (rawsz + 8) * (off_t)max_objects;
 }
 
 /*
@@ -178,10 +212,12 @@ static void collect_pack_candidates(struct repository *repo,
 				    const char *packdir,
 				    struct strset *cycle_exclude,
 				    struct strset *midx_exclude,
-				    struct string_list *candidates)
+				    struct string_list *candidates,
+				    off_t max_idx_size)
 {
 	struct packed_git *p;
 	struct strbuf base = STRBUF_INIT;
+	off_t idx_size = 0;
 
 	repo_for_each_pack(repo, p) {
 		if (!p->pack_local)
@@ -198,7 +234,9 @@ static void collect_pack_candidates(struct repository *repo,
 			continue;
 		if (has_protective_sidecar(packdir, base.buf))
 			continue;
-		if (!has_idx(packdir, base.buf))
+		if (!idx_file_size(packdir, base.buf, &idx_size))
+			continue;
+		if (max_idx_size && idx_size > max_idx_size)
 			continue;
 
 		string_list_append(candidates, base.buf);
@@ -353,7 +391,7 @@ static void unlink_consumed_packs(const char *packdir,
 
 static int run_aggregation(struct repository *repo, const char *packdir,
 			   struct strset *midx_exclude,
-			   int min_loose, int min_packs)
+			   int min_loose, int min_packs, int max_objects)
 {
 	struct oid_array loose_oids = OID_ARRAY_INIT;
 	struct string_list loose_paths = STRING_LIST_INIT_DUP;
@@ -405,7 +443,9 @@ static int run_aggregation(struct repository *repo, const char *packdir,
 	 */
 	refresh_midx_exclusions(repo, midx_exclude);
 	collect_pack_candidates(repo, packdir,
-				&loose_rollup_exclude, midx_exclude, &candidates);
+				&loose_rollup_exclude, midx_exclude, &candidates,
+				max_objects_to_idx_size(repo->hash_algo,
+							max_objects));
 
 	if ((int)candidates.nr < min_packs)
 		goto out;
@@ -445,6 +485,7 @@ int cmd_pack_aggregate(int argc, const char **argv,
 {
 	int min_packs = 5;
 	int min_loose = 5;
+	int max_objects = -1;
 	int once = 0;
 	struct option options[] = {
 		OPT_BOOL(0, "once", &once,
@@ -455,6 +496,9 @@ int cmd_pack_aggregate(int argc, const char **argv,
 		OPT_INTEGER(0, "min-packs", &min_packs,
 			    N_("skip pack aggregation if fewer "
 			       "candidates (default 5)")),
+		OPT_INTEGER(0, "max-objects", &max_objects,
+			    N_("skip packs with more than this many "
+			       "objects (0 for no limit)")),
 		OPT_END(),
 	};
 	struct strset midx_exclude = STRSET_INIT;
@@ -472,10 +516,16 @@ int cmd_pack_aggregate(int argc, const char **argv,
 	if (min_packs < 1)
 		die(_("--min-packs must be at least 1"));
 
+	if (max_objects < 0 &&
+	    repo_config_get_int(repo, "pack.aggregatemaxobjects", &max_objects))
+		max_objects = DEFAULT_MAX_OBJECTS;
+	if (max_objects < 0)
+		die(_("pack.aggregateMaxObjects cannot be negative"));
+
 	packdir = mkpathdup("%s/pack", repo_get_object_directory(repo));
 
 	ret = run_aggregation(repo, packdir, &midx_exclude,
-			      min_loose, min_packs);
+			      min_loose, min_packs, max_objects);
 
 	strset_clear(&midx_exclude);
 	free(packdir);
diff --git a/t/t5336-pack-aggregate.sh b/t/t5336-pack-aggregate.sh
index 6af76243ffba45..8610fdad562f42 100755
--- a/t/t5336-pack-aggregate.sh
+++ b/t/t5336-pack-aggregate.sh
@@ -37,6 +37,26 @@ build_n_loose () {
 	done
 }
 
+# Build a single pack containing N distinct blobs.  Echoes the pack
+# basename (without .pack).
+build_big_pack () {
+	n=$1 &&
+	mkdir -p .git/objects/pack &&
+	i=0 &&
+	while test $i -lt "$n"
+	do
+		echo "big-$i-$$" | git hash-object -w --stdin &&
+		i=$((i + 1)) || return 1
+	done >big_oids &&
+	git pack-objects --window=0 .git/objects/pack/pack \
+		<big_oids >big_hash &&
+	hash=$(cat big_hash) &&
+	test -n "$hash" &&
+	test_path_is_file .git/objects/pack/pack-${hash}.pack &&
+	git prune-packed &&
+	echo "pack-$hash"
+}
+
 count_packs () {
 	ls .git/objects/pack/pack-*.pack 2>/dev/null | wc -l
 }
@@ -190,6 +210,78 @@ test_expect_success 'sidecar-marked packs are skipped' '
 	)
 '
 
+test_expect_success '--max-objects skips packs above the object-count limit' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		big=$(build_big_pack 20) &&
+		build_n_packs 5 >/dev/null &&
+		test 6 -eq "$(count_packs)" &&
+		# The big pack (20 objects) is above the cap; the five
+		# single-object packs are below it and get rolled up.
+		git pack-aggregate --once \
+			--min-loose=1000 --min-packs=1 --max-objects=10 &&
+		test_path_is_file .git/objects/pack/${big}.pack &&
+		# 1 preserved big pack + 1 aggregate = 2 packs total.
+		test 2 -eq "$(count_packs)" &&
+		test 1 -eq "$(count_baddeltas)" &&
+		git fsck
+	)
+'
+
+test_expect_success '--max-objects=0 disables the object-count limit' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		big=$(build_big_pack 20) &&
+		build_n_packs 5 >/dev/null &&
+		test 6 -eq "$(count_packs)" &&
+		# With no cap, the big pack is aggregated along with the
+		# small ones into a single pack.
+		git pack-aggregate --once \
+			--min-loose=1000 --min-packs=1 --max-objects=0 &&
+		test_path_is_missing .git/objects/pack/${big}.pack &&
+		test 1 -eq "$(count_packs)" &&
+		git fsck
+	)
+'
+
+test_expect_success 'pack.aggregateMaxObjects supplies the default limit' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		big=$(build_big_pack 20) &&
+		build_n_packs 5 >/dev/null &&
+		test 6 -eq "$(count_packs)" &&
+		git -c pack.aggregateMaxObjects=10 pack-aggregate --once \
+			--min-loose=1000 --min-packs=1 &&
+		test_path_is_file .git/objects/pack/${big}.pack &&
+		test 2 -eq "$(count_packs)" &&
+		# An explicit --max-objects still overrides the config.
+		big2=$(build_big_pack 20) &&
+		git -c pack.aggregateMaxObjects=10 pack-aggregate --once \
+			--min-loose=1000 --min-packs=1 --max-objects=0 &&
+		test_path_is_missing .git/objects/pack/${big2}.pack &&
+		test 1 -eq "$(count_packs)" &&
+		git fsck
+	)
+'
+
+test_expect_success 'pack.aggregateMaxObjects rejects negative values' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		build_n_packs 5 >/dev/null &&
+		test_must_fail git -c pack.aggregateMaxObjects=-1 \
+			pack-aggregate --once --min-packs=5 2>err &&
+		test_grep "cannot be negative" err
+	)
+'
+
 test_expect_success 'aggregate re-rolls up .baddeltas packs' '
 	test_when_finished "rm -fr work" &&
 	cp -R repo work &&

From 34e971155a9c46b5df07797338edc83f97d1e8d4 Mon Sep 17 00:00:00 2001
From: Elijah Newren <newren@gmail.com>
Date: Sat, 12 Sep 2026 12:32:55 -0700
Subject: [PATCH 10/18] pack-aggregate: skip packs near the output size limit

With pack.packSizeLimit=1m, aggregating 700-KiB single-blob packs just
rewrites them without reducing their number.

Skip packs larger than half the effective output limit, using their
already-known sizes.  Add --max-input-pack-size and
pack.aggregateMaxInputPackSize to allow a lower threshold, or an
independent byte cap when output size is unlimited.

Assisted-by: GPT-6 Astra
Signed-off-by: Elijah Newren <newren@gmail.com>
---
 Documentation/config/pack.adoc        |   4 +
 Documentation/git-pack-aggregate.adoc |  19 +++++
 builtin/pack-aggregate.c              |  41 +++++++--
 t/t5336-pack-aggregate.sh             | 115 ++++++++++++++++++++++++--
 4 files changed, 167 insertions(+), 12 deletions(-)

diff --git a/Documentation/config/pack.adoc b/Documentation/config/pack.adoc
index 16c62a539f10d8..cf2511f99c36f8 100644
--- a/Documentation/config/pack.adoc
+++ b/Documentation/config/pack.adoc
@@ -43,6 +43,10 @@ pack.aggregateMaxObjects::
 	Default for linkgit:git-pack-aggregate[1]'s `--max-objects`
 	option. Defaults to `100000`; see that option for details.
 
+pack.aggregateMaxInputPackSize::
+	Default for linkgit:git-pack-aggregate[1]'s `--max-input-pack-size`
+	option. Defaults to `0` (automatic); see that option for details.
+
 pack.island::
 	An extended regular expression configuring a set of delta
 	islands. See "DELTA ISLANDS" in linkgit:git-pack-objects[1]
diff --git a/Documentation/git-pack-aggregate.adoc b/Documentation/git-pack-aggregate.adoc
index 29794a6eed81f3..4c3b49a5906c5b 100644
--- a/Documentation/git-pack-aggregate.adoc
+++ b/Documentation/git-pack-aggregate.adoc
@@ -11,6 +11,7 @@ SYNOPSIS
 [verse]
 'git pack-aggregate' --once [--min-loose=<n>] [--min-packs=<n>]
                    [--max-objects=<n>]
+                   [--max-input-pack-size=<bytes>]
 
 DESCRIPTION
 -----------
@@ -39,6 +40,9 @@ The `pack.packSizeLimit` setting can split either step's output into
 multiple packs.  All outputs from a batch are installed before its
 input packs or loose objects are removed.  Size-based splitting may
 require expanding deltas whose bases are in another output pack.
+By default, step 2 skips packs larger than half that limit to avoid
+repeatedly copying nearly full packs without reducing the pack count.
+See `--max-input-pack-size` for a smaller input-size threshold.
 
 This command provides a quick recovery step for a repository that has
 accumulated many loose objects or small packs.  It reduces the number
@@ -76,6 +80,21 @@ OPTIONS
 	regardless of this setting, so on a normally-maintained
 	repository the large base pack is skipped anyway.
 
+--max-input-pack-size=<bytes>::
+	Skip input packs whose `.pack` file is larger than `<bytes>`.
+	This byte-size gate applies in addition to `--max-objects`;
+	it does not limit loose-object rollup or individual output packs.
+	The suffixes `k`, `m`, and `g` are supported.
++
+Defaults to `pack.aggregateMaxInputPackSize`, or `0` (automatic).
+Automatic selection uses half of `pack.packSizeLimit`, after applying
+the same 1-MiB minimum for nonzero output limits as `pack-objects`.
+An explicit positive input limit above that ceiling is an error;
+a lower limit is allowed.  If `pack.packSizeLimit` is unset or zero,
+automatic selection imposes no byte-size gate, and any explicit
+positive input limit is allowed.  An explicit `0` overrides the
+configuration and restores automatic selection.
+
 SEE ALSO
 --------
 linkgit:git-repack[1], linkgit:git-pack-objects[1],
diff --git a/builtin/pack-aggregate.c b/builtin/pack-aggregate.c
index 4b62f7db563931..3346a5fb7e27d3 100644
--- a/builtin/pack-aggregate.c
+++ b/builtin/pack-aggregate.c
@@ -23,7 +23,8 @@
 
 static const char *const pack_aggregate_usage[] = {
 	N_("git pack-aggregate --once [--min-loose=<n>] [--min-packs=<n>]\n"
-	   "                         [--max-objects=<n>]"),
+	   "                         [--max-objects=<n>]\n"
+	   "                         [--max-input-pack-size=<bytes>]"),
 	NULL
 };
 
@@ -213,7 +214,8 @@ static void collect_pack_candidates(struct repository *repo,
 				    struct strset *cycle_exclude,
 				    struct strset *midx_exclude,
 				    struct string_list *candidates,
-				    off_t max_idx_size)
+				    off_t max_idx_size,
+				    unsigned long max_input_pack_size)
 {
 	struct packed_git *p;
 	struct strbuf base = STRBUF_INIT;
@@ -222,6 +224,9 @@ static void collect_pack_candidates(struct repository *repo,
 	repo_for_each_pack(repo, p) {
 		if (!p->pack_local)
 			continue;
+		if (max_input_pack_size &&
+		    (uintmax_t)p->pack_size > max_input_pack_size)
+			continue;
 
 		strbuf_reset(&base);
 		strbuf_addstr(&base, pack_basename(p));
@@ -391,7 +396,8 @@ static void unlink_consumed_packs(const char *packdir,
 
 static int run_aggregation(struct repository *repo, const char *packdir,
 			   struct strset *midx_exclude,
-			   int min_loose, int min_packs, int max_objects)
+			   int min_loose, int min_packs, int max_objects,
+			   unsigned long max_input_pack_size)
 {
 	struct oid_array loose_oids = OID_ARRAY_INIT;
 	struct string_list loose_paths = STRING_LIST_INIT_DUP;
@@ -445,7 +451,8 @@ static int run_aggregation(struct repository *repo, const char *packdir,
 	collect_pack_candidates(repo, packdir,
 				&loose_rollup_exclude, midx_exclude, &candidates,
 				max_objects_to_idx_size(repo->hash_algo,
-							max_objects));
+							max_objects),
+				max_input_pack_size);
 
 	if ((int)candidates.nr < min_packs)
 		goto out;
@@ -486,6 +493,8 @@ int cmd_pack_aggregate(int argc, const char **argv,
 	int min_packs = 5;
 	int min_loose = 5;
 	int max_objects = -1;
+	unsigned long max_input_pack_size = 0;
+	unsigned long pack_size_limit = 0;
 	int once = 0;
 	struct option options[] = {
 		OPT_BOOL(0, "once", &once,
@@ -499,12 +508,19 @@ int cmd_pack_aggregate(int argc, const char **argv,
 		OPT_INTEGER(0, "max-objects", &max_objects,
 			    N_("skip packs with more than this many "
 			       "objects (0 for no limit)")),
+		OPT_UNSIGNED(0, "max-input-pack-size", &max_input_pack_size,
+			     N_("skip packs larger than this many bytes "
+				"(0 for automatic)")),
 		OPT_END(),
 	};
 	struct strset midx_exclude = STRSET_INIT;
 	char *packdir;
 	int ret = 0;
 
+	if (repo)
+		repo_config_get_ulong(repo, "pack.aggregatemaxinputpacksize",
+				      &max_input_pack_size);
+
 	argc = parse_options(argc, argv, prefix, options,
 			     pack_aggregate_usage, 0);
 	if (argc > 0)
@@ -522,10 +538,25 @@ int cmd_pack_aggregate(int argc, const char **argv,
 	if (max_objects < 0)
 		die(_("pack.aggregateMaxObjects cannot be negative"));
 
+	repo_config_get_ulong(repo, "pack.packsizelimit", &pack_size_limit);
+	/* Match pack-objects' minimum nonzero output size limit. */
+	if (pack_size_limit && pack_size_limit < 1024 * 1024)
+		pack_size_limit = 1024 * 1024;
+	if (pack_size_limit) {
+		unsigned long ceiling = pack_size_limit / 2;
+
+		if (max_input_pack_size > ceiling)
+			die(_("maximum input pack size cannot exceed %lu bytes "
+			      "(half the effective pack.packSizeLimit)"), ceiling);
+		if (!max_input_pack_size)
+			max_input_pack_size = ceiling;
+	}
+
 	packdir = mkpathdup("%s/pack", repo_get_object_directory(repo));
 
 	ret = run_aggregation(repo, packdir, &midx_exclude,
-			      min_loose, min_packs, max_objects);
+			      min_loose, min_packs, max_objects,
+			      max_input_pack_size);
 
 	strset_clear(&midx_exclude);
 	free(packdir);
diff --git a/t/t5336-pack-aggregate.sh b/t/t5336-pack-aggregate.sh
index 8610fdad562f42..da9a12cc2d9f53 100755
--- a/t/t5336-pack-aggregate.sh
+++ b/t/t5336-pack-aggregate.sh
@@ -155,30 +155,41 @@ do
 		cp -R repo work &&
 		(
 			cd work &&
-			# Each blob fits in 1 MiB, but no pair does.
+			blob_size=716800 &&
+			output_packs=3 &&
+			if test "$input_mode" = packed
+			then
+				# Each input must fit below the half-limit gate.
+				blob_size=409600 &&
+				output_packs=2
+			fi &&
 			for i in 1 2 3
 			do
-				test-tool genrandom "split-$i" 716800 >blob &&
+				test-tool genrandom "split-$i" "$blob_size" >blob &&
 				oid=$(git hash-object -w blob) &&
 				test-tool chmtime -1 \
 					".git/objects/$(test_oid_to_path "$oid")" &&
+				if test "$input_mode" = packed
+				then
+					echo "$oid" |
+					git pack-objects --window=0 \
+						.git/objects/pack/pack >input.hash
+				fi &&
 				echo "$oid" || return 1
 			done >oids &&
 			if test "$input_mode" = packed
 			then
-				git pack-objects --window=0 .git/objects/pack/pack \
-					<oids >input.hash &&
 				git prune-packed
 			fi &&
 			sort oids >expect &&
 
-			# On the second pass, all three output names match inputs.
+			# A one-blob output can have the same name as an input.
 			for pass in 1 2
 			do
 				git -c pack.packSizeLimit=1m pack-aggregate --once \
 					--min-loose=1 --min-packs=1 &&
-				test 3 -eq "$(count_packs)" &&
-				test 3 -eq "$(count_baddeltas)" &&
+				test "$output_packs" -eq "$(count_packs)" &&
+				test "$output_packs" -eq "$(count_baddeltas)" &&
 				test 0 -eq "$(count_loose)" &&
 				find .git/objects/pack -name ".tmp-*" >temporary &&
 				test_must_be_empty temporary &&
@@ -282,6 +293,96 @@ test_expect_success 'pack.aggregateMaxObjects rejects negative values' '
 	)
 '
 
+test_expect_success 'the automatic byte gate excludes nearly full packs' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		test-tool genrandom large 716800 >blob &&
+		oid=$(git hash-object -w blob) &&
+		echo "$oid" |
+		git pack-objects --window=0 .git/objects/pack/pack >large.hash &&
+		large=.git/objects/pack/pack-$(cat large.hash) &&
+		git prune-packed &&
+		build_n_packs 5 >/dev/null &&
+
+		# The excluded pack does not count toward --min-packs.
+		git -c pack.packSizeLimit=1m pack-aggregate --once \
+			--min-packs=6 --max-objects=0 &&
+		test 6 -eq "$(count_packs)" &&
+		test 0 -eq "$(count_baddeltas)" &&
+		git -c pack.packSizeLimit=1m -c pack.aggregateMaxInputPackSize=1 \
+			pack-aggregate --once --min-packs=5 \
+			--max-input-pack-size=0 --max-objects=0 &&
+		test_path_is_file "$large.pack" &&
+		test_path_is_missing "$large.baddeltas" &&
+		test 2 -eq "$(count_packs)" &&
+		test 1 -eq "$(count_baddeltas)" &&
+		git fsck
+	)
+'
+
+test_expect_success 'input byte cap uses config, with an inclusive CLI override' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		big=$(build_big_pack 20) &&
+		size=$(wc -c <.git/objects/pack/$big.pack) &&
+		build_n_packs 5 >/dev/null &&
+		git -c pack.aggregateMaxInputPackSize=$((size - 1)) \
+			pack-aggregate --once --min-packs=1 &&
+		test_path_is_file .git/objects/pack/$big.pack &&
+		test_path_is_missing .git/objects/pack/$big.baddeltas &&
+		test 2 -eq "$(count_packs)" &&
+		git -c pack.aggregateMaxInputPackSize=1 pack-aggregate --once \
+			--min-packs=1 --max-input-pack-size="$size" &&
+		test_path_is_missing .git/objects/pack/$big.pack &&
+		test 1 -eq "$(count_packs)" &&
+		git fsck
+	)
+'
+
+test_expect_success 'zero input cap restores unlimited automatic selection' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		build_n_packs 5 >/dev/null &&
+		git -c pack.packSizeLimit=0 -c pack.aggregateMaxInputPackSize=1 \
+			pack-aggregate --once --max-input-pack-size=0 &&
+		test 1 -eq "$(count_packs)" &&
+		git fsck
+	)
+'
+
+for output_limit in 1m 1k
+do
+	test_expect_success "input byte cap respects the effective $output_limit output limit" '
+		git -C repo -c pack.packSizeLimit=$output_limit pack-aggregate \
+			--once --max-input-pack-size=512k &&
+		test_must_fail git -C repo -c pack.packSizeLimit=$output_limit \
+			pack-aggregate --once --max-input-pack-size=524289 2>err &&
+		test_grep -F "half the effective pack.packSizeLimit" err &&
+		test_must_fail git -C repo -c pack.packSizeLimit=$output_limit \
+			-c pack.aggregateMaxInputPackSize=524289 \
+			pack-aggregate --once 2>err &&
+		test_grep -F "half the effective pack.packSizeLimit" err
+	'
+done
+
+for value in -1 bogus 999999999999999999999999999999
+do
+	test_expect_success "input byte cap rejects $value" '
+		test_must_fail git -C repo pack-aggregate --once \
+			--max-input-pack-size=$value 2>err &&
+		test_grep "max-input-pack-size" err &&
+		test_must_fail git -C repo -c pack.aggregateMaxInputPackSize=$value \
+			pack-aggregate --once 2>err &&
+		test_grep "aggregatemaxinputpacksize" err
+	'
+done
+
 test_expect_success 'aggregate re-rolls up .baddeltas packs' '
 	test_when_finished "rm -fr work" &&
 	cp -R repo work &&

From eaec96358bf1e746967c7dfa0a131aaacc42dcbb Mon Sep 17 00:00:00 2001
From: Elijah Newren <newren@gmail.com>
Date: Tue, 4 Aug 2026 22:57:45 -0700
Subject: [PATCH 11/18] pack-aggregate: limit loose objects processed at a time

pack-aggregate currently feeds every eligible loose object to a single
pack-objects process.  That is acceptable for the normal case, but an
extremely neglected repository can have millions of loose objects.
Such a repository remains burdened by the large number of loose-object
files until that invocation finishes, and pack-objects must hold
bookkeeping for the entire backlog at once.

Add --max-loose-objects=<n> and pack.aggregateMaxLooseObjects to limit
how many loose objects each pack-objects invocation processes.  Each
batch can produce multiple packs under pack.packSizeLimit.  Install all
its output packs before unlinking its loose copies and starting the
next batch, allowing the repository to improve incrementally and
preserving completed work if the process is interrupted.

Create a temporary marker in the object directory and use its filesystem
mtime as the cycle cutoff.  Rescans ignore objects that are not older
than that marker, so concurrent writers cannot keep a cycle running
indefinitely.  Using a marker on the same filesystem also avoids
comparing file mtimes against a potentially different host clock.

When loose-object rollup produces multiple packs, leave all of them
out of the pack-aggregation phase of the same cycle.  This avoids
immediately copying the entire recovered loose-object backlog a second
time.  A single pack produced from loose objects retains the existing
behavior and can be combined with other small packs immediately.

Default the limit to 100000.  On a synthetic repository containing ten
million small loose blobs, the following limits produced:

    limit       first pack     total time     peak RSS
    100000          12.4s         1520.0s         26MB
    500000          64.1s         1530.8s        115MB
    1000000        132.6s         1537.0s        226MB

The total time was effectively unchanged, while 100000 made the first
improvement visible much sooner and used substantially less memory.  A
value of 0 processes all eligible loose objects in one batch.

Assisted-by: GPT-5.6 Sol
Signed-off-by: Elijah Newren <newren@gmail.com>
---
 Documentation/config/pack.adoc        |   4 +
 Documentation/git-pack-aggregate.adoc |  12 +++
 builtin/pack-aggregate.c              | 121 +++++++++++++++++++++-----
 t/t5336-pack-aggregate.sh             | 113 +++++++++++++++++++++++-
 4 files changed, 226 insertions(+), 24 deletions(-)

diff --git a/Documentation/config/pack.adoc b/Documentation/config/pack.adoc
index cf2511f99c36f8..bc7a37bbd0d840 100644
--- a/Documentation/config/pack.adoc
+++ b/Documentation/config/pack.adoc
@@ -47,6 +47,10 @@ pack.aggregateMaxInputPackSize::
 	Default for linkgit:git-pack-aggregate[1]'s `--max-input-pack-size`
 	option. Defaults to `0` (automatic); see that option for details.
 
+pack.aggregateMaxLooseObjects::
+	Default for linkgit:git-pack-aggregate[1]'s `--max-loose-objects`
+	option. Defaults to `100000`; see that option for details.
+
 pack.island::
 	An extended regular expression configuring a set of delta
 	islands. See "DELTA ISLANDS" in linkgit:git-pack-objects[1]
diff --git a/Documentation/git-pack-aggregate.adoc b/Documentation/git-pack-aggregate.adoc
index 4c3b49a5906c5b..9bde09832805f3 100644
--- a/Documentation/git-pack-aggregate.adoc
+++ b/Documentation/git-pack-aggregate.adoc
@@ -10,6 +10,7 @@ SYNOPSIS
 --------
 [verse]
 'git pack-aggregate' --once [--min-loose=<n>] [--min-packs=<n>]
+                   [--max-loose-objects=<n>]
                    [--max-objects=<n>]
                    [--max-input-pack-size=<bytes>]
 
@@ -67,6 +68,17 @@ OPTIONS
 	packs are present.
 	Defaults to 5.
 
+--max-loose-objects=<n>::
+	Process at most `<n>` loose objects per batch.  All output packs
+	are installed and the loose copies are removed before the next
+	batch begins, so repository performance can improve incrementally
+	during recovery from an extreme backlog.  Loose objects created
+	after the cycle starts are left for the next cycle.
+	If multiple packs are produced, they are left for a later aggregation
+	cycle instead of being copied again immediately.
+	Defaults to the `pack.aggregateMaxLooseObjects` configuration value,
+	or 100000 if that is unset.  A value of `0` disables the limit.
+
 --max-objects=<n>::
 	Skip any pack that contains more than `<n>` objects, leaving it
 	untouched by step 2.  The object count is estimated cheaply from
diff --git a/builtin/pack-aggregate.c b/builtin/pack-aggregate.c
index 3346a5fb7e27d3..c0f4cbc4825cbf 100644
--- a/builtin/pack-aggregate.c
+++ b/builtin/pack-aggregate.c
@@ -23,11 +23,14 @@
 
 static const char *const pack_aggregate_usage[] = {
 	N_("git pack-aggregate --once [--min-loose=<n>] [--min-packs=<n>]\n"
+	   "                         [--max-loose-objects=<n>]\n"
 	   "                         [--max-objects=<n>]\n"
 	   "                         [--max-input-pack-size=<bytes>]"),
 	NULL
 };
 
+#define DEFAULT_MAX_LOOSE_OBJECTS 100000
+
 #define DEFAULT_MAX_OBJECTS 100000
 
 static int has_sidecar(const char *packdir, const char *basename,
@@ -130,15 +133,58 @@ static void refresh_midx_exclusions(struct repository *repo,
 struct loose_scan {
 	struct oid_array *oids;
 	struct string_list *paths;
+	size_t limit;
+	size_t minimum;
+	size_t eligible;
+	time_t cutoff_sec;
+	unsigned int cutoff_nsec;
 };
 
+static void set_loose_scan_cutoff(struct repository *repo,
+				  struct loose_scan *data)
+{
+	struct strbuf template = STRBUF_INIT;
+	struct tempfile *marker;
+	struct stat st;
+
+	strbuf_addf(&template, "%s/.tmp-pack-aggregate-cutoff-XXXXXX",
+		    repo_get_object_directory(repo));
+	marker = xmks_tempfile(template.buf);
+	strbuf_release(&template);
+
+	if (fstat(get_tempfile_fd(marker), &st))
+		die_errno(_("could not stat loose-object cutoff marker"));
+	data->cutoff_sec = st.st_mtime;
+	data->cutoff_nsec = ST_MTIME_NSEC(st);
+	delete_tempfile(&marker);
+}
+
 static int loose_scan_cb(const struct object_id *oid, const char *path,
 			 void *cb_data)
 {
 	struct loose_scan *data = cb_data;
+	struct stat st;
+
+	if (lstat(path, &st)) {
+		if (errno != ENOENT)
+			warning_errno(_("could not stat loose object '%s'"),
+				      path);
+		return 0;
+	}
+	if (st.st_mtime > data->cutoff_sec ||
+	    (st.st_mtime == data->cutoff_sec &&
+	     ST_MTIME_NSEC(st) >= data->cutoff_nsec))
+		return 0;
 
-	oid_array_append(data->oids, oid);
-	string_list_append(data->paths, path);
+	data->eligible++;
+	if (!data->limit || data->oids->nr < data->limit) {
+		oid_array_append(data->oids, oid);
+		string_list_append(data->paths, path);
+	}
+
+	if (data->limit && data->oids->nr >= data->limit &&
+	    data->eligible >= data->minimum)
+		return 1;
 	return 0;
 }
 
@@ -195,16 +241,14 @@ static int run_pack_objects_loose(const char *packtmp, struct oid_array *oids,
 	return ret;
 }
 
-static void unlink_loose_paths(const struct string_list *paths)
+static int unlink_loose_paths(const struct string_list *paths)
 {
 	size_t i;
 
-	for (i = 0; i < paths->nr; i++) {
-		const char *p = paths->items[i].string;
-		if (unlink(p) < 0 && errno != ENOENT)
-			warning_errno(_("could not unlink loose object '%s'"),
-				      p);
-	}
+	for (i = 0; i < paths->nr; i++)
+		if (unlink_or_warn(paths->items[i].string))
+			return -1;
+	return 0;
 }
 
 /* ---------- pack aggregation ---------- */
@@ -396,7 +440,8 @@ static void unlink_consumed_packs(const char *packdir,
 
 static int run_aggregation(struct repository *repo, const char *packdir,
 			   struct strset *midx_exclude,
-			   int min_loose, int min_packs, int max_objects,
+			   int min_loose, int min_packs,
+			   int max_loose_objects, int max_objects,
 			   unsigned long max_input_pack_size)
 {
 	struct oid_array loose_oids = OID_ARRAY_INIT;
@@ -404,6 +449,8 @@ static int run_aggregation(struct repository *repo, const char *packdir,
 	struct loose_scan loose_data = {
 		.oids = &loose_oids,
 		.paths = &loose_paths,
+		.limit = max_loose_objects,
+		.minimum = min_loose,
 	};
 	struct strset loose_rollup_exclude = STRSET_INIT;
 	struct strset output_bases = STRSET_INIT;
@@ -414,27 +461,43 @@ static int run_aggregation(struct repository *repo, const char *packdir,
 	int ret = 0;
 
 	/*
-	 * Step 1: bundle local loose objects into new packs and remove
-	 * the on-disk loose copies only after all outputs are installed.
+	 * Step 1: pack loose objects in bounded batches, installing every
+	 * output before removing inputs. The cycle-start cutoff prevents
+	 * new arrivals from prolonging this cycle.
 	 */
+	set_loose_scan_cutoff(repo, &loose_data);
 	for_each_loose_file_in_source(repo->objects->sources,
 				      loose_scan_cb, NULL, NULL, &loose_data);
-	if ((int)loose_oids.nr >= min_loose) {
+	if (loose_data.eligible >= (size_t)min_loose) {
 		packtmp_loose = mkpathdup("%s/.tmp-%d-loose-pack",
 					  packdir, (int)getpid());
-		if (run_pack_objects_loose(packtmp_loose, &loose_oids,
-					   &output_hashes)) {
-			ret = error(_("pack-objects failed during "
-				      "loose-object rollup"));
-			goto out;
-		}
-		if (output_hashes.nr) {
+		while (loose_oids.nr) {
+			string_list_clear(&output_hashes, 0);
+			if (run_pack_objects_loose(packtmp_loose, &loose_oids,
+						   &output_hashes)) {
+				ret = error(_("pack-objects failed during "
+					      "loose-object rollup"));
+				goto out;
+			}
+			if (!output_hashes.nr)
+				break;
+
 			if (install_packs(repo, packtmp_loose, packdir,
-					  &output_hashes, &loose_rollup_exclude)) {
+					  &output_hashes, &loose_rollup_exclude) ||
+			    unlink_loose_paths(&loose_paths)) {
 				ret = -1;
 				goto out;
 			}
-			unlink_loose_paths(&loose_paths);
+
+			oid_array_clear(&loose_oids);
+			string_list_clear(&loose_paths, 0);
+
+			/* Once rollup starts, also consume a final partial batch. */
+			loose_data.minimum = 1;
+			loose_data.eligible = 0;
+			for_each_loose_file_in_source(repo->objects->sources,
+						      loose_scan_cb, NULL, NULL,
+						      &loose_data);
 		}
 	}
 
@@ -492,6 +555,7 @@ int cmd_pack_aggregate(int argc, const char **argv,
 {
 	int min_packs = 5;
 	int min_loose = 5;
+	int max_loose_objects = -1;
 	int max_objects = -1;
 	unsigned long max_input_pack_size = 0;
 	unsigned long pack_size_limit = 0;
@@ -505,6 +569,9 @@ int cmd_pack_aggregate(int argc, const char **argv,
 		OPT_INTEGER(0, "min-packs", &min_packs,
 			    N_("skip pack aggregation if fewer "
 			       "candidates (default 5)")),
+		OPT_INTEGER(0, "max-loose-objects", &max_loose_objects,
+			    N_("pack at most this many loose objects per "
+			       "batch (0 for no limit)")),
 		OPT_INTEGER(0, "max-objects", &max_objects,
 			    N_("skip packs with more than this many "
 			       "objects (0 for no limit)")),
@@ -532,6 +599,13 @@ int cmd_pack_aggregate(int argc, const char **argv,
 	if (min_packs < 1)
 		die(_("--min-packs must be at least 1"));
 
+	if (max_loose_objects < 0 &&
+	    repo_config_get_int(repo, "pack.aggregatemaxlooseobjects",
+				&max_loose_objects))
+		max_loose_objects = DEFAULT_MAX_LOOSE_OBJECTS;
+	if (max_loose_objects < 0)
+		die(_("pack.aggregateMaxLooseObjects cannot be negative"));
+
 	if (max_objects < 0 &&
 	    repo_config_get_int(repo, "pack.aggregatemaxobjects", &max_objects))
 		max_objects = DEFAULT_MAX_OBJECTS;
@@ -555,7 +629,8 @@ int cmd_pack_aggregate(int argc, const char **argv,
 	packdir = mkpathdup("%s/pack", repo_get_object_directory(repo));
 
 	ret = run_aggregation(repo, packdir, &midx_exclude,
-			      min_loose, min_packs, max_objects,
+			      min_loose, min_packs,
+			      max_loose_objects, max_objects,
 			      max_input_pack_size);
 
 	strset_clear(&midx_exclude);
diff --git a/t/t5336-pack-aggregate.sh b/t/t5336-pack-aggregate.sh
index da9a12cc2d9f53..41b0939383ccf8 100755
--- a/t/t5336-pack-aggregate.sh
+++ b/t/t5336-pack-aggregate.sh
@@ -30,9 +30,13 @@ build_n_packs () {
 build_n_loose () {
 	n=$1 &&
 	i=0 &&
+	# Ensure these predate the later cutoff marker even without nanoseconds.
 	while test $i -lt "$n"
 	do
-		echo "loose-$i-$$" | git hash-object -w --stdin &&
+		oid=$(echo "loose-$i-$$" | git hash-object -w --stdin) &&
+		test-tool chmtime -1 \
+			".git/objects/$(test_oid_to_path "$oid")" &&
+		echo "$oid" &&
 		i=$((i + 1)) || return 1
 	done
 }
@@ -383,6 +387,113 @@ do
 	'
 done
 
+test_expect_success '--max-loose-objects splits the cycle-start backlog' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		build_n_loose 10 >/dev/null &&
+		git pack-aggregate --once --min-loose=1 --min-packs=1000 \
+			--max-loose-objects=4 &&
+		test 0 -eq "$(count_loose)" &&
+		test 3 -eq "$(count_packs)" &&
+		test 3 -eq "$(count_baddeltas)" &&
+		git fsck
+	)
+'
+
+test_expect_success '--min-loose can exceed --max-loose-objects' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		build_n_loose 6 >/dev/null &&
+		git pack-aggregate --once --min-loose=5 --min-packs=1000 \
+			--max-loose-objects=2 &&
+		test 0 -eq "$(count_loose)" &&
+		test 3 -eq "$(count_packs)" &&
+		git fsck
+	)
+'
+
+test_expect_success 'multiple loose batches avoid same-cycle reaggregation' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		build_n_loose 10 >/dev/null &&
+		build_n_packs 5 >/dev/null &&
+		git pack-aggregate --once --min-loose=1 --min-packs=1 \
+			--max-loose-objects=4 &&
+		# The five original packs are aggregated, while the three
+		# loose-rollup packs remain separate until a later cycle.
+		test 0 -eq "$(count_loose)" &&
+		test 4 -eq "$(count_packs)" &&
+		test 4 -eq "$(count_baddeltas)" &&
+		git fsck
+	)
+'
+
+test_expect_success 'loose objects newer than the cycle cutoff are deferred' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		build_n_loose 5 >oids &&
+		deferred=$(tail -n 1 oids) &&
+		deferred_path=.git/objects/$(test_oid_to_path "$deferred") &&
+		test-tool chmtime +60 "$deferred_path" &&
+		git pack-aggregate --once --min-loose=1 --min-packs=1000 \
+			--max-loose-objects=2 &&
+		test 1 -eq "$(count_loose)" &&
+		test_path_is_file "$deferred_path" &&
+		test-tool chmtime -60 "$deferred_path" &&
+		git pack-aggregate --once --min-loose=1 --min-packs=1000 \
+			--max-loose-objects=2 &&
+		test 0 -eq "$(count_loose)" &&
+		git fsck
+	)
+'
+
+test_expect_success '--max-loose-objects=0 disables batch splitting' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		build_n_loose 10 >/dev/null &&
+		git pack-aggregate --once --min-loose=1 --min-packs=1000 \
+			--max-loose-objects=0 &&
+		test 0 -eq "$(count_loose)" &&
+		test 1 -eq "$(count_packs)" &&
+		git fsck
+	)
+'
+
+test_expect_success 'pack.aggregateMaxLooseObjects supplies the default limit' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		build_n_loose 10 >/dev/null &&
+		git -c pack.aggregateMaxLooseObjects=4 pack-aggregate --once \
+			--min-loose=1 --min-packs=1000 &&
+		test 0 -eq "$(count_loose)" &&
+		test 3 -eq "$(count_packs)" &&
+		git fsck
+	)
+'
+
+test_expect_success 'pack.aggregateMaxLooseObjects rejects negative values' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		test_must_fail git -c pack.aggregateMaxLooseObjects=-1 \
+			pack-aggregate --once 2>err &&
+		test_grep "cannot be negative" err
+	)
+'
+
 test_expect_success 'aggregate re-rolls up .baddeltas packs' '
 	test_when_finished "rm -fr work" &&
 	cp -R repo work &&

From f0608798c945fc762af688d6910ed706857bf819 Mon Sep 17 00:00:00 2001
From: Elijah Newren <newren@gmail.com>
Date: Sat, 25 Jul 2026 21:08:20 -0700
Subject: [PATCH 12/18] pack-aggregate: limit input packs processed at a time

pack-aggregate feeds all aggregatable packs to a single pack-objects
invocation.  On a normally-maintained repository that is fine, but
repositories can accumulate an extreme number of packs -- tens or even
hundreds of thousands -- before maintenance catches up.  Processing that
many packs at once increases the memory needed for pack data and indexes
and can exhaust the per-process limit on memory mappings.

Add a --max-packs=<n> option (and a pack.aggregateMaxPacks config) that
caps the number of input packs per pack-objects invocation.  When more
than <n> candidates are present, split them into approximately balanced
batches by pack count, each handled by a separate invocation.  The final
batch may be smaller.  For example, 12000 packs with --max-packs=5000
are processed as three batches of 4000 -- not 5000, 5000, and 2000.

Split on whole-pack boundaries.  Because on-disk packs are always
self-contained (git never stores thin packs), a delta and its base stay
together in the same input batch.  Each invocation can reuse existing
deltas where possible, though pack.packSizeLimit can split its output
into multiple packs and require expanding deltas whose bases land in
another output pack.

Default --max-packs to 10000; use a value of 0 to process all
aggregatable packs in one batch.

Assisted-by: Claude Opus 4.8 & GPT-5.6 Sol
Signed-off-by: Elijah Newren <newren@gmail.com>
---
 Documentation/config/pack.adoc        |  4 ++
 Documentation/git-pack-aggregate.adoc | 15 ++++-
 builtin/pack-aggregate.c              | 78 +++++++++++++++++++------
 t/t5336-pack-aggregate.sh             | 83 +++++++++++++++++++++++++++
 4 files changed, 161 insertions(+), 19 deletions(-)

diff --git a/Documentation/config/pack.adoc b/Documentation/config/pack.adoc
index bc7a37bbd0d840..3df7eb1020cd4d 100644
--- a/Documentation/config/pack.adoc
+++ b/Documentation/config/pack.adoc
@@ -51,6 +51,10 @@ pack.aggregateMaxLooseObjects::
 	Default for linkgit:git-pack-aggregate[1]'s `--max-loose-objects`
 	option. Defaults to `100000`; see that option for details.
 
+pack.aggregateMaxPacks::
+	Default for linkgit:git-pack-aggregate[1]'s `--max-packs`
+	option. Defaults to `10000`; see that option for details.
+
 pack.island::
 	An extended regular expression configuring a set of delta
 	islands. See "DELTA ISLANDS" in linkgit:git-pack-objects[1]
diff --git a/Documentation/git-pack-aggregate.adoc b/Documentation/git-pack-aggregate.adoc
index 9bde09832805f3..6a835a14fb4c8b 100644
--- a/Documentation/git-pack-aggregate.adoc
+++ b/Documentation/git-pack-aggregate.adoc
@@ -11,7 +11,7 @@ SYNOPSIS
 [verse]
 'git pack-aggregate' --once [--min-loose=<n>] [--min-packs=<n>]
                    [--max-loose-objects=<n>]
-                   [--max-objects=<n>]
+                   [--max-objects=<n>] [--max-packs=<n>]
                    [--max-input-pack-size=<bytes>]
 
 DESCRIPTION
@@ -107,6 +107,19 @@ automatic selection imposes no byte-size gate, and any explicit
 positive input limit is allowed.  An explicit `0` overrides the
 configuration and restores automatic selection.
 
+--max-packs=<n>::
+	Process at most `<n>` input packs per `pack-objects` invocation.
+	When more than `<n>` aggregatable packs are present, split them
+	into approximately balanced batches by pack count.  The final batch
+	may be smaller, and each batch can produce multiple output packs.
+	Limiting input packs helps control memory use for pack data and
+	indexes on repositories with very many packs.  Batching happens on
+	whole-pack boundaries, keeping each delta and its base in the same
+	input batch.
+	Defaults to the `pack.aggregateMaxPacks` configuration value, or
+	`10000` if unset.  A value of `0` disables the input-pack limit and
+	processes all input packs in one batch.
+
 SEE ALSO
 --------
 linkgit:git-repack[1], linkgit:git-pack-objects[1],
diff --git a/builtin/pack-aggregate.c b/builtin/pack-aggregate.c
index c0f4cbc4825cbf..03b283d65d6706 100644
--- a/builtin/pack-aggregate.c
+++ b/builtin/pack-aggregate.c
@@ -24,7 +24,7 @@
 static const char *const pack_aggregate_usage[] = {
 	N_("git pack-aggregate --once [--min-loose=<n>] [--min-packs=<n>]\n"
 	   "                         [--max-loose-objects=<n>]\n"
-	   "                         [--max-objects=<n>]\n"
+	   "                         [--max-objects=<n>] [--max-packs=<n>]\n"
 	   "                         [--max-input-pack-size=<bytes>]"),
 	NULL
 };
@@ -33,6 +33,8 @@ static const char *const pack_aggregate_usage[] = {
 
 #define DEFAULT_MAX_OBJECTS 100000
 
+#define DEFAULT_MAX_PACKS 10000
+
 static int has_sidecar(const char *packdir, const char *basename,
 		       const char *ext)
 {
@@ -296,13 +298,14 @@ static void collect_pack_candidates(struct repository *repo,
 
 static int run_pack_objects_packs(const char *packtmp,
 				  const struct string_list *bases,
+				  size_t begin, size_t count,
 				  struct string_list *out_hashes)
 {
 	struct strbuf input = STRBUF_INIT;
 	size_t i;
 	int ret;
 
-	for (i = 0; i < bases->nr; i++)
+	for (i = begin; i < begin + count; i++)
 		strbuf_addf(&input, "%s.pack\n", bases->items[i].string);
 	ret = run_pack_objects(packtmp, 1, &input, out_hashes);
 	strbuf_release(&input);
@@ -401,6 +404,7 @@ static int install_packs(struct repository *repo, const char *packtmp,
 
 static void unlink_consumed_packs(const char *packdir,
 				  const struct string_list *bases,
+				  size_t begin, size_t count,
 				  struct strset *keep_basenames)
 {
 	static const char *exts[] = {
@@ -408,7 +412,7 @@ static void unlink_consumed_packs(const char *packdir,
 	};
 	size_t i;
 
-	for (i = 0; i < bases->nr; i++) {
+	for (i = begin; i < begin + count; i++) {
 		const char *base = bases->items[i].string;
 		int j;
 
@@ -442,7 +446,7 @@ static int run_aggregation(struct repository *repo, const char *packdir,
 			   struct strset *midx_exclude,
 			   int min_loose, int min_packs,
 			   int max_loose_objects, int max_objects,
-			   unsigned long max_input_pack_size)
+			   int max_packs, unsigned long max_input_pack_size)
 {
 	struct oid_array loose_oids = OID_ARRAY_INIT;
 	struct string_list loose_paths = STRING_LIST_INIT_DUP;
@@ -522,20 +526,48 @@ static int run_aggregation(struct repository *repo, const char *packdir,
 
 	packtmp_packs = mkpathdup("%s/.tmp-%d-pack",
 				  packdir, (int)getpid());
-	string_list_clear(&output_hashes, 0);
-	if (run_pack_objects_packs(packtmp_packs, &candidates,
-				   &output_hashes)) {
-		ret = error(_("pack-objects failed during "
-			      "pack aggregation"));
-		goto out;
-	}
-	if (output_hashes.nr) {
-		if (install_packs(repo, packtmp_packs, packdir,
-				  &output_hashes, &output_bases)) {
-			ret = -1;
-			goto out;
+
+	/*
+	 * Batch whole packs so each input batch contains its delta bases.
+	 * Aim for balanced sizes with ceil(total / ceil(total / max_packs));
+	 * max_packs == 0 means one batch containing everything.
+	 */
+	{
+		size_t total = candidates.nr;
+		size_t batch_size = total;
+		size_t start;
+
+		if (max_packs > 0 && total > (size_t)max_packs) {
+			size_t num_batches = DIV_ROUND_UP(total,
+							  (size_t)max_packs);
+			batch_size = DIV_ROUND_UP(total, num_batches);
+		}
+
+		for (start = 0; start < total; start += batch_size) {
+			size_t count = batch_size;
+
+			if (start + count > total)
+				count = total - start;
+
+			string_list_clear(&output_hashes, 0);
+			strset_clear(&output_bases);
+			if (run_pack_objects_packs(packtmp_packs, &candidates,
+						   start, count, &output_hashes)) {
+				ret = error(_("pack-objects failed during "
+					      "pack aggregation"));
+				goto out;
+			}
+			if (output_hashes.nr) {
+				if (install_packs(repo, packtmp_packs, packdir,
+						  &output_hashes, &output_bases)) {
+					ret = -1;
+					goto out;
+				}
+				unlink_consumed_packs(packdir, &candidates,
+						      start, count,
+						      &output_bases);
+			}
 		}
-		unlink_consumed_packs(packdir, &candidates, &output_bases);
 	}
 
 out:
@@ -557,6 +589,7 @@ int cmd_pack_aggregate(int argc, const char **argv,
 	int min_loose = 5;
 	int max_loose_objects = -1;
 	int max_objects = -1;
+	int max_packs = -1;
 	unsigned long max_input_pack_size = 0;
 	unsigned long pack_size_limit = 0;
 	int once = 0;
@@ -575,6 +608,9 @@ int cmd_pack_aggregate(int argc, const char **argv,
 		OPT_INTEGER(0, "max-objects", &max_objects,
 			    N_("skip packs with more than this many "
 			       "objects (0 for no limit)")),
+		OPT_INTEGER(0, "max-packs", &max_packs,
+			    N_("aggregate at most this many input packs per "
+			       "batch (0 for no limit)")),
 		OPT_UNSIGNED(0, "max-input-pack-size", &max_input_pack_size,
 			     N_("skip packs larger than this many bytes "
 				"(0 for automatic)")),
@@ -612,6 +648,12 @@ int cmd_pack_aggregate(int argc, const char **argv,
 	if (max_objects < 0)
 		die(_("pack.aggregateMaxObjects cannot be negative"));
 
+	if (max_packs < 0 &&
+	    repo_config_get_int(repo, "pack.aggregatemaxpacks", &max_packs))
+		max_packs = DEFAULT_MAX_PACKS;
+	if (max_packs < 0)
+		die(_("pack.aggregateMaxPacks cannot be negative"));
+
 	repo_config_get_ulong(repo, "pack.packsizelimit", &pack_size_limit);
 	/* Match pack-objects' minimum nonzero output size limit. */
 	if (pack_size_limit && pack_size_limit < 1024 * 1024)
@@ -631,7 +673,7 @@ int cmd_pack_aggregate(int argc, const char **argv,
 	ret = run_aggregation(repo, packdir, &midx_exclude,
 			      min_loose, min_packs,
 			      max_loose_objects, max_objects,
-			      max_input_pack_size);
+			      max_packs, max_input_pack_size);
 
 	strset_clear(&midx_exclude);
 	free(packdir);
diff --git a/t/t5336-pack-aggregate.sh b/t/t5336-pack-aggregate.sh
index 41b0939383ccf8..4692578554b8e0 100755
--- a/t/t5336-pack-aggregate.sh
+++ b/t/t5336-pack-aggregate.sh
@@ -494,6 +494,89 @@ test_expect_success 'pack.aggregateMaxLooseObjects rejects negative values' '
 	)
 '
 
+test_expect_success '--max-packs splits candidates into several output packs' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		build_n_packs 10 >/dev/null &&
+		test 10 -eq "$(count_packs)" &&
+		git cat-file --batch-all-objects --batch-check >before &&
+		# 10 candidates, at most 4 per output pack: ceil(10/4)=3
+		# batches of sizes 4, 4, 2 => 3 output packs, with no
+		# objects lost across the batch boundaries.
+		git pack-aggregate --once \
+			--min-loose=1000 --min-packs=1 --max-packs=4 &&
+		test 3 -eq "$(count_packs)" &&
+		test 3 -eq "$(count_baddeltas)" &&
+		git cat-file --batch-all-objects --batch-check >after &&
+		test_cmp before after &&
+		git fsck
+	)
+'
+
+test_expect_success '--max-packs above the candidate count yields one pack' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		build_n_packs 5 >/dev/null &&
+		test 5 -eq "$(count_packs)" &&
+		git pack-aggregate --once \
+			--min-loose=1000 --min-packs=1 --max-packs=100 &&
+		test 1 -eq "$(count_packs)" &&
+		test 1 -eq "$(count_baddeltas)" &&
+		git fsck
+	)
+'
+
+test_expect_success '--max-packs=0 folds everything into one pack' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		build_n_packs 10 >/dev/null &&
+		test 10 -eq "$(count_packs)" &&
+		git pack-aggregate --once \
+			--min-loose=1000 --min-packs=1 --max-packs=0 &&
+		test 1 -eq "$(count_packs)" &&
+		git fsck
+	)
+'
+
+test_expect_success 'pack.aggregateMaxPacks supplies the default limit' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		build_n_packs 10 >/dev/null &&
+		test 10 -eq "$(count_packs)" &&
+		git -c pack.aggregateMaxPacks=4 pack-aggregate --once \
+			--min-loose=1000 --min-packs=1 &&
+		test 3 -eq "$(count_packs)" &&
+		# An explicit --max-packs=0 still overrides the config,
+		# folding the current packs back into a single one.
+		build_n_packs 6 >/dev/null &&
+		test 9 -eq "$(count_packs)" &&
+		git -c pack.aggregateMaxPacks=4 pack-aggregate --once \
+			--min-loose=1000 --min-packs=1 --max-packs=0 &&
+		test 1 -eq "$(count_packs)" &&
+		git fsck
+	)
+'
+
+test_expect_success 'pack.aggregateMaxPacks rejects negative values' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		build_n_packs 5 >/dev/null &&
+		test_must_fail git -c pack.aggregateMaxPacks=-1 \
+			pack-aggregate --once --min-packs=5 2>err &&
+		test_grep "cannot be negative" err
+	)
+'
+
 test_expect_success 'aggregate re-rolls up .baddeltas packs' '
 	test_when_finished "rm -fr work" &&
 	cp -R repo work &&

From ef2f652dbd26ceb8bb36596a81a4884a6b55d10e Mon Sep 17 00:00:00 2001
From: Elijah Newren <newren@gmail.com>
Date: Tue, 11 Aug 2026 22:31:22 -0700
Subject: [PATCH 13/18] repack: optionally aggregate once before repacking

Repositories that have gone without maintenance can accumulate enough
loose objects and small packs to slow down every Git command that needs
to inspect the object store.  A thorough repack will eventually repair
that state, but it must first operate while the repository is still at
its least healthy.

Teach `git repack` to optionally run `git pack-aggregate --once` before
it inspects the existing packs and loose objects.  This cheap
preliminary pass quickly reduces the number of files the main repack
must contend with, leaving the thorough repack to optimize deltas and
pack layout.

Add `--aggregate-once` and `--no-aggregate-once`, together with the
matching `repack.aggregateOnce` configuration variable.  Keep the
behavior disabled by default.

Run the aggregation pass before repack snapshots refs for a MIDX bitmap,
reads the existing MIDX, or computes geometric pack selection.  If the
aggregation fails, abort before starting the main pack-objects process.

Since aggregation mutates the repository, validate incompatible
`--geometric` and `-a`/`-A` options, and `--filter-to` without
`--filter`, before invoking it.  Invalid commands therefore remain
side-effect free.

Like `git repack` and `git pack-aggregate` themselves, this integration
takes no locks.  Serialization with other pack-rewriting maintenance
remains the caller's responsibility.

Signed-off-by: Elijah Newren <newren@gmail.com>
---
 Documentation/config/repack.adoc      |   8 ++
 Documentation/git-pack-aggregate.adoc |  15 ++-
 Documentation/git-repack.adoc         |  10 ++
 builtin/pack-aggregate.c              |  19 +++-
 builtin/repack.c                      |  43 +++++++-
 t/t5336-pack-aggregate.sh             | 140 ++++++++++++++++++++++++++
 6 files changed, 224 insertions(+), 11 deletions(-)

diff --git a/Documentation/config/repack.adoc b/Documentation/config/repack.adoc
index 4c22a499f6216c..ab13d6b94c699e 100644
--- a/Documentation/config/repack.adoc
+++ b/Documentation/config/repack.adoc
@@ -64,3 +64,11 @@ repack.midxNewLayerThreshold::
 When the tip layer has fewer packs than this threshold, those packs are
 excluded from the geometric repack entirely, and are thus left
 unmodified. Must be at least 1. Defaults to 8.
+
+repack.aggregateOnce::
+	If set to true, linkgit:git-repack[1] will run
+	linkgit:git-pack-aggregate[1] once before inspecting the packs
+	and loose objects to repack. This can quickly reduce a large
+	number of files before the more thorough repack begins.
+	Defaults to false. Can be overridden on the command line with
+	`--aggregate-once` or `--no-aggregate-once`.
diff --git a/Documentation/git-pack-aggregate.adoc b/Documentation/git-pack-aggregate.adoc
index 6a835a14fb4c8b..544c08dbaebff8 100644
--- a/Documentation/git-pack-aggregate.adoc
+++ b/Documentation/git-pack-aggregate.adoc
@@ -13,6 +13,7 @@ SYNOPSIS
                    [--max-loose-objects=<n>]
                    [--max-objects=<n>] [--max-packs=<n>]
                    [--max-input-pack-size=<bytes>]
+                   [--keep-pack=<pack-name>]
 
 DESCRIPTION
 -----------
@@ -21,9 +22,9 @@ DESCRIPTION
 packfiles into new packs in two steps:
 
 1. Bundle local loose objects into new packs and unlink the loose copies.
-2. Aggregate small local packs (minus those referenced by the
-   multi-pack-index or carrying a `.keep`, `.promisor`, `.mtimes`, or
-   `.bitmap` sidecar) into new packs and unlink the source packs.
+2. Aggregate small local packs (minus those named by `--keep-pack`,
+   referenced by the multi-pack-index, or carrying a `.keep`, `.promisor`,
+   `.mtimes`, or `.bitmap` sidecar) into new packs and unlink the source packs.
    If step 1 writes a single pack, it is naturally a candidate here
    and will normally be folded into the step-2 output.  Multiple
    loose-rollup packs are left for a later aggregation pass.
@@ -49,6 +50,9 @@ This command provides a quick recovery step for a repository that has
 accumulated many loose objects or small packs.  It reduces the number
 of files that unrelated `git` operations must scan, while leaving a
 later thorough linkgit:git-repack[1] to optimize deltas and pack layout.
+The `repack.aggregateOnce` configuration variable (see
+linkgit:git-repack[1]) lets `git repack` request this cleanup before
+beginning that more expensive work.
 
 Like `git repack`, `git pack-aggregate` takes no locks of its own.  Do
 not run it concurrently with other pack-rewriting maintenance.
@@ -68,6 +72,11 @@ OPTIONS
 	packs are present.
 	Defaults to 5.
 
+--keep-pack=<pack-name>::
+	Exclude the given pack from aggregation.  `<pack-name>` is the pack
+	file name without a leading directory (e.g. `pack-123.pack`).
+	This option can be repeated to keep multiple packs.
+
 --max-loose-objects=<n>::
 	Process at most `<n>` loose objects per batch.  All output packs
 	are installed and the loose copies are removed before the next
diff --git a/Documentation/git-repack.adoc b/Documentation/git-repack.adoc
index 2e4e79cf3921bc..a87860f3c100cb 100644
--- a/Documentation/git-repack.adoc
+++ b/Documentation/git-repack.adoc
@@ -13,6 +13,7 @@ SYNOPSIS
 	[--window=<n>] [--depth=<n>] [--threads=<n>] [--keep-pack=<pack-name>]
 	[--write-midx[=<mode>]] [--name-hash-version=<n>] [--path-walk]
 	[--filter=<filter-spec>] [--drop-filtered [--dry-run]]
+	[--[no-]aggregate-once]
 
 DESCRIPTION
 -----------
@@ -340,6 +341,15 @@ created for any new pack(s) without disturbing the existing chain.
 	Pass the `--path-walk` option to the underlying `git pack-objects`
 	process. See linkgit:git-pack-objects[1] for full details.
 
+--aggregate-once::
+--no-aggregate-once::
+	Run linkgit:git-pack-aggregate[1] once before inspecting the
+	packs and loose objects to repack. This can quickly reduce a
+	large number of files before the more thorough repack begins.
+	Packs named by `--keep-pack` are excluded from this preliminary pass.
+	Overrides the `repack.aggregateOnce` configuration variable.
+	Off by default.
+
 CONFIGURATION
 -------------
 
diff --git a/builtin/pack-aggregate.c b/builtin/pack-aggregate.c
index 03b283d65d6706..2b087350f5bc6d 100644
--- a/builtin/pack-aggregate.c
+++ b/builtin/pack-aggregate.c
@@ -2,6 +2,7 @@
 
 #include "builtin.h"
 #include "config.h"
+#include "dir.h"
 #include "gettext.h"
 #include "hash.h"
 #include "hex.h"
@@ -25,7 +26,8 @@ static const char *const pack_aggregate_usage[] = {
 	N_("git pack-aggregate --once [--min-loose=<n>] [--min-packs=<n>]\n"
 	   "                         [--max-loose-objects=<n>]\n"
 	   "                         [--max-objects=<n>] [--max-packs=<n>]\n"
-	   "                         [--max-input-pack-size=<bytes>]"),
+	   "                         [--max-input-pack-size=<bytes>]\n"
+	   "                         [--keep-pack=<pack-name>]"),
 	NULL
 };
 
@@ -257,6 +259,7 @@ static int unlink_loose_paths(const struct string_list *paths)
 
 static void collect_pack_candidates(struct repository *repo,
 				    const char *packdir,
+				    const struct string_list *keep_pack_list,
 				    struct strset *cycle_exclude,
 				    struct strset *midx_exclude,
 				    struct string_list *candidates,
@@ -276,6 +279,8 @@ static void collect_pack_candidates(struct repository *repo,
 
 		strbuf_reset(&base);
 		strbuf_addstr(&base, pack_basename(p));
+		if (string_list_has_string(keep_pack_list, base.buf))
+			continue;
 		if (!strbuf_strip_suffix(&base, ".pack"))
 			continue;
 
@@ -443,6 +448,7 @@ static void unlink_consumed_packs(const char *packdir,
 }
 
 static int run_aggregation(struct repository *repo, const char *packdir,
+			   const struct string_list *keep_pack_list,
 			   struct strset *midx_exclude,
 			   int min_loose, int min_packs,
 			   int max_loose_objects, int max_objects,
@@ -515,7 +521,7 @@ static int run_aggregation(struct repository *repo, const char *packdir,
 	 * Refresh MIDX exclusions before collecting candidates.
 	 */
 	refresh_midx_exclusions(repo, midx_exclude);
-	collect_pack_candidates(repo, packdir,
+	collect_pack_candidates(repo, packdir, keep_pack_list,
 				&loose_rollup_exclude, midx_exclude, &candidates,
 				max_objects_to_idx_size(repo->hash_algo,
 							max_objects),
@@ -592,6 +598,7 @@ int cmd_pack_aggregate(int argc, const char **argv,
 	int max_packs = -1;
 	unsigned long max_input_pack_size = 0;
 	unsigned long pack_size_limit = 0;
+	struct string_list keep_pack_list = STRING_LIST_INIT_NODUP;
 	int once = 0;
 	struct option options[] = {
 		OPT_BOOL(0, "once", &once,
@@ -614,6 +621,8 @@ int cmd_pack_aggregate(int argc, const char **argv,
 		OPT_UNSIGNED(0, "max-input-pack-size", &max_input_pack_size,
 			     N_("skip packs larger than this many bytes "
 				"(0 for automatic)")),
+		OPT_STRING_LIST(0, "keep-pack", &keep_pack_list, N_("name"),
+				N_("exclude the given pack from aggregation")),
 		OPT_END(),
 	};
 	struct strset midx_exclude = STRSET_INIT;
@@ -668,13 +677,17 @@ int cmd_pack_aggregate(int argc, const char **argv,
 			max_input_pack_size = ceiling;
 	}
 
+	keep_pack_list.cmp = fspathcmp;
+	string_list_sort(&keep_pack_list);
+
 	packdir = mkpathdup("%s/pack", repo_get_object_directory(repo));
 
-	ret = run_aggregation(repo, packdir, &midx_exclude,
+	ret = run_aggregation(repo, packdir, &keep_pack_list, &midx_exclude,
 			      min_loose, min_packs,
 			      max_loose_objects, max_objects,
 			      max_packs, max_input_pack_size);
 
+	string_list_clear(&keep_pack_list, 0);
 	strset_clear(&midx_exclude);
 	free(packdir);
 	return ret ? 1 : 0;
diff --git a/builtin/repack.c b/builtin/repack.c
index c4360382c1fce2..f876501ccea689 100644
--- a/builtin/repack.c
+++ b/builtin/repack.c
@@ -36,12 +36,14 @@ static int midx_must_contain_cruft = 1;
 static int drop_filtered;
 static int dry_run;
 static int write_bitmaps_given;
+static int aggregate_once_opt = -1;
 
 static const char *const git_repack_usage[] = {
 	N_("git repack [-a] [-A] [-d] [-f] [-F] [-l] [-n] [-q] [-b] [-m]\n"
 	   "[--window=<n>] [--depth=<n>] [--threads=<n>] [--keep-pack=<pack-name>]\n"
 	   "[--write-midx[=<mode>]] [--name-hash-version=<n>] [--path-walk]\n"
-	   "[--filter=<filter-spec>] [--drop-filtered [--dry-run]]"),
+	   "[--filter=<filter-spec>] [--drop-filtered [--dry-run]]\n"
+	   "[--[no-]aggregate-once]"),
 	NULL
 };
 
@@ -117,6 +119,10 @@ static int repack_config(const char *var, const char *value,
 								      ctx->kvi);
 		return 0;
 	}
+	if (!strcmp(var, "repack.aggregateonce")) {
+		aggregate_once_opt = git_config_bool(var, value);
+		return 0;
+	}
 	return git_default_config(var, value, ctx, cb);
 }
 
@@ -155,6 +161,21 @@ static int option_parse_write_midx(const struct option *opt, const char *arg,
 	return 0;
 }
 
+static int run_pack_aggregate_once(const struct string_list *keep_pack_list)
+{
+	struct child_process cmd = CHILD_PROCESS_INIT;
+	struct string_list_item *item;
+
+	strvec_pushl(&cmd.args, "pack-aggregate", "--once", NULL);
+	for_each_string_list_item(item, keep_pack_list)
+		strvec_pushf(&cmd.args, "--keep-pack=%s", item->string);
+	cmd.git_cmd = 1;
+
+	if (run_command(&cmd))
+		return error(_("git pack-aggregate --once failed"));
+	return 0;
+}
+
 int cmd_repack(int argc,
 	       const char **argv,
 	       const char *prefix,
@@ -261,6 +282,8 @@ int cmd_repack(int argc,
 				N_("delete filtered out objects (requires --filter)")),
 		OPT_BOOL(0, "dry-run", &dry_run,
 				N_("only show which objects would be dropped")),
+		OPT_BOOL(0, "aggregate-once", &aggregate_once_opt,
+			 N_("run pack-aggregate once before repacking")),
 		OPT_END()
 	};
 
@@ -417,6 +440,14 @@ int cmd_repack(int argc,
 	    write_midx == REPACK_WRITE_MIDX_NONE)
 		die(_(incremental_bitmap_conflict_error));
 
+	if (geometry.split_factor && pack_everything)
+		die(_("options '%s' and '%s' cannot be used together"),
+		    "--geometric", "-A/-a");
+
+	if (filter_to && !po_args.filter_options.choice)
+		die(_("option '%s' can only be used along with '%s'"),
+		    "--filter-to", "--filter");
+
 	if (write_bitmaps && po_args.local &&
 	    odb_has_alternates(repo->objects)) {
 		/*
@@ -437,6 +468,12 @@ int cmd_repack(int argc,
 		die(_("invalid value for %s: %d"), "--midx-new-layer-threshold",
 		    config_ctx.midx_new_layer_threshold);
 
+	if (aggregate_once_opt > 0 &&
+	    run_pack_aggregate_once(&keep_pack_list)) {
+		ret = 1;
+		goto cleanup;
+	}
+
 	if (write_midx != REPACK_WRITE_MIDX_NONE && write_bitmaps) {
 		struct strbuf path = STRBUF_INIT;
 
@@ -458,8 +495,6 @@ int cmd_repack(int argc,
 	existing_packs_collect(&existing, &keep_pack_list);
 
 	if (geometry.split_factor) {
-		if (pack_everything)
-			die(_("options '%s' and '%s' cannot be used together"), "--geometric", "-A/-a");
 		if (write_midx == REPACK_WRITE_MIDX_INCREMENTAL) {
 			geometry.midx_layer_threshold = config_ctx.midx_new_layer_threshold;
 			geometry.midx_layer_threshold_set = true;
@@ -546,8 +581,6 @@ int cmd_repack(int argc,
 	if (po_args.filter_options.choice)
 		strvec_pushf(&cmd.args, "--filter=%s",
 			     expand_list_objects_filter_spec(&po_args.filter_options));
-	else if (filter_to)
-		die(_("option '%s' can only be used along with '%s'"), "--filter-to", "--filter");
 
 	if (geometry.split_factor)
 		cmd.in = -1;
diff --git a/t/t5336-pack-aggregate.sh b/t/t5336-pack-aggregate.sh
index 4692578554b8e0..120a9289621419 100755
--- a/t/t5336-pack-aggregate.sh
+++ b/t/t5336-pack-aggregate.sh
@@ -152,6 +152,36 @@ test_expect_success '--once prefers an existing delta over a duplicate base copy
 	)
 '
 
+test_expect_success '--keep-pack excludes repeated names before applying --min-packs' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		build_n_packs 6 >packs.txt &&
+		sort -r packs.txt >sorted &&
+		first=$(head -n 1 sorted) &&
+		second=$(sed -n 2p sorted) &&
+		git pack-aggregate --once --min-loose=1000 \
+			--min-packs=5 \
+			--keep-pack="$first.pack" \
+			--keep-pack="$second.pack" &&
+		test 6 -eq "$(count_packs)" &&
+		git pack-aggregate --once --min-loose=1000 \
+			--min-packs=4 \
+			--keep-pack="$first.pack" \
+			--keep-pack="$second.pack" &&
+		test 3 -eq "$(count_packs)" &&
+		test 1 -eq "$(count_baddeltas)" &&
+		for name in "$first" "$second"
+		do
+			test_path_is_file ".git/objects/pack/$name.pack" &&
+			test_path_is_file ".git/objects/pack/$name.idx" ||
+			return 1
+		done &&
+		git fsck
+	)
+'
+
 for input_mode in loose packed
 do
 	test_expect_success "pack.packSizeLimit splits $input_mode aggregation outputs" '
@@ -800,4 +830,114 @@ test_expect_success 'geometric repack leaves non-baddeltas packs above the split
 	)
 '
 
+# ---- repack integration ----
+
+test_expect_success 'repack does not aggregate by default' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		build_n_packs 3 >/dev/null &&
+		GIT_TRACE2_EVENT="$(pwd)/trace.txt" \
+			git repack -d --geometric=2 &&
+		test_grep ! "\"pack-aggregate\"" trace.txt
+	)
+'
+
+test_expect_success 'repack --aggregate-once runs pack-aggregate once' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		build_n_packs 3 >/dev/null &&
+		GIT_TRACE2_EVENT="$(pwd)/trace.txt" \
+			git repack -d --geometric=2 --aggregate-once &&
+		test_grep "\"argv\":.*\"pack-aggregate\",\"--once\"" trace.txt &&
+		git fsck
+	)
+'
+
+test_expect_success 'repack --aggregate-once honors repeated --keep-pack' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		build_n_packs 7 >packs.txt &&
+		first=$(head -n 1 packs.txt) &&
+		second=$(sed -n 2p packs.txt) &&
+		git cat-file --batch-all-objects \
+			--batch-check="create refs/tags/%(objectname) %(objectname)" \
+			>refs &&
+		git update-ref --stdin <refs &&
+		GIT_TRACE2_EVENT="$(pwd)/trace.txt" \
+			git repack -ad --aggregate-once \
+				--keep-pack="$first.pack" \
+				--keep-pack="$second.pack" &&
+		test_grep "\"argv\":.*\"pack-objects\".*\"--mark-bad-deltas\"" \
+			trace.txt &&
+		for name in "$first" "$second"
+		do
+			test_path_is_file ".git/objects/pack/$name.pack" &&
+			test_path_is_file ".git/objects/pack/$name.idx" ||
+			return 1
+		done &&
+		test 3 -eq "$(count_packs)" &&
+		git fsck
+	)
+'
+
+test_expect_success 'repack stops when --aggregate-once fails' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		build_n_packs 3 >/dev/null &&
+		test_env GIT_TRACE2_EVENT="$(pwd)/trace.txt" \
+			test_must_fail git -c pack.aggregateMaxObjects=-1 \
+				repack -d --geometric=2 \
+				--aggregate-once 2>err &&
+		test_grep "pack.aggregateMaxObjects cannot be negative" err &&
+		test_grep "git pack-aggregate --once failed" err &&
+		test_grep ! "\"argv\":.*\"pack-objects\"" trace.txt
+	)
+'
+
+test_expect_success 'repack --aggregate-once handles an existing MIDX' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		build_n_packs 5 >/dev/null &&
+		git multi-pack-index write &&
+		git repack -d --geometric=2 --aggregate-once --write-midx &&
+		git fsck
+	)
+'
+
+test_expect_success 'repack aggregation config enables once mode' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		build_n_packs 3 >/dev/null &&
+		GIT_TRACE2_EVENT="$(pwd)/trace.txt" \
+			git -c repack.aggregateOnce=true \
+			repack -d --geometric=2 &&
+		test_grep "\"argv\":.*\"pack-aggregate\",\"--once\"" trace.txt
+	)
+'
+
+test_expect_success 'CLI can disable configured once aggregation' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		build_n_packs 3 >/dev/null &&
+		GIT_TRACE2_EVENT="$(pwd)/trace.txt" \
+			git -c repack.aggregateOnce=true \
+			repack -d --geometric=2 --no-aggregate-once &&
+		test_grep ! "\"pack-aggregate\"" trace.txt
+	)
+'
+
 test_done

From e58da75aa0723a10b703400b91ae54c07bf23987 Mon Sep 17 00:00:00 2001
From: Elijah Newren <newren@gmail.com>
Date: Sat, 6 Jun 2026 11:44:37 -0700
Subject: [PATCH 14/18] pack-objects: add --emit-input-{packs,loose} plumbing
 options

Let pack-objects publish the local packs and loose objects visible
before object enumeration, using `--emit-input-packs` and
`--emit-input-loose`.  A concurrent maintenance process can exclude
these inputs without racing to enumerate them before pack-objects.

Include all local packs, not just those selected for rewriting.  A
geometric repack may include retained packs in its replacement MIDX;
a concurrent aggregator must leave them alone too, or the MIDX could
reference a pack it retired.

The loose-object snapshot reduces duplicate packing: deleting a loose
copy does not prevent pack-objects from writing another packed copy.

Write each file through `<file>.tmp` and rename it into place, so
readers never see a partial list.  These options support the planned
background repack integration and remain undocumented.

Assisted-by: Claude Opus 4.7 & GPT-5.6 Sol
Signed-off-by: Elijah Newren <newren@gmail.com>
---
 builtin/pack-objects.c | 75 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 75 insertions(+)

diff --git a/builtin/pack-objects.c b/builtin/pack-objects.c
index 06b85ed434bb97..2a76e9fb89a5c6 100644
--- a/builtin/pack-objects.c
+++ b/builtin/pack-objects.c
@@ -215,6 +215,8 @@ static timestamp_t unpack_unreachable_expiration;
 static int pack_loose_unreachable;
 static int cruft;
 static int mark_bad_deltas;
+static const char *emit_input_packs_path;
+static const char *emit_input_loose_path;
 static int shallow = 0;
 static timestamp_t cruft_expiration;
 static int local;
@@ -5231,6 +5233,68 @@ static int parse_stdin_packs_mode(const struct option *opt, const char *arg,
 	return 0;
 }
 
+static void emit_input_packs_to_file(const char *path)
+{
+	struct strbuf tmp = STRBUF_INIT;
+	struct packed_git *p;
+	FILE *fp;
+
+	strbuf_addf(&tmp, "%s.tmp", path);
+	fp = fopen(tmp.buf, "w");
+	if (!fp)
+		die_errno(_("unable to write '%s'"), tmp.buf);
+	/*
+	 * This is deliberately a conservative snapshot of every local pack,
+	 * not just packs selected by this invocation.  A geometric repack can
+	 * leave packs untouched but still include them in its replacement MIDX,
+	 * so a concurrent aggregator must exclude them too.
+	 */
+	repo_for_each_pack(the_repository, p) {
+		/* Exclude alternates */
+		if (!p->pack_local)
+			continue;
+		fprintf(fp, "%s\n", pack_basename(p));
+	}
+	if (fclose(fp))
+		die_errno(_("unable to write '%s'"), tmp.buf);
+	if (rename(tmp.buf, path))
+		die_errno(_("unable to rename '%s' to '%s'"), tmp.buf, path);
+	strbuf_release(&tmp);
+}
+
+static int emit_input_loose_cb(const struct object_id *oid,
+			       const char *path UNUSED,
+			       void *data)
+{
+	FILE *fp = data;
+	fprintf(fp, "%s\n", oid_to_hex(oid));
+	return 0;
+}
+
+static void emit_input_loose_to_file(const char *path)
+{
+	struct strbuf tmp = STRBUF_INIT;
+	FILE *fp;
+
+	strbuf_addf(&tmp, "%s.tmp", path);
+	fp = fopen(tmp.buf, "w");
+	if (!fp)
+		die_errno(_("unable to write '%s'"), tmp.buf);
+	/*
+	 * Note: for_each_loose_file_in_source() walks only the local
+	 * source (sources->next is skipped), thus excluding
+	 * alternates and matching the "p->pack_local" check in
+	 * emit_input_packs_to_file().
+	 */
+	for_each_loose_file_in_source(the_repository->objects->sources,
+				      emit_input_loose_cb, NULL, NULL, fp);
+	if (fclose(fp))
+		die_errno(_("unable to write '%s'"), tmp.buf);
+	if (rename(tmp.buf, path))
+		die_errno(_("unable to rename '%s' to '%s'"), tmp.buf, path);
+	strbuf_release(&tmp);
+}
+
 int cmd_pack_objects(int argc,
 		     const char **argv,
 		     const char *prefix,
@@ -5332,6 +5396,12 @@ int cmd_pack_objects(int argc,
 			 N_("ignore packs that have companion .keep file")),
 		OPT_STRING_LIST(0, "keep-pack", &keep_pack_list, N_("name"),
 				N_("ignore this pack")),
+		OPT_STRING(0, "emit-input-packs", &emit_input_packs_path,
+			   N_("file"),
+			   N_("write basenames of all local packs to <file>")),
+		OPT_STRING(0, "emit-input-loose", &emit_input_loose_path,
+			   N_("file"),
+			   N_("write OIDs of local loose objects to <file>")),
 		OPT_INTEGER(0, "compression", &cfg->pack_compression_level,
 			    N_("pack compression level")),
 		OPT_BOOL(0, "keep-true-parents", &grafts_keep_true_parents,
@@ -5592,6 +5662,11 @@ int cmd_pack_objects(int argc,
 			    the_repository);
 	prepare_packing_data(the_repository, &to_pack);
 
+	if (emit_input_packs_path)
+		emit_input_packs_to_file(emit_input_packs_path);
+	if (emit_input_loose_path)
+		emit_input_loose_to_file(emit_input_loose_path);
+
 	if (progress && !cruft)
 		progress_state = start_progress(the_repository,
 						_("Enumerating objects"), 0);

From 8f27a9d4515ece01cde5f07438cd9bc0aed24824 Mon Sep 17 00:00:00 2001
From: Elijah Newren <newren@gmail.com>
Date: Tue, 4 Aug 2026 13:29:22 -0700
Subject: [PATCH 15/18] pack-aggregate: add a --loop mode for continuous
 aggregation

The `--once` mode provides a quick manual cleanup pass, but a
long-running repack leaves time for new loose objects and small push
packs to accumulate while it works.  Repeated aggregation can keep
that new material under control without interfering with the larger
repack, provided the two processes operate on disjoint inputs.

Add a `--loop` mode that runs aggregation passes repeatedly, sleeping
`--interval` seconds between them.  Add exclusion files for packs and
loose objects so a concurrent `pack-objects` can declare the inputs it
owns; the aggregator skips those inputs on every pass.

Add `--parent-pipe-fd` so a parent process can keep the aggregator
alive by holding a pipe open.  Poll the pipe during the interval so
the aggregator exits promptly when its parent goes away.

Handle termination signals by recording a stop request so the current
cycle can unwind and the loop can exit at a safe boundary.  An in-flight
`pack-objects` is already marked `clean_on_exit`, so run-command's
standard signal cleanup forwards the signal to it before chaining to
the loop's handler.  This stops the child promptly while allowing the
loop to unwind in an orderly way.

Assisted-by: Claude Opus 4.7/4.8 & GPT-5.6 Sol
Signed-off-by: Elijah Newren <newren@gmail.com>
---
 Documentation/git-pack-aggregate.adoc |  92 +++++++++----
 builtin/pack-aggregate.c              | 180 +++++++++++++++++++++++---
 t/t5336-pack-aggregate.sh             |  48 ++++++-
 3 files changed, 271 insertions(+), 49 deletions(-)

diff --git a/Documentation/git-pack-aggregate.adoc b/Documentation/git-pack-aggregate.adoc
index 544c08dbaebff8..0f2070fed86a11 100644
--- a/Documentation/git-pack-aggregate.adoc
+++ b/Documentation/git-pack-aggregate.adoc
@@ -9,25 +9,33 @@ without doing any delta compression or search
 SYNOPSIS
 --------
 [verse]
-'git pack-aggregate' --once [--min-loose=<n>] [--min-packs=<n>]
+'git pack-aggregate' (--once | --loop) [--interval=<seconds>]
+                   [--min-loose=<n>] [--min-packs=<n>]
                    [--max-loose-objects=<n>]
                    [--max-objects=<n>] [--max-packs=<n>]
                    [--max-input-pack-size=<bytes>]
                    [--keep-pack=<pack-name>]
+                   [--exclude-pack-file=<path>]
+                   [--exclude-loose-file=<path>]
+                   [--parent-pipe-fd=<n>]
 
 DESCRIPTION
 -----------
 
 `git pack-aggregate` rolls accumulated loose objects and small
-packfiles into new packs in two steps:
-
-1. Bundle local loose objects into new packs and unlink the loose copies.
-2. Aggregate small local packs (minus those named by `--keep-pack`,
-   referenced by the multi-pack-index, or carrying a `.keep`, `.promisor`,
-   `.mtimes`, or `.bitmap` sidecar) into new packs and unlink the source packs.
-   If step 1 writes a single pack, it is naturally a candidate here
-   and will normally be folded into the step-2 output.  Multiple
-   loose-rollup packs are left for a later aggregation pass.
+packfiles into new packs.  It can run one cycle as a quick recovery
+step, or run cycles periodically to keep new material under control
+while longer-running maintenance proceeds.  Each cycle has two steps:
+
+1. Bundle local loose objects (minus any listed in
+   `--exclude-loose-file`) into new packs and unlink the loose copies.
+2. Aggregate small local packs (minus any excluded by `--keep-pack` or
+   `--exclude-pack-file`, or those referenced by the multi-pack-index,
+   or those carrying a `.keep`, `.promisor`, `.mtimes`, or `.bitmap`
+   sidecar) into new packs and unlink the source packs.  If step 1
+   writes a single pack, it is naturally a candidate here and will
+   normally be folded into the step-2 output.  Multiple loose-rollup
+   packs are left for a later cycle.
 
 No delta search is performed and no bitmaps or commit-graphs are updated.
 Existing packed representations are reused where possible.  When an
@@ -46,37 +54,69 @@ By default, step 2 skips packs larger than half that limit to avoid
 repeatedly copying nearly full packs without reducing the pack count.
 See `--max-input-pack-size` for a smaller input-size threshold.
 
-This command provides a quick recovery step for a repository that has
-accumulated many loose objects or small packs.  It reduces the number
-of files that unrelated `git` operations must scan, while leaving a
-later thorough linkgit:git-repack[1] to optimize deltas and pack layout.
-The `repack.aggregateOnce` configuration variable (see
-linkgit:git-repack[1]) lets `git repack` request this cleanup before
-beginning that more expensive work.
-
-Like `git repack`, `git pack-aggregate` takes no locks of its own.  Do
-not run it concurrently with other pack-rewriting maintenance.
+This command serves two related purposes.  With `--once`, it provides a
+quick recovery step for a repository that has accumulated many loose
+objects or small packs.  With `--loop`, it keeps new material under
+control while a long-running repack is in flight.  Both reduce the
+number of files that unrelated Git operations must scan, while leaving
+a later thorough linkgit:git-repack[1] to optimize deltas and pack
+layout.  The `repack.aggregateOnce` configuration variable (see
+linkgit:git-repack[1]) lets `git repack` request the one-shot cleanup
+before beginning that more expensive work.
+
+Like linkgit:git-repack[1], `git pack-aggregate` takes no locks of its
+own.  Callers that need serialization must arrange it themselves (for
+example by running under `git gc`).
+Callers can declare "do not touch these inputs" with `--keep-pack`,
+`--exclude-pack-file`, and `--exclude-loose-file`.
 
 OPTIONS
 -------
 
 --once::
-	Run one aggregation pass and exit.  This option is required.
+	Run a single cycle and exit.  Exactly one of `--once` or
+	`--loop` is required.
+
+--loop::
+	Run cycles forever, sleeping `--interval` seconds between
+	cycles.  Stops on `SIGTERM`, `SIGHUP`, or `SIGINT`.
+
+--interval=<seconds>::
+	Number of seconds to sleep between the end of one cycle and the
+	start of the next.  Defaults to 60.  Only meaningful with
+	`--loop`.
 
 --min-loose=<n>::
-	Skip aggregation of loose objects if fewer than `<n>` are present.
-	Defaults to 5.
+	Skip aggregation of loose objects if fewer than `<n>` remain
+	after applying `--exclude-loose-file`.  Defaults to 5.
 
 --min-packs=<n>::
-	Skip aggregation of small packfiles if fewer than `<n>` aggregatable
-	packs are present.
-	Defaults to 5.
+	Skip aggregation of small packfiles if fewer than `<n>`
+	aggregatable packs remain after applying all exclusions.  Defaults
+	to 5.
 
 --keep-pack=<pack-name>::
 	Exclude the given pack from aggregation.  `<pack-name>` is the pack
 	file name without a leading directory (e.g. `pack-123.pack`).
 	This option can be repeated to keep multiple packs.
 
+--exclude-pack-file=<path>::
+	Read a list of pack basenames (one per line) from `<path>` and
+	never touch any of those packs.  Lines may name a basename with
+	or without a `.pack` or `.idx` suffix; the suffix is stripped.
+	Blank lines and lines beginning with `#` are ignored.
+
+--exclude-loose-file=<path>::
+	Read a list of loose object IDs (one per line) from `<path>`
+	and never pack or unlink any of those loose objects.  Blank
+	lines and lines beginning with `#` are ignored.
+
+--parent-pipe-fd=<n>::
+	An inherited pipe file descriptor whose write end the parent
+	process holds open.  When the parent exits the pipe is closed
+	and `git pack-aggregate` exits at the next cycle boundary,
+	without waiting out the remainder of `--interval`.
+
 --max-loose-objects=<n>::
 	Process at most `<n>` loose objects per batch.  All output packs
 	are installed and the loose copies are removed before the next
diff --git a/builtin/pack-aggregate.c b/builtin/pack-aggregate.c
index 2b087350f5bc6d..6647e4b66b98d0 100644
--- a/builtin/pack-aggregate.c
+++ b/builtin/pack-aggregate.c
@@ -15,6 +15,7 @@
 #include "path.h"
 #include "repository.h"
 #include "run-command.h"
+#include "sigchain.h"
 #include "strbuf.h"
 #include "string-list.h"
 #include "strmap.h"
@@ -23,11 +24,15 @@
 #include "wrapper.h"
 
 static const char *const pack_aggregate_usage[] = {
-	N_("git pack-aggregate --once [--min-loose=<n>] [--min-packs=<n>]\n"
-	   "                         [--max-loose-objects=<n>]\n"
-	   "                         [--max-objects=<n>] [--max-packs=<n>]\n"
-	   "                         [--max-input-pack-size=<bytes>]\n"
-	   "                         [--keep-pack=<pack-name>]"),
+	N_("git pack-aggregate (--once | --loop) [--interval=<seconds>]\n"
+	   "                  [--min-loose=<n>] [--min-packs=<n>]\n"
+	   "                  [--max-loose-objects=<n>]\n"
+	   "                  [--max-objects=<n>] [--max-packs=<n>]\n"
+	   "                  [--max-input-pack-size=<bytes>]\n"
+	   "                  [--keep-pack=<pack-name>]\n"
+	   "                  [--exclude-pack-file=<path>]\n"
+	   "                  [--exclude-loose-file=<path>]\n"
+	   "                  [--parent-pipe-fd=<n>]"),
 	NULL
 };
 
@@ -37,6 +42,14 @@ static const char *const pack_aggregate_usage[] = {
 
 #define DEFAULT_MAX_PACKS 10000
 
+static volatile sig_atomic_t stop_signaled;
+static int parent_pipe_fd = -1;
+
+static void term_handler(int sig UNUSED)
+{
+	stop_signaled = 1;
+}
+
 static int has_sidecar(const char *packdir, const char *basename,
 		       const char *ext)
 {
@@ -102,6 +115,27 @@ static off_t max_objects_to_idx_size(const struct git_hash_algo *algo,
 	return 8 + 1024 + 2 * rawsz + (rawsz + 8) * (off_t)max_objects;
 }
 
+static void load_exclusions_from_file(const char *path, struct strset *set)
+{
+	FILE *fp;
+	struct strbuf line = STRBUF_INIT;
+
+	fp = fopen(path, "r");
+	if (!fp)
+		die_errno(_("could not open exclude file '%s'"), path);
+
+	while (strbuf_getline_lf(&line, fp) != EOF) {
+		strbuf_trim(&line);
+		if (!line.len || line.buf[0] == '#')
+			continue;
+		strbuf_strip_suffix(&line, ".pack");
+		strbuf_strip_suffix(&line, ".idx");
+		strset_add(set, line.buf);
+	}
+	strbuf_release(&line);
+	fclose(fp);
+}
+
 /*
  * Re-read the multi-pack-index (and any incremental layers) and
  * populate `set` with the basenames of every referenced pack.  The
@@ -135,6 +169,7 @@ static void refresh_midx_exclusions(struct repository *repo,
 /* ---------- loose-object pre-pass ---------- */
 
 struct loose_scan {
+	struct strset *exclude;
 	struct oid_array *oids;
 	struct string_list *paths;
 	size_t limit;
@@ -169,6 +204,8 @@ static int loose_scan_cb(const struct object_id *oid, const char *path,
 	struct loose_scan *data = cb_data;
 	struct stat st;
 
+	if (strset_contains(data->exclude, oid_to_hex(oid)))
+		return 0;
 	if (lstat(path, &st)) {
 		if (errno != ENOENT)
 			warning_errno(_("could not stat loose object '%s'"),
@@ -260,6 +297,7 @@ static int unlink_loose_paths(const struct string_list *paths)
 static void collect_pack_candidates(struct repository *repo,
 				    const char *packdir,
 				    const struct string_list *keep_pack_list,
+				    struct strset *file_exclude,
 				    struct strset *cycle_exclude,
 				    struct strset *midx_exclude,
 				    struct string_list *candidates,
@@ -284,6 +322,8 @@ static void collect_pack_candidates(struct repository *repo,
 		if (!strbuf_strip_suffix(&base, ".pack"))
 			continue;
 
+		if (strset_contains(file_exclude, base.buf))
+			continue;
 		if (strset_contains(cycle_exclude, base.buf))
 			continue;
 		if (strset_contains(midx_exclude, base.buf))
@@ -447,16 +487,19 @@ static void unlink_consumed_packs(const char *packdir,
 	}
 }
 
-static int run_aggregation(struct repository *repo, const char *packdir,
-			   const struct string_list *keep_pack_list,
-			   struct strset *midx_exclude,
-			   int min_loose, int min_packs,
-			   int max_loose_objects, int max_objects,
-			   int max_packs, unsigned long max_input_pack_size)
+static int do_one_cycle(struct repository *repo, const char *packdir,
+			const struct string_list *keep_pack_list,
+			struct strset *pack_exclude,
+			struct strset *loose_exclude,
+			struct strset *midx_exclude,
+			int min_loose, int min_packs,
+			int max_loose_objects, int max_objects,
+			int max_packs, unsigned long max_input_pack_size)
 {
 	struct oid_array loose_oids = OID_ARRAY_INIT;
 	struct string_list loose_paths = STRING_LIST_INIT_DUP;
 	struct loose_scan loose_data = {
+		.exclude = loose_exclude,
 		.oids = &loose_oids,
 		.paths = &loose_paths,
 		.limit = max_loose_objects,
@@ -478,10 +521,10 @@ static int run_aggregation(struct repository *repo, const char *packdir,
 	set_loose_scan_cutoff(repo, &loose_data);
 	for_each_loose_file_in_source(repo->objects->sources,
 				      loose_scan_cb, NULL, NULL, &loose_data);
-	if (loose_data.eligible >= (size_t)min_loose) {
+	if (loose_data.eligible >= (size_t)min_loose && !stop_signaled) {
 		packtmp_loose = mkpathdup("%s/.tmp-%d-loose-pack",
 					  packdir, (int)getpid());
-		while (loose_oids.nr) {
+		while (loose_oids.nr && !stop_signaled) {
 			string_list_clear(&output_hashes, 0);
 			if (run_pack_objects_loose(packtmp_loose, &loose_oids,
 						   &output_hashes)) {
@@ -501,6 +544,8 @@ static int run_aggregation(struct repository *repo, const char *packdir,
 
 			oid_array_clear(&loose_oids);
 			string_list_clear(&loose_paths, 0);
+			if (stop_signaled)
+				break;
 
 			/* Once rollup starts, also consume a final partial batch. */
 			loose_data.minimum = 1;
@@ -514,6 +559,9 @@ static int run_aggregation(struct repository *repo, const char *packdir,
 	if (strset_get_size(&loose_rollup_exclude) == 1)
 		strset_clear(&loose_rollup_exclude);
 
+	if (stop_signaled)
+		goto out;
+
 	/*
 	 * Step 2: aggregate small packs. Let a single pack produced from loose
 	 * objects participate, but defer multiple packs to avoid copying
@@ -521,7 +569,7 @@ static int run_aggregation(struct repository *repo, const char *packdir,
 	 * Refresh MIDX exclusions before collecting candidates.
 	 */
 	refresh_midx_exclusions(repo, midx_exclude);
-	collect_pack_candidates(repo, packdir, keep_pack_list,
+	collect_pack_candidates(repo, packdir, keep_pack_list, pack_exclude,
 				&loose_rollup_exclude, midx_exclude, &candidates,
 				max_objects_to_idx_size(repo->hash_algo,
 							max_objects),
@@ -549,7 +597,8 @@ static int run_aggregation(struct repository *repo, const char *packdir,
 			batch_size = DIV_ROUND_UP(total, num_batches);
 		}
 
-		for (start = 0; start < total; start += batch_size) {
+		for (start = 0; start < total && !stop_signaled;
+		     start += batch_size) {
 			size_t count = batch_size;
 
 			if (start + count > total)
@@ -588,9 +637,57 @@ static int run_aggregation(struct repository *repo, const char *packdir,
 	return ret;
 }
 
+static void interruptible_sleep(unsigned int seconds)
+{
+	struct pollfd pfd;
+	int timeout_ms;
+
+	if (stop_signaled)
+		return;
+
+	if (parent_pipe_fd < 0) {
+		unsigned int remaining = seconds;
+		while (remaining > 0 && !stop_signaled)
+			remaining = sleep(remaining);
+		return;
+	}
+
+	/*
+	 * Watch the parent pipe so we wake immediately if the process
+	 * that spawned us exits.  POLLHUP is reported in revents
+	 * regardless of whether it appears in events, so we leave
+	 * events==0; any of POLLHUP/POLLERR/POLLNVAL/POLLIN means the
+	 * other end of the pipe is gone and we should stop.
+	 */
+	pfd.fd = parent_pipe_fd;
+	pfd.events = 0;
+	timeout_ms = (seconds > INT_MAX / 1000) ? INT_MAX
+					       : (int)(seconds * 1000);
+
+	while (!stop_signaled) {
+		int ret;
+		pfd.revents = 0;
+		ret = poll(&pfd, 1, timeout_ms);
+		if (ret < 0) {
+			if (errno == EINTR)
+				continue;
+			break;
+		}
+		if (ret == 0)
+			break;
+		if (pfd.revents & (POLLHUP | POLLERR | POLLNVAL | POLLIN)) {
+			stop_signaled = 1;
+			break;
+		}
+	}
+}
+
 int cmd_pack_aggregate(int argc, const char **argv,
 		       const char *prefix, struct repository *repo)
 {
+	const char *exclude_pack_file = NULL;
+	const char *exclude_loose_file = NULL;
+	int interval = 60;
 	int min_packs = 5;
 	int min_loose = 5;
 	int max_loose_objects = -1;
@@ -600,9 +697,16 @@ int cmd_pack_aggregate(int argc, const char **argv,
 	unsigned long pack_size_limit = 0;
 	struct string_list keep_pack_list = STRING_LIST_INIT_NODUP;
 	int once = 0;
+	int loop = 0;
 	struct option options[] = {
 		OPT_BOOL(0, "once", &once,
 			 N_("run a single cycle and exit")),
+		OPT_BOOL(0, "loop", &loop,
+			 N_("loop forever, sleeping --interval seconds "
+			    "between cycles")),
+		OPT_INTEGER(0, "interval", &interval,
+			    N_("seconds to sleep between cycles "
+			       "(default 60)")),
 		OPT_INTEGER(0, "min-loose", &min_loose,
 			    N_("skip loose-object rollup if fewer "
 			       "candidates (default 5)")),
@@ -623,8 +727,21 @@ int cmd_pack_aggregate(int argc, const char **argv,
 				"(0 for automatic)")),
 		OPT_STRING_LIST(0, "keep-pack", &keep_pack_list, N_("name"),
 				N_("exclude the given pack from aggregation")),
+		OPT_STRING(0, "exclude-pack-file", &exclude_pack_file,
+			   N_("file"),
+			   N_("file listing pack basenames never to "
+			      "touch")),
+		OPT_STRING(0, "exclude-loose-file", &exclude_loose_file,
+			   N_("file"),
+			   N_("file listing loose object OIDs never to "
+			      "touch")),
+		OPT_INTEGER(0, "parent-pipe-fd", &parent_pipe_fd,
+			    N_("inherited fd of a pipe whose write end "
+			       "the parent holds; EOF triggers exit")),
 		OPT_END(),
 	};
+	struct strset pack_exclude = STRSET_INIT;
+	struct strset loose_exclude = STRSET_INIT;
 	struct strset midx_exclude = STRSET_INIT;
 	char *packdir;
 	int ret = 0;
@@ -637,8 +754,10 @@ int cmd_pack_aggregate(int argc, const char **argv,
 			     pack_aggregate_usage, 0);
 	if (argc > 0)
 		usage_with_options(pack_aggregate_usage, options);
-	if (!once)
-		die(_("--once is required"));
+	if (once == loop)
+		die(_("exactly one of --once or --loop is required"));
+	if (interval < 1)
+		die(_("--interval must be at least 1"));
 	if (min_loose < 1)
 		die(_("--min-loose must be at least 1"));
 	if (min_packs < 1)
@@ -682,12 +801,31 @@ int cmd_pack_aggregate(int argc, const char **argv,
 
 	packdir = mkpathdup("%s/pack", repo_get_object_directory(repo));
 
-	ret = run_aggregation(repo, packdir, &keep_pack_list, &midx_exclude,
-			      min_loose, min_packs,
-			      max_loose_objects, max_objects,
-			      max_packs, max_input_pack_size);
+	if (exclude_pack_file)
+		load_exclusions_from_file(exclude_pack_file, &pack_exclude);
+	if (exclude_loose_file)
+		load_exclusions_from_file(exclude_loose_file, &loose_exclude);
+
+	sigchain_push(SIGTERM, term_handler);
+	sigchain_push(SIGHUP, term_handler);
+	sigchain_push(SIGINT, term_handler);
+
+	do {
+		if (stop_signaled)
+			break;
+		ret = do_one_cycle(repo, packdir, &keep_pack_list,
+				   &pack_exclude, &loose_exclude, &midx_exclude,
+				   min_loose, min_packs,
+				   max_loose_objects, max_objects,
+				   max_packs, max_input_pack_size);
+		if (ret || once || stop_signaled)
+			break;
+		interruptible_sleep((unsigned int)interval);
+	} while (!stop_signaled);
 
 	string_list_clear(&keep_pack_list, 0);
+	strset_clear(&pack_exclude);
+	strset_clear(&loose_exclude);
 	strset_clear(&midx_exclude);
 	free(packdir);
 	return ret ? 1 : 0;
diff --git a/t/t5336-pack-aggregate.sh b/t/t5336-pack-aggregate.sh
index 120a9289621419..a8750973b5a02f 100755
--- a/t/t5336-pack-aggregate.sh
+++ b/t/t5336-pack-aggregate.sh
@@ -82,13 +82,13 @@ test_expect_success 'setup an empty repo' '
 	git init repo
 '
 
-test_expect_success '--once is required' '
+test_expect_success 'an aggregation mode is required' '
 	test_when_finished "rm -fr work" &&
 	cp -R repo work &&
 	(
 		cd work &&
 		test_must_fail git pack-aggregate 2>err &&
-		test_grep -- "--once is required" err
+		test_grep "exactly one of --once or --loop" err
 	)
 '
 
@@ -237,6 +237,28 @@ do
 	'
 done
 
+test_expect_success '--exclude-pack-file protects listed packs' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		build_n_packs 6 >packs.txt &&
+		head -n 2 packs.txt >exclude.txt &&
+		git pack-aggregate --once \
+			--min-loose=1000 --min-packs=4 \
+			--exclude-pack-file=exclude.txt &&
+		while read name
+		do
+			test_path_is_file \
+				.git/objects/pack/${name}.pack || return 1
+		done <exclude.txt &&
+		# 2 excluded + 1 aggregate = 3 packs total.
+		test 3 -eq "$(count_packs)" &&
+		test 1 -eq "$(count_baddeltas)" &&
+		git fsck
+	)
+'
+
 test_expect_success 'sidecar-marked packs are skipped' '
 	test_when_finished "rm -fr work" &&
 	cp -R repo work &&
@@ -646,6 +668,28 @@ test_expect_success 'aggregates loose objects above --min-loose' '
 	)
 '
 
+test_expect_success '--exclude-loose-file protects listed loose objects' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		build_n_loose 5 >loose.txt &&
+		head -n 2 loose.txt >exclude.txt &&
+		git pack-aggregate --once \
+			--min-loose=1 --min-packs=1000 \
+			--exclude-loose-file=exclude.txt &&
+		while read oid
+		do
+			test_path_is_file \
+				".git/objects/$(test_oid_to_path "$oid")" ||
+				return 1
+		done <exclude.txt &&
+		test 2 -eq "$(count_loose)" &&
+		test 1 -eq "$(count_packs)" &&
+		git fsck
+	)
+'
+
 test_expect_success 'loose then pack aggregation in one cycle' '
 	test_when_finished "rm -fr work" &&
 	cp -R repo work &&

From fa0065812e12e6bb002d7e1898cfc4ceaa9471b2 Mon Sep 17 00:00:00 2001
From: Elijah Newren <newren@gmail.com>
Date: Thu, 13 Aug 2026 11:15:22 -0700
Subject: [PATCH 16/18] repack, pack-aggregate: never consume in-flight temp
 packs

Both `git repack` and `git pack-aggregate` stage a new pack as
".tmp-<pid>-pack-<hash>.*" and rename it to "pack-<hash>.*" only once it
is fully written (the .idx last).  Before running these commands
concurrently, prevent them from selecting each other's staging files.

The object-store scan treats any "*.idx" as a pack regardless of
prefix, while exclusion lists and ".keep" markers use the final
"pack-<hash>" name.  Without a name check, pack-aggregate can delete a
temporary pack owned by another process, or geometric repack can feed
it to pack-objects just before its owner renames it.

Require a canonical "pack-<hash>.pack" basename where packs are
selected, using a shared helper in collect_pack_candidates() and the
geometry rollup.  Keep the object-store scan unchanged: `git repack -ad`
legitimately enumerates stale ".tmp-*" packs in order to delete them.

Signed-off-by: Elijah Newren <newren@gmail.com>
---
 builtin/pack-aggregate.c    |  3 ++-
 packfile.c                  | 13 ++++++++++
 packfile.h                  |  5 ++++
 repack-geometry.c           |  4 ++++
 t/t5336-pack-aggregate.sh   | 35 +++++++++++++++++++++++++++
 t/t7703-repack-geometric.sh | 48 +++++++++++++++++++++++++++++++++++++
 6 files changed, 107 insertions(+), 1 deletion(-)

diff --git a/builtin/pack-aggregate.c b/builtin/pack-aggregate.c
index 6647e4b66b98d0..1ee9c4f324c01f 100644
--- a/builtin/pack-aggregate.c
+++ b/builtin/pack-aggregate.c
@@ -319,8 +319,9 @@ static void collect_pack_candidates(struct repository *repo,
 		strbuf_addstr(&base, pack_basename(p));
 		if (string_list_has_string(keep_pack_list, base.buf))
 			continue;
-		if (!strbuf_strip_suffix(&base, ".pack"))
+		if (!is_canonical_pack_basename(base.buf, repo->hash_algo->hexsz))
 			continue;
+		strbuf_strip_suffix(&base, ".pack");
 
 		if (strset_contains(file_exclude, base.buf))
 			continue;
diff --git a/packfile.c b/packfile.c
index 28cfc5313f98b0..afabc3f7614476 100644
--- a/packfile.c
+++ b/packfile.c
@@ -524,6 +524,19 @@ const char *pack_basename(struct packed_git *p)
 	return ret;
 }
 
+int is_canonical_pack_basename(const char *base, size_t hexsz)
+{
+	const char *hex;
+	size_t i;
+
+	if (!skip_prefix(base, "pack-", &hex))
+		return 0;
+	for (i = 0; i < hexsz; i++)
+		if (!isxdigit(hex[i]))
+			return 0;
+	return !strcmp(hex + hexsz, ".pack");
+}
+
 /*
  * Do not call this directly as this leaks p->pack_fd on error return;
  * call open_packed_git() instead.
diff --git a/packfile.h b/packfile.h
index 119c88942641da..c39d22b922be85 100644
--- a/packfile.h
+++ b/packfile.h
@@ -175,6 +175,11 @@ char *odb_pack_name(struct repository *r, struct strbuf *buf,
  */
 const char *pack_basename(struct packed_git *p);
 
+/*
+ * Return nonzero for a "pack-<hash>.pack" basename with hexsz hex digits.
+ */
+int is_canonical_pack_basename(const char *base, size_t hexsz);
+
 /*
  * Parse the pack idx file found at idx_path and create a packed_git struct
  * which can be used with find_pack_entry_one().
diff --git a/repack-geometry.c b/repack-geometry.c
index de3f49ad824700..6b0ae5d26015d4 100644
--- a/repack-geometry.c
+++ b/repack-geometry.c
@@ -88,6 +88,10 @@ void pack_geometry_init(struct pack_geometry *geometry,
 		if (p->is_cruft)
 			continue;
 
+		if (!is_canonical_pack_basename(pack_basename(p),
+						existing->repo->hash_algo->hexsz))
+			continue;
+
 		if (p->pack_promisor) {
 			ALLOC_GROW(geometry->promisor_pack,
 				   geometry->promisor_pack_nr + 1,
diff --git a/t/t5336-pack-aggregate.sh b/t/t5336-pack-aggregate.sh
index a8750973b5a02f..b43b0b496338cc 100755
--- a/t/t5336-pack-aggregate.sh
+++ b/t/t5336-pack-aggregate.sh
@@ -984,4 +984,39 @@ test_expect_success 'CLI can disable configured once aggregation' '
 	)
 '
 
+test_expect_success 'pack-aggregate ignores in-flight .tmp-* packs' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		build_n_packs 5 >packs.txt &&
+		# Simulate a concurrent repack or pack-aggregate that has
+		# fully written its output but not yet renamed it into
+		# place: stage one pack under a ".tmp-<pid>-pack-<hash>"
+		# name.  The object-store scan enumerates any "*.idx", so
+		# this in-flight pack becomes visible to get_all_packs();
+		# the aggregator must never treat it as a candidate, and in
+		# particular must not delete it out from under its owner.
+		victim=$(head -n 1 packs.txt) &&
+		for e in pack idx rev
+		do
+			from=.git/objects/pack/${victim}.$e &&
+			if test -f "$from"
+			then
+				mv "$from" \
+				   .git/objects/pack/.tmp-1234-${victim}.$e ||
+				return 1
+			fi
+		done &&
+		git pack-aggregate --once --min-loose=1000 --min-packs=4 &&
+		# The staged temp pack is left untouched ...
+		test_path_is_file .git/objects/pack/.tmp-1234-${victim}.pack &&
+		test_path_is_file .git/objects/pack/.tmp-1234-${victim}.idx &&
+		# ... and only the four canonical packs were rolled into a
+		# single aggregate.
+		test 1 -eq "$(count_packs)" &&
+		git fsck
+	)
+'
+
 test_done
diff --git a/t/t7703-repack-geometric.sh b/t/t7703-repack-geometric.sh
index f3a0650cfe1a2f..9d8c8801af5ad3 100755
--- a/t/t7703-repack-geometric.sh
+++ b/t/t7703-repack-geometric.sh
@@ -541,4 +541,52 @@ test_expect_success 'geometric repack works with promisor packs' '
 	)
 '
 
+test_expect_success 'geometric repack ignores in-flight .tmp-* packs' '
+	git init geometric-tmp &&
+	test_when_finished "rm -fr geometric-tmp" &&
+	(
+		cd geometric-tmp &&
+
+		# Build several packs whose sizes do not already form a
+		# geometric progression, so that a --geometric=2 repack
+		# would roll the smaller ones together.
+		for i in 1 2 3 4 5 6
+		do
+			n=$((i * 3)) &&
+			j=0 &&
+			while test $j -lt $n
+			do
+				echo "obj-$i-$j" | git hash-object -w --stdin &&
+				j=$((j + 1)) || return 1
+			done |
+			git pack-objects --window=0 $packdir/pack \
+				>/dev/null || return 1
+		done &&
+		git prune-packed &&
+
+		# Stage the smallest pack under an in-flight
+		# ".tmp-<pid>-pack-<hash>" name, as a concurrent repack or
+		# pack-aggregate would before renaming it into place.  The
+		# geometric roll-up must not select it as pack-objects input
+		# (it may vanish under us mid-read), and with -d it must not
+		# delete it either.
+		victim=$(ls -S $packdir/pack-*.pack | tail -n 1) &&
+		vb=$(basename "$victim" .pack) &&
+		for e in pack idx rev
+		do
+			from=$packdir/${vb}.$e &&
+			if test -f "$from"
+			then
+				mv "$from" $packdir/.tmp-1234-${vb}.$e ||
+				return 1
+			fi
+		done &&
+
+		git repack --geometric 2 -d &&
+
+		test_path_is_file $packdir/.tmp-1234-${vb}.pack &&
+		test_path_is_file $packdir/.tmp-1234-${vb}.idx
+	)
+'
+
 test_done

From e1c378fc40d2936b4739385901eee02d6db63991 Mon Sep 17 00:00:00 2001
From: Elijah Newren <newren@gmail.com>
Date: Tue, 11 Aug 2026 22:32:31 -0700
Subject: [PATCH 17/18] repack: optionally aggregate while repacking

On a busy server hosting a large repository, `git repack` routinely
takes long enough for thousands of packs and tens of thousands of loose
objects to accumulate before it finishes.  Every subsequent Git
operation pays the price: each pack lookup walks the longer list, and
each loose-object miss has to consult more sources.

Wire `git repack` to optionally drive `git pack-aggregate` as a
background subprocess, controlled by `repack.aggregateLoop` or the
equivalent `--aggregate-loop` and `--no-aggregate-loop` command-line
options.  Keep the behavior disabled by default and independent of the
one-shot aggregation pass.

Have the main pack-objects write its input snapshots to a temporary
directory under `objects/`.  Once both files exist, launch aggregation
with those exclusion lists.  Protect new repack outputs with temporary
`.keep` files before their indexes become visible.

The aggregator already skips packs in the current MIDX.  The exclusions
and temporary markers also protect every pack in the replacement MIDX's
explicit include list, so aggregation cannot retire a pack the repack is
about to reference.

Keep the aggregator running through cruft packing, pack installation,
and the MIDX write.  Stop it before redundant-pack cleanup, then remove
only the `.keep` files this repack created.  The aggregator detects an
unexpected repack exit through a parent pipe.  Mark unrelated pipe ends
close-on-exec so inherited writers cannot suppress EOF and leave either
child waiting.

`git repack` itself takes no locks, and neither does the aggregator we
spawn; serialization across maintenance runs is the caller's
responsibility (typically `git gc` or a server-side maintenance driver).
This matches the prior behavior of `git repack`.

Assisted-by: Claude Opus 4.7 & GPT-5.6 Sol
Signed-off-by: Elijah Newren <newren@gmail.com>
---
 Documentation/config/repack.adoc      |  10 +
 Documentation/git-pack-aggregate.adoc |  29 ++-
 Documentation/git-repack.adoc         |  13 +-
 builtin/repack.c                      | 359 +++++++++++++++++++++++++-
 t/t5336-pack-aggregate.sh             | 176 ++++++++++++-
 5 files changed, 575 insertions(+), 12 deletions(-)

diff --git a/Documentation/config/repack.adoc b/Documentation/config/repack.adoc
index ab13d6b94c699e..d56957bd9642a2 100644
--- a/Documentation/config/repack.adoc
+++ b/Documentation/config/repack.adoc
@@ -72,3 +72,13 @@ repack.aggregateOnce::
 	number of files before the more thorough repack begins.
 	Defaults to false. Can be overridden on the command line with
 	`--aggregate-once` or `--no-aggregate-once`.
+
+repack.aggregateLoop::
+	If set to true, linkgit:git-repack[1] will spawn a background
+	linkgit:git-pack-aggregate[1] while repacking, until redundant-pack
+	cleanup begins. The aggregator rolls up small packs and loose
+	objects that arrive after the main pack-objects process records
+	its input exclusions, preventing them from accumulating in
+	`objects/pack/` and slowing other Git operations on busy servers.
+	Defaults to false. Can be overridden on the command line with
+	`--aggregate-loop` or `--no-aggregate-loop`.
diff --git a/Documentation/git-pack-aggregate.adoc b/Documentation/git-pack-aggregate.adoc
index 0f2070fed86a11..e67b7a2899ec3c 100644
--- a/Documentation/git-pack-aggregate.adoc
+++ b/Documentation/git-pack-aggregate.adoc
@@ -60,15 +60,22 @@ objects or small packs.  With `--loop`, it keeps new material under
 control while a long-running repack is in flight.  Both reduce the
 number of files that unrelated Git operations must scan, while leaving
 a later thorough linkgit:git-repack[1] to optimize deltas and pack
-layout.  The `repack.aggregateOnce` configuration variable (see
-linkgit:git-repack[1]) lets `git repack` request the one-shot cleanup
-before beginning that more expensive work.
+layout.  The `repack.aggregateOnce` and `repack.aggregateLoop`
+configuration variables (see linkgit:git-repack[1]) let `git repack`
+request either behavior independently.
 
 Like linkgit:git-repack[1], `git pack-aggregate` takes no locks of its
 own.  Callers that need serialization must arrange it themselves (for
 example by running under `git gc`).
 Callers can declare "do not touch these inputs" with `--keep-pack`,
 `--exclude-pack-file`, and `--exclude-loose-file`.
+When coordinating with a concurrent repack, protect every pack it may
+read or include in its replacement MIDX.  Exclude existing packs with
+`--exclude-pack-file` and protect new outputs with `.keep` files before
+their indexes become visible.  Keep these protections through the MIDX
+write and until aggregation stops.  `git repack` arranges this itself
+when spawning the aggregator and removes only its own `.keep` files
+afterward.
 
 OPTIONS
 -------
@@ -104,18 +111,28 @@ OPTIONS
 	Read a list of pack basenames (one per line) from `<path>` and
 	never touch any of those packs.  Lines may name a basename with
 	or without a `.pack` or `.idx` suffix; the suffix is stripped.
-	Blank lines and lines beginning with `#` are ignored.
+	Blank lines and lines beginning with `#` are ignored.  When
+	`git pack-aggregate` is spawned by a long-running `git repack`,
+	this file is populated by that `pack-objects` itself via
+	`--emit-input-packs`, and may contain a conservative superset
+	of the packs it will actually consume (such as in `--geometric`
+	mode).
 
 --exclude-loose-file=<path>::
 	Read a list of loose object IDs (one per line) from `<path>`
 	and never pack or unlink any of those loose objects.  Blank
-	lines and lines beginning with `#` are ignored.
+	lines and lines beginning with `#` are ignored.  When `git
+	pack-aggregate` is spawned by a long-running `git repack`, this
+	file is populated by that `pack-objects` itself via
+	`--emit-input-loose`.
 
 --parent-pipe-fd=<n>::
 	An inherited pipe file descriptor whose write end the parent
 	process holds open.  When the parent exits the pipe is closed
 	and `git pack-aggregate` exits at the next cycle boundary,
-	without waiting out the remainder of `--interval`.
+	without waiting out the remainder of `--interval`.  This is an
+	internal plumbing option used by `git repack` to keep its
+	companion aggregator from outliving it.
 
 --max-loose-objects=<n>::
 	Process at most `<n>` loose objects per batch.  All output packs
diff --git a/Documentation/git-repack.adoc b/Documentation/git-repack.adoc
index a87860f3c100cb..15cc0372e06103 100644
--- a/Documentation/git-repack.adoc
+++ b/Documentation/git-repack.adoc
@@ -13,7 +13,7 @@ SYNOPSIS
 	[--window=<n>] [--depth=<n>] [--threads=<n>] [--keep-pack=<pack-name>]
 	[--write-midx[=<mode>]] [--name-hash-version=<n>] [--path-walk]
 	[--filter=<filter-spec>] [--drop-filtered [--dry-run]]
-	[--[no-]aggregate-once]
+	[--[no-]aggregate-once] [--[no-]aggregate-loop]
 
 DESCRIPTION
 -----------
@@ -350,6 +350,16 @@ created for any new pack(s) without disturbing the existing chain.
 	Overrides the `repack.aggregateOnce` configuration variable.
 	Off by default.
 
+--aggregate-loop::
+--no-aggregate-loop::
+	Spawn a background linkgit:git-pack-aggregate[1] while
+	repacking, until redundant-pack cleanup begins. The aggregator
+	rolls up small packs and loose objects that arrive after the main
+	pack-objects process records its input exclusions, preventing them
+	from accumulating in `objects/pack/` and slowing other Git
+	operations on busy servers. Overrides the `repack.aggregateLoop`
+	configuration variable. Off by default.
+
 CONFIGURATION
 -------------
 
@@ -374,6 +384,7 @@ SEE ALSO
 --------
 linkgit:git-pack-objects[1]
 linkgit:git-prune-packed[1]
+linkgit:git-pack-aggregate[1]
 
 GIT
 ---
diff --git a/builtin/repack.c b/builtin/repack.c
index f876501ccea689..06804583f6a90a 100644
--- a/builtin/repack.c
+++ b/builtin/repack.c
@@ -19,6 +19,8 @@
 #include "hex.h"
 #include "wt-status.h"
 #include "read-cache-ll.h"
+#include "wrapper.h"
+#include "dir.h"
 
 #define ALL_INTO_ONE 1
 #define LOOSEN_UNREACHABLE 2
@@ -37,13 +39,14 @@ static int drop_filtered;
 static int dry_run;
 static int write_bitmaps_given;
 static int aggregate_once_opt = -1;
+static int aggregate_loop_opt = -1;
 
 static const char *const git_repack_usage[] = {
 	N_("git repack [-a] [-A] [-d] [-f] [-F] [-l] [-n] [-q] [-b] [-m]\n"
 	   "[--window=<n>] [--depth=<n>] [--threads=<n>] [--keep-pack=<pack-name>]\n"
 	   "[--write-midx[=<mode>]] [--name-hash-version=<n>] [--path-walk]\n"
 	   "[--filter=<filter-spec>] [--drop-filtered [--dry-run]]\n"
-	   "[--[no-]aggregate-once]"),
+	   "[--[no-]aggregate-once] [--[no-]aggregate-loop]"),
 	NULL
 };
 
@@ -123,6 +126,10 @@ static int repack_config(const char *var, const char *value,
 		aggregate_once_opt = git_config_bool(var, value);
 		return 0;
 	}
+	if (!strcmp(var, "repack.aggregateloop")) {
+		aggregate_loop_opt = git_config_bool(var, value);
+		return 0;
+	}
 	return git_default_config(var, value, ctx, cb);
 }
 
@@ -161,6 +168,192 @@ static int option_parse_write_midx(const struct option *opt, const char *arg,
 	return 0;
 }
 
+struct pack_aggregate_process {
+	struct child_process cmd;
+	char *tmpdir;
+	char *exclude_packs_path;
+	char *exclude_loose_path;
+	/* Full paths of the ".keep" markers created by this repack. */
+	struct string_list installed_keeps;
+	/* The aggregator stops on EOF if we exit unexpectedly. */
+	int parent_pipe_write_fd;
+	int started;
+};
+#define AGGREGATE_KEEP_MARKER_PREFIX "git-repack-aggregate-temporary"
+
+/*
+ * Scan packdir for stale ".keep" markers left behind by previous
+ * crashed repacks: files whose contents begin with our marker
+ * prefix and whose owning pid is no longer running.  Skip anything
+ * we cannot parse (foreign ".keep" files) or whose owner is alive.
+ */
+static void clean_stale_aggregate_keeps(const char *packdir)
+{
+	DIR *dir = opendir(packdir);
+	struct dirent *ent;
+	struct strbuf path = STRBUF_INIT;
+
+	if (!dir)
+		return;
+
+	while ((ent = readdir(dir))) {
+		const char *p;
+		char *end;
+		long pid;
+		int fd;
+		ssize_t n;
+		char buf[256];
+
+		if (!ends_with(ent->d_name, ".keep"))
+			continue;
+
+		strbuf_reset(&path);
+		strbuf_addf(&path, "%s/%s", packdir, ent->d_name);
+
+		fd = open(path.buf, O_RDONLY);
+		if (fd < 0)
+			continue;
+		n = read_in_full(fd, buf, sizeof(buf) - 1);
+		close(fd);
+		if (n <= 0)
+			continue;
+		buf[n] = '\0';
+
+		if (!skip_prefix(buf, AGGREGATE_KEEP_MARKER_PREFIX " pid=", &p))
+			continue;
+		errno = 0;
+		pid = strtol(p, &end, 10);
+		if (errno || end == p || pid <= 0)
+			continue;
+		if (*end != '\n' && *end != '\0')
+			continue;
+
+		/* Send no signal; just check existence of process */
+		if (!kill((pid_t)pid, 0))
+			continue;
+		if (errno != ESRCH)
+			continue;
+
+		if (unlink(path.buf) && errno != ENOENT)
+			warning_errno(_("could not unlink stale "
+					"aggregate .keep marker '%s'"),
+				      path.buf);
+	}
+
+	closedir(dir);
+	strbuf_release(&path);
+}
+
+/*
+ * Protect new packs before generated_pack_install() exposes their indexes.
+ * Leave pre-existing ".keep" files untouched; record only markers we create
+ * so cleanup cannot remove someone else's protection.
+ */
+static void install_aggregate_keep_markers(struct pack_aggregate_process *agg,
+					   const char *packdir,
+					   const struct string_list *names)
+{
+	struct strbuf path = STRBUF_INIT;
+	struct strbuf content = STRBUF_INIT;
+	size_t i;
+
+	strbuf_addf(&content, "%s pid=%ld\n",
+		    AGGREGATE_KEEP_MARKER_PREFIX, (long)getpid());
+
+	for (i = 0; i < names->nr; i++) {
+		int fd;
+
+		strbuf_reset(&path);
+		strbuf_addf(&path, "%s/pack-%s.keep", packdir,
+			    names->items[i].string);
+
+		fd = open(path.buf, O_WRONLY | O_CREAT | O_EXCL, 0666);
+		if (fd < 0) {
+			if (errno == EEXIST)
+				continue;
+			die_errno(_("could not create aggregate "
+				    ".keep marker '%s'"), path.buf);
+		}
+		if (write_in_full(fd, content.buf, content.len) < 0)
+			die_errno(_("could not write aggregate "
+				    ".keep marker '%s'"), path.buf);
+		close(fd);
+		string_list_append(&agg->installed_keeps, path.buf);
+	}
+
+	strbuf_release(&path);
+	strbuf_release(&content);
+}
+
+/* Only remove our markers after the aggregator has been reaped. */
+static void remove_aggregate_keep_markers(struct pack_aggregate_process *agg)
+{
+	size_t i;
+
+	for (i = 0; i < agg->installed_keeps.nr; i++) {
+		const char *p = agg->installed_keeps.items[i].string;
+		if (unlink(p) && errno != ENOENT)
+			warning_errno(_("could not unlink aggregate "
+					".keep marker '%s'"), p);
+	}
+	string_list_clear(&agg->installed_keeps, 0);
+}
+
+static int wait_for_emit_files(const char *packs_path,
+			       const char *loose_path,
+			       int pack_objects_out_fd)
+{
+	struct stat st;
+	int waited_ms = 0;
+	int sleep_ms = 20;
+	const int max_wait_ms = 60000;
+	struct pollfd pfd;
+
+	/*
+	 * Detect early exit via stdout hang-up; POLLHUP is reported even
+	 * with events == 0.  The files are emitted after preparing packing
+	 * data, before object enumeration or stdout output.
+	 * Leave reaping to finish_pack_objects_cmd().
+	 */
+	pfd.fd = pack_objects_out_fd;
+	pfd.events = 0;
+
+	while (waited_ms < max_wait_ms) {
+		int ok_packs = (stat(packs_path, &st) == 0);
+		int ok_loose = (stat(loose_path, &st) == 0);
+		int ret;
+		if (ok_packs && ok_loose)
+			return 0;
+		pfd.revents = 0;
+		ret = poll(&pfd, 1, sleep_ms);
+		if (ret < 0 && errno != EINTR)
+			return error_errno(_("poll on pack-objects "
+					     "pipe failed"));
+		if (ret > 0 &&
+		    (pfd.revents & (POLLHUP | POLLERR | POLLNVAL)))
+			return error(_("pack-objects exited before "
+				       "emitting exclude files"));
+		waited_ms += sleep_ms;
+		if (sleep_ms < 200)
+			sleep_ms *= 2;
+	}
+	return error(_("timed out waiting for pack-objects to write "
+		       "exclude files"));
+}
+
+static int set_cloexec_or_error(int fd, const char *description)
+{
+	int flags = fcntl(fd, F_GETFD);
+
+	if (flags < 0)
+		return error_errno(_("could not read descriptor flags for %s"),
+				   description);
+	if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) < 0)
+		return error_errno(_("could not mark %s close-on-exec"),
+				   description);
+	return 0;
+}
+
 static int run_pack_aggregate_once(const struct string_list *keep_pack_list)
 {
 	struct child_process cmd = CHILD_PROCESS_INIT;
@@ -176,12 +369,133 @@ static int run_pack_aggregate_once(const struct string_list *keep_pack_list)
 	return 0;
 }
 
+static int start_pack_aggregate(struct pack_aggregate_process *agg,
+				int pack_objects_out_fd)
+{
+	int pp[2];
+
+	if (wait_for_emit_files(agg->exclude_packs_path,
+				agg->exclude_loose_path,
+				pack_objects_out_fd))
+		return -1;
+
+	/*
+	 * Only the parent may hold the write end, or the aggregator
+	 * would not see EOF when we exit.
+	 */
+	if (pipe(pp))
+		return error_errno(_("could not create aggregate "
+				     "parent pipe"));
+	if (set_cloexec_or_error(pp[1],
+				 _("aggregate parent-pipe write end"))) {
+		close(pp[0]);
+		close(pp[1]);
+		return -1;
+	}
+
+	strvec_pushl(&agg->cmd.args, "pack-aggregate", "--loop", NULL);
+	strvec_pushf(&agg->cmd.args, "--exclude-pack-file=%s",
+		     agg->exclude_packs_path);
+	strvec_pushf(&agg->cmd.args, "--exclude-loose-file=%s",
+		     agg->exclude_loose_path);
+	strvec_pushf(&agg->cmd.args, "--parent-pipe-fd=%d", pp[0]);
+	agg->cmd.git_cmd = 1;
+	if (start_command(&agg->cmd)) {
+		close(pp[0]);
+		close(pp[1]);
+		return error(_("could not start git pack-aggregate"));
+	}
+	close(pp[0]);
+	agg->parent_pipe_write_fd = pp[1];
+	agg->started = 1;
+	return 0;
+}
+
+static void stop_pack_aggregate(struct pack_aggregate_process *agg)
+{
+	/* Wake the aggregator if it is polling between cycles. */
+	if (agg->parent_pipe_write_fd >= 0) {
+		close(agg->parent_pipe_write_fd);
+		agg->parent_pipe_write_fd = -1;
+	}
+	if (agg->started) {
+		agg->started = 0;
+		if (agg->cmd.pid > 0) {
+			pid_t pid = agg->cmd.pid;
+			int waited_ms = 0;
+			int status;
+			pid_t r;
+
+			kill(pid, SIGTERM);
+			/*
+			 * Wait briefly for graceful exit before reaping;
+			 * pack-aggregate is expected to finish quite quickly,
+			 * so a few seconds should be plenty.
+			 */
+			while (waited_ms < 5000) {
+				r = waitpid(pid, &status, WNOHANG);
+				if (r == pid || (r < 0 && errno != EINTR))
+					break;
+				sleep_millisec(50);
+				waited_ms += 50;
+			}
+			if (r != pid) {
+				kill(pid, SIGKILL);
+				while (waitpid(pid, &status, 0) < 0 &&
+				       errno == EINTR)
+					; /* nothing */
+			}
+			agg->cmd.pid = -1;
+			child_process_clear(&agg->cmd);
+		}
+	}
+	if (agg->tmpdir) {
+		struct strbuf path = STRBUF_INIT;
+		strbuf_addstr(&path, agg->tmpdir);
+		remove_dir_recursively(&path, 0);
+		strbuf_release(&path);
+		FREE_AND_NULL(agg->tmpdir);
+	}
+	FREE_AND_NULL(agg->exclude_packs_path);
+	FREE_AND_NULL(agg->exclude_loose_path);
+
+	remove_aggregate_keep_markers(agg);
+}
+
+static int init_pack_aggregate(struct repository *repo,
+			       struct pack_aggregate_process *agg)
+{
+	struct strbuf tmpl = STRBUF_INIT;
+	char *pdir;
+
+	pdir = mkpathdup("%s/pack", repo_get_object_directory(repo));
+	clean_stale_aggregate_keeps(pdir);
+	free(pdir);
+
+	strbuf_addf(&tmpl, "%s/pack-aggregate.XXXXXX",
+		    repo_get_object_directory(repo));
+	if (!mkdtemp(tmpl.buf)) {
+		error_errno(_("could not create pack-aggregate tempdir"));
+		strbuf_release(&tmpl);
+		return -1;
+	}
+	agg->tmpdir = strbuf_detach(&tmpl, NULL);
+	agg->exclude_packs_path = xstrfmt("%s/packs", agg->tmpdir);
+	agg->exclude_loose_path = xstrfmt("%s/loose", agg->tmpdir);
+	return 0;
+}
+
 int cmd_repack(int argc,
 	       const char **argv,
 	       const char *prefix,
 	       struct repository *repo)
 {
 	struct child_process cmd = CHILD_PROCESS_INIT;
+	struct pack_aggregate_process aggregate = {
+		.cmd = CHILD_PROCESS_INIT,
+		.installed_keeps = STRING_LIST_INIT_DUP,
+		.parent_pipe_write_fd = -1,
+	};
 	struct string_list_item *item;
 	struct string_list names = STRING_LIST_INIT_DUP;
 	struct existing_packs existing = EXISTING_PACKS_INIT;
@@ -284,6 +598,8 @@ int cmd_repack(int argc,
 				N_("only show which objects would be dropped")),
 		OPT_BOOL(0, "aggregate-once", &aggregate_once_opt,
 			 N_("run pack-aggregate once before repacking")),
+		OPT_BOOL(0, "aggregate-loop", &aggregate_loop_opt,
+			 N_("run pack-aggregate in the background while repacking")),
 		OPT_END()
 	};
 
@@ -507,6 +823,18 @@ int cmd_repack(int argc,
 
 	show_progress = !po_args.quiet && isatty(2);
 
+	if (aggregate_loop_opt > 0) {
+		if (init_pack_aggregate(repo, &aggregate)) {
+			/* fall through: error already reported */
+			aggregate_loop_opt = 0;
+		} else {
+			strvec_pushf(&cmd.args, "--emit-input-packs=%s",
+				     aggregate.exclude_packs_path);
+			strvec_pushf(&cmd.args, "--emit-input-loose=%s",
+				     aggregate.exclude_loose_path);
+		}
+	}
+
 	strvec_push(&cmd.args, "--keep-true-parents");
 	for (i = 0; i < keep_pack_list.nr; i++)
 		strvec_pushf(&cmd.args, "--keep-pack=%s",
@@ -591,6 +919,26 @@ int cmd_repack(int argc,
 	if (ret)
 		goto cleanup;
 
+	/*
+	 * Do not let the aggregator inherit our pack-objects pipes:
+	 * holding cmd.in open would prevent EOF in --geometric mode.
+	 * Only positive fds are ours; cmd.in == 0 is the child-process
+	 * default in the no_stdin case, not a pipe we own.
+	 */
+	if (aggregate_loop_opt > 0) {
+		if ((cmd.in > 0 &&
+		     set_cloexec_or_error(cmd.in,
+					  _("main pack-objects input"))) ||
+		    (cmd.out > 0 &&
+		     set_cloexec_or_error(cmd.out,
+					  _("main pack-objects output")))) {
+			/* Keep the emit-file paths until pack-objects exits. */
+			aggregate_loop_opt = 0;
+		} else if (start_pack_aggregate(&aggregate, cmd.out)) {
+			aggregate_loop_opt = 0;
+		}
+	}
+
 	if (geometry.split_factor) {
 		FILE *in = xfdopen(cmd.in, "w");
 		/*
@@ -740,6 +1088,8 @@ int cmd_repack(int argc,
 	string_list_sort(&names);
 
 	odb_close(repo->objects);
+	if (aggregate.started)
+		install_aggregate_keep_markers(&aggregate, packdir, &names);
 
 	/*
 	 * Ok we have prepared all new packfiles.
@@ -775,6 +1125,12 @@ int cmd_repack(int argc,
 			goto cleanup;
 	}
 
+	/*
+	 * Stop aggregation before refreshing the object store or deleting
+	 * redundant packs and objects, which could race with it.
+	 */
+	stop_pack_aggregate(&aggregate);
+
 	odb_reprepare(repo->objects);
 
 	if (delete_redundant) {
@@ -812,6 +1168,7 @@ int cmd_repack(int argc,
 	}
 
 cleanup:
+	stop_pack_aggregate(&aggregate);
 	string_list_clear(&keep_pack_list, 0);
 	string_list_clear(&names, 1);
 	oidset_clear(&drop_oids);
diff --git a/t/t5336-pack-aggregate.sh b/t/t5336-pack-aggregate.sh
index b43b0b496338cc..f1a4a1f4efbce5 100755
--- a/t/t5336-pack-aggregate.sh
+++ b/t/t5336-pack-aggregate.sh
@@ -897,6 +897,7 @@ test_expect_success 'repack --aggregate-once runs pack-aggregate once' '
 		GIT_TRACE2_EVENT="$(pwd)/trace.txt" \
 			git repack -d --geometric=2 --aggregate-once &&
 		test_grep "\"argv\":.*\"pack-aggregate\",\"--once\"" trace.txt &&
+		test_grep ! "\"argv\":.*\"pack-aggregate\",\"--loop\"" trace.txt &&
 		git fsck
 	)
 '
@@ -958,7 +959,36 @@ test_expect_success 'repack --aggregate-once handles an existing MIDX' '
 	)
 '
 
-test_expect_success 'repack aggregation config enables once mode' '
+test_expect_success 'repack --aggregate-loop spawns and reaps pack-aggregate' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		build_n_packs 5 >/dev/null &&
+		GIT_TRACE2_EVENT="$(pwd)/trace.txt" \
+			git repack -d --geometric=2 --aggregate-loop &&
+		test_grep "\"argv\":.*\"pack-aggregate\",\"--loop\"" trace.txt &&
+		# Tempdir should be cleaned up.
+		test -z "$(ls .git/objects | grep pack-aggregate)" &&
+		git fsck
+	)
+'
+
+test_expect_success 'repack can enable both aggregation modes' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		build_n_packs 3 >/dev/null &&
+		GIT_TRACE2_EVENT="$(pwd)/trace.txt" \
+			git repack -d --geometric=2 \
+				--aggregate-once --aggregate-loop &&
+		test_grep "\"argv\":.*\"pack-aggregate\",\"--once\"" trace.txt &&
+		test_grep "\"argv\":.*\"pack-aggregate\",\"--loop\"" trace.txt
+	)
+'
+
+test_expect_success 'repack aggregation config enables both modes' '
 	test_when_finished "rm -fr work" &&
 	cp -R repo work &&
 	(
@@ -966,12 +996,14 @@ test_expect_success 'repack aggregation config enables once mode' '
 		build_n_packs 3 >/dev/null &&
 		GIT_TRACE2_EVENT="$(pwd)/trace.txt" \
 			git -c repack.aggregateOnce=true \
+			-c repack.aggregateLoop=true \
 			repack -d --geometric=2 &&
-		test_grep "\"argv\":.*\"pack-aggregate\",\"--once\"" trace.txt
+		test_grep "\"argv\":.*\"pack-aggregate\",\"--once\"" trace.txt &&
+		test_grep "\"argv\":.*\"pack-aggregate\",\"--loop\"" trace.txt
 	)
 '
 
-test_expect_success 'CLI can disable configured once aggregation' '
+test_expect_success 'CLI can disable configured aggregation modes' '
 	test_when_finished "rm -fr work" &&
 	cp -R repo work &&
 	(
@@ -979,11 +1011,147 @@ test_expect_success 'CLI can disable configured once aggregation' '
 		build_n_packs 3 >/dev/null &&
 		GIT_TRACE2_EVENT="$(pwd)/trace.txt" \
 			git -c repack.aggregateOnce=true \
-			repack -d --geometric=2 --no-aggregate-once &&
+			-c repack.aggregateLoop=true \
+			repack -d --geometric=2 \
+				--no-aggregate-once --no-aggregate-loop &&
 		test_grep ! "\"pack-aggregate\"" trace.txt
 	)
 '
 
+# ---- pack-aggregate lifecycle / .keep marker coverage ----
+
+test_expect_success PERL 'pack-aggregate survives through MIDX bitmap write' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		test_commit base &&
+		build_n_packs 5 >/dev/null &&
+		GIT_TRACE2_EVENT="$(pwd)/trace.txt" \
+			git repack -d --geometric=2 --aggregate-loop \
+				--write-midx --write-bitmap-index &&
+		test_path_is_file \
+			.git/objects/pack/multi-pack-index-*.bitmap &&
+		git rev-list --test-bitmap HEAD &&
+		# Match child start and exit events by session ID.
+		# Direct waitpid() teardown omits the child_exit event in the
+		# parent trace, so compare the child exit events.
+		perl -ne '\''
+			my ($sid)  = /"sid":"([^"]+)"/ or next;
+			my ($time) = /"time":"([^"]+)"/;
+			if (/"event":"start"/) {
+				# Match the subcommand, not a path containing
+				# pack-aggregate.
+				my ($argv) = /"argv":\["[^"]*","([^"]+)"/;
+				if (defined($argv) && $argv eq "multi-pack-index") {
+					$kind{$sid} = "midx";
+				} elsif (defined($argv) && $argv eq "pack-aggregate") {
+					$kind{$sid} = "agg";
+				}
+			} elsif (/"event":"exit"/ && $kind{$sid}) {
+				$exit{$kind{$sid}} //= $time;
+			}
+			END {
+				die "missing midx exit\n" unless $exit{midx};
+				die "missing agg exit\n"  unless $exit{agg};
+				die "ordering wrong: agg=$exit{agg} midx=$exit{midx}\n"
+					unless $exit{agg} gt $exit{midx};
+			}
+		'\'' trace.txt
+	)
+'
+
+test_expect_success '--aggregate-loop preserves pre-existing user .keep files' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		build_n_packs 5 >packs.txt &&
+		first=$(head -n 1 packs.txt) &&
+		# A user-created .keep with no marker content must
+		# survive a repack --aggregate-loop untouched.
+		echo "I am a user keep file" >expect &&
+		cp expect .git/objects/pack/${first}.keep &&
+		git repack -d --geometric=2 --aggregate-loop &&
+		test_path_is_file .git/objects/pack/${first}.keep &&
+		test_path_is_file .git/objects/pack/${first}.pack &&
+		test_cmp expect .git/objects/pack/${first}.keep
+	)
+'
+
+test_expect_success '--aggregate-loop cleans up its own .keep markers' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		build_n_packs 5 >/dev/null &&
+		git repack -d --geometric=2 --aggregate-loop &&
+		# No marker .keep files should remain.  Any .keep that
+		# survives must NOT carry our marker prefix.
+		for f in .git/objects/pack/*.keep
+		do
+			test -e "$f" || continue
+			test_grep ! "^git-repack-aggregate-temporary " "$f" \
+				|| return 1
+		done
+	)
+'
+
+test_expect_success 'startup cleans up stale .keep markers from dead pids' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	(
+		cd work &&
+		build_n_packs 3 >packs.txt &&
+		# Spawn a short-lived subshell that writes its own pid
+		# to a file, then exits.  That pid is guaranteed dead
+		# by the time we read it.
+		sh -c "echo \$\$" >dead_pid.txt &&
+		dead_pid=$(cat dead_pid.txt) &&
+		test -n "$dead_pid" &&
+		first=$(head -n 1 packs.txt) &&
+		stale=.git/objects/pack/${first}.keep &&
+		printf "git-repack-aggregate-temporary pid=%d\n" \
+			"$dead_pid" >"$stale" &&
+		test_path_is_file "$stale" &&
+		git repack -d --geometric=2 --aggregate-loop &&
+		# The stale marker should have been cleaned at startup;
+		# even if its pack was preserved by geometric repack,
+		# the .keep should not still carry the dead-pid marker.
+		if test -e "$stale"
+		then
+			test_grep ! "^git-repack-aggregate-temporary " \
+				"$stale"
+		fi
+	)
+'
+
+test_expect_success !MINGW 'startup leaves live-pid .keep markers alone' '
+	test_when_finished "rm -fr work" &&
+	cp -R repo work &&
+	# Use the test-runner shell pid, which is reliably alive
+	# for the duration of this test.  PID 1 (init) would also
+	# work since our code treats EPERM as "alive".
+	#
+	# !MINGW: on Windows, bash $$ is a virtualized MSYS pid that
+	# does not correspond to a process kill(pid, 0) can see, so
+	# our liveness check would treat it as dead and the marker
+	# would be removed.  Skip this test there.
+	live_pid=$$ &&
+	(
+		cd work &&
+		build_n_packs 3 >packs.txt &&
+		first=$(head -n 1 packs.txt) &&
+		live=.git/objects/pack/${first}.keep &&
+		printf "git-repack-aggregate-temporary pid=%d\n" \
+			"$live_pid" >"$live" &&
+		test_path_is_file "$live" &&
+		git repack -d --geometric=2 --aggregate-loop &&
+		test_path_is_file "$live" &&
+		test_grep "pid=${live_pid}" "$live"
+	)
+'
+
 test_expect_success 'pack-aggregate ignores in-flight .tmp-* packs' '
 	test_when_finished "rm -fr work" &&
 	cp -R repo work &&

From 1d72451674f64c199b4118336203f21b1b45ca0e Mon Sep 17 00:00:00 2001
From: Elijah Newren <newren@gmail.com>
Date: Wed, 12 Aug 2026 09:49:58 -0700
Subject: [PATCH 18/18] repack, pack-aggregate: trace pack cleanup cycles

A pack-aggregate cycle that finds nothing to do leaves no on-disk
artifact, so process lifetime and repository state are insufficient to
count cleanup cycles.

Add trace2 regions around each pack-aggregate cycle and repack's
redundant-pack removal so trace consumers can account for these
operations, including no-op aggregation cycles.

Signed-off-by: Elijah Newren <newren@gmail.com>
---
 builtin/pack-aggregate.c | 6 ++++++
 builtin/repack.c         | 3 +++
 2 files changed, 9 insertions(+)

diff --git a/builtin/pack-aggregate.c b/builtin/pack-aggregate.c
index 1ee9c4f324c01f..bd074160b40872 100644
--- a/builtin/pack-aggregate.c
+++ b/builtin/pack-aggregate.c
@@ -21,6 +21,7 @@
 #include "strmap.h"
 #include "strvec.h"
 #include "tempfile.h"
+#include "trace2.h"
 #include "wrapper.h"
 
 static const char *const pack_aggregate_usage[] = {
@@ -699,6 +700,7 @@ int cmd_pack_aggregate(int argc, const char **argv,
 	struct string_list keep_pack_list = STRING_LIST_INIT_NODUP;
 	int once = 0;
 	int loop = 0;
+	uintmax_t cycle_count = 0;
 	struct option options[] = {
 		OPT_BOOL(0, "once", &once,
 			 N_("run a single cycle and exit")),
@@ -814,11 +816,15 @@ int cmd_pack_aggregate(int argc, const char **argv,
 	do {
 		if (stop_signaled)
 			break;
+		trace2_region_enter("pack-aggregate", "cycle", repo);
 		ret = do_one_cycle(repo, packdir, &keep_pack_list,
 				   &pack_exclude, &loose_exclude, &midx_exclude,
 				   min_loose, min_packs,
 				   max_loose_objects, max_objects,
 				   max_packs, max_input_pack_size);
+		trace2_data_intmax("pack-aggregate", repo, "cycle-num",
+				   ++cycle_count);
+		trace2_region_leave("pack-aggregate", "cycle", repo);
 		if (ret || once || stop_signaled)
 			break;
 		interruptible_sleep((unsigned int)interval);
diff --git a/builtin/repack.c b/builtin/repack.c
index 06804583f6a90a..07f2d890101727 100644
--- a/builtin/repack.c
+++ b/builtin/repack.c
@@ -21,6 +21,7 @@
 #include "read-cache-ll.h"
 #include "wrapper.h"
 #include "dir.h"
+#include "trace2.h"
 
 #define ALL_INTO_ONE 1
 #define LOOSEN_UNREACHABLE 2
@@ -1137,6 +1138,7 @@ int cmd_repack(int argc,
 		int opts = 0;
 		bool wrote_incremental_midx = write_midx == REPACK_WRITE_MIDX_INCREMENTAL;
 
+		trace2_region_enter("repack", "pack-cleanup", repo);
 		existing_packs_remove_redundant(&existing, packdir,
 						wrote_incremental_midx);
 
@@ -1144,6 +1146,7 @@ int cmd_repack(int argc,
 			pack_geometry_remove_redundant(&geometry, &names,
 						       &existing, packdir,
 						       wrote_incremental_midx);
+		trace2_region_leave("repack", "pack-cleanup", repo);
 		if (show_progress)
 			opts |= PRUNE_PACKED_VERBOSE;
 		prune_packed_objects(opts);