Hi Harald

On 09/06/2026 11:11, Harald Nordgren via GitGitGadget wrote:
> From: Harald Nordgren <haraldnordgren@gmail.com>
> > Setting branch.<name>.pruneMerged=false exempts that branch from
> "git branch --prune-merged", which is useful for a topic you want
> to keep developing after an early round of it has been merged
> upstream. Unless --quiet is given, each skip is reported so the
> user knows why their topic was kept.

Sounds good

> @@ -755,6 +757,18 @@ static int prune_merged_branches(int argc, const char **argv,
>   		if (!push || !strcmp(push, upstream))
>   			continue;
>   > +		strbuf_addf(&key, "branch.%s.prunemerged", short_name);
> +		if (!repo_config_get_bool(the_repository, key.buf, &opt_out) &&
> +		    !opt_out) {
> +			if (!quiet)
> +				fprintf(stderr,
> +					_("Skipping '%s' (branch.%s.pruneMerged is false)\n"),
> +					short_name, short_name);
> +			strbuf_release(&key);
> +			continue;
> +		}
> +		strbuf_release(&key);

As this is in a loop we don't want to free the buffer on each iteration, only at the end. You should call strbuf_reset() just before strbuf_addf() above and then move this call to strbuf_release() out of the loop.

> +test_expect_success '--prune-merged honours branch.<name>.pruneMerged=false' '
> +	test_when_finished "rm -rf pm-optout" &&
> +	git clone pm-upstream pm-optout &&
> +	git -C pm-optout remote add fork ../pm-fork &&
> +	test_config -C pm-optout remote.pushDefault fork &&
> +	test_config -C pm-optout push.default current &&
> +	git -C pm-optout branch one one-commit &&
> +	git -C pm-optout branch --set-upstream-to=origin/next one &&
> +	git -C pm-optout branch two two-commit &&
> +	git -C pm-optout branch --set-upstream-to=origin/next two &&
> +	test_config -C pm-optout branch.one.pruneMerged false &&
> +
> +	git -C pm-optout branch --prune-merged "origin/*" 2>err &&
> +
> +	git -C pm-optout rev-parse --verify refs/heads/one &&
> +	test_must_fail git -C pm-optout rev-parse --verify refs/heads/two &&
> +	test_grep "Skipping .one." err

Do we really need a whole new setup to test this - can't we just add a protected branch to an existing test?

Thanks

Phillip

> +
> +test_expect_success 'branch -d still deletes a pruneMerged=false branch' '
> +	test_when_finished "rm -rf pm-optout-d" &&
> +	git clone pm-upstream pm-optout-d &&
> +	git -C pm-optout-d branch one one-commit &&
> +	git -C pm-optout-d branch --set-upstream-to=origin/next one &&
> +	test_config -C pm-optout-d branch.one.pruneMerged false &&
> +
> +	git -C pm-optout-d branch -d one &&
> +	test_must_fail git -C pm-optout-d rev-parse --verify refs/heads/one
> +'
> +
>   test_done

Hi Harald

On 09/06/2026 11:11, Harald Nordgren via GitGitGadget wrote:
> From: Harald Nordgren <haraldnordgren@gmail.com>
> > Add a --forked option to "git branch" list mode that lists only
> branches whose configured upstream matches <branch>. The argument
> can be a ref (e.g. "origin/main", "master") or a shell glob
> (e.g. "origin/*"), and may be repeated to widen the filter.
> > It is an ordinary list filter, so it combines with the others:
> >      git branch --merged origin/main --forked 'origin/*'
> > lists branches forked from origin that are already merged into
> origin/main, and --no-merged inverts the question.
> > This is the building block for --prune-merged, which deletes the
> listed branches once they have landed on their upstream.
> > Signed-off-by: Harald Nordgren <haraldnordgren@gmail.com>
> ---
>   Documentation/git-branch.adoc | 10 +++-
>   builtin/branch.c              | 18 ++++++-
>   ref-filter.c                  | 70 ++++++++++++++++++++++++++
>   ref-filter.h                  | 10 ++++
>   t/t3200-branch.sh             | 92 +++++++++++++++++++++++++++++++++++
>   5 files changed, 197 insertions(+), 3 deletions(-)

It's nice to see that moving the code into the ref-filter.c has reduced the overall number of additions by ~50 lines. The documentation and implementation look fine though I have a couple of thoughts:

 - Previous iterations supported "origin" as a short hand for the branch
   origin/HEAD points to. That was nice because it means we can use the
   same syntax for "git checkout -b" and "git branch --forked". It
   would probably be a good idea to support it.

 - We could probably be a bit smarter about the way we handle patterns
   by copying what dwim_ref() does to support things like
   remotes/origin/* but I don't think we need to do that now.

> diff --git a/t/t3200-branch.sh b/t/t3200-branch.sh
> index e7829c2c4b..4e7deddc04 100755
> --- a/t/t3200-branch.sh
> +++ b/t/t3200-branch.sh
> @@ -1717,4 +1717,96 @@ test_expect_success 'errors if given a bad branch name' '
>   	test_cmp expect actual
>   '
>   > +test_expect_success '--forked: setup' '
> +	test_create_repo forked-upstream &&
> +	test_commit -C forked-upstream base &&
> +	git -C forked-upstream branch one base &&
> +	git -C forked-upstream branch two base &&
> +
> +	test_create_repo forked-other &&
> +	test_commit -C forked-other other-base &&
> +	git -C forked-other branch foreign other-base &&
> +
> +	git clone forked-upstream forked &&
> +	git -C forked remote add other ../forked-other &&

We can use "add -f" to fetch here rather than doing it separately.

> +	git -C forked fetch other &&
> +	git -C forked branch local-base &&
> +	git -C forked branch --track local-one origin/one &&
> +	git -C forked branch --track local-two origin/two &&
> +	git -C forked branch --track local-foreign other/foreign &&
> +	git -C forked branch detached &&

Normally we use "detached" to mean no branch, lets read on and see how this is used ...

> +	git -C forked branch --track local-trunk local-base
> +'
> +
> +test_expect_success '--forked <upstream-tracking-branch> filters by upstream' '
> +	git -C forked branch --forked origin/one --format="%(refname:short)" >actual &&

origin/one and origin/two point to the same commit, so this demonstrates that we're checking the branch names, not the topology which is good. All of the local branches point at their upstream which isn't very realistic - I wonder if we should add some local commits?

The tests all look sensible, but there is no coverage for combining --forked with branch names as in

    git branch --forked <arg> <branch>

Thanks

Phillip


> +	echo local-one >expect &&
> +	test_cmp expect actual
> +'
> +
> +test_expect_success '--forked <glob> filters by wildmatch' '
> +	git -C forked branch --forked "origin/*" --format="%(refname:short)" >actual &&
> +	cat >expect <<-\EOF &&
> +	local-one
> +	local-two
> +	main
> +	EOF
> +	test_cmp expect actual
> +'
> +
> +test_expect_success '--forked <local-branch> matches branches with local upstream' '
> +	git -C forked branch --forked local-base --format="%(refname:short)" >actual &&
> +	echo local-trunk >expect &&
> +	test_cmp expect actual
> +'
> +
> +test_expect_success '--forked can be repeated to widen the filter' '
> +	git -C forked branch --forked origin/one --forked other/foreign --format="%(refname:short)" >actual &&
> +	cat >expect <<-\EOF &&
> +	local-foreign
> +	local-one
> +	EOF
> +	test_cmp expect actual
> +'
> +
> +test_expect_success '--forked combines literal and glob arguments' '
> +	git -C forked branch --forked local-base --forked "other/*" --format="%(refname:short)" >actual &&
> +	cat >expect <<-\EOF &&
> +	local-foreign
> +	local-trunk
> +	EOF
> +	test_cmp expect actual
> +'
> +
> +test_expect_success '--forked "*/*" covers every remote-tracking upstream' '
> +	git -C forked branch --forked "*/*" --format="%(refname:short)" >actual &&
> +	cat >expect <<-\EOF &&
> +	local-foreign
> +	local-one
> +	local-two
> +	main
> +	EOF
> +	test_cmp expect actual
> +'
> +
> +test_expect_success '--forked composes with --no-merged' '
> +	test_when_finished "git -C forked checkout detached" &&
> +	git -C forked checkout local-one &&
> +	test_commit -C forked local-only &&
> +	git -C forked branch --forked "origin/*" --no-merged origin/one \
> +		--format="%(refname:short)" >actual &&
> +	echo local-one >expect &&
> +	test_cmp expect actual
> +'
> +
> +test_expect_success '--forked rejects unknown branch/pattern' '
> +	test_must_fail git -C forked branch --forked nope 2>err &&
> +	test_grep "not a valid branch or pattern" err
> +'
> +
> +test_expect_success '--forked requires a value' '
> +	test_must_fail git -C forked branch --forked 2>err &&
> +	test_grep "requires a value" err
> +'
> +
>   test_done

Hi Harald

On 03/06/2026 10:04, Harald Nordgren via GitGitGadget wrote:
> From: Harald Nordgren <haraldnordgren@gmail.com>
> > Add a --forked option to "git branch" list mode that keeps only
> branches whose configured upstream matches <branch>. The argument
> can be a ref (e.g. "origin/main", "master") or a shell-style
> glob (e.g. "origin/*"). The option can be repeated to widen the
> filter.

Do we want to support a remote name as an alias for $remote/HEAD to match "git checkout -b $remote"?

> Because it is a filter on list mode, --forked composes with the
> existing list-mode filters, so
> >      git branch --merged origin/main --forked 'origin/*'
> > lists branches forked from origin that have already been
> integrated into origin/main, and --no-merged inverts the question.

Nice
> This is the building block for --prune-merged, which deletes the
> listed branches once they have landed on their upstream.
> > Signed-off-by: Harald Nordgren <haraldnordgren@gmail.com>
> ---
>   Documentation/git-branch.adoc |   7 ++
>   builtin/branch.c              | 147 +++++++++++++++++++++++++++++++++-
>   ref-filter.c                  |  10 +--
>   ref-filter.h                  |   2 +
>   t/t3200-branch.sh             |  92 +++++++++++++++++++++
>   5 files changed, 249 insertions(+), 9 deletions(-)
> > diff --git a/Documentation/git-branch.adoc b/Documentation/git-branch.adoc
> index c0afddc424..8002d7f38c 100644
> --- a/Documentation/git-branch.adoc
> +++ b/Documentation/git-branch.adoc
> @@ -14,6 +14,7 @@ git branch [--color[=<when>] | --no-color] [--show-current]
>   	   [--merged [<commit>]] [--no-merged [<commit>]]
>   	   [--contains [<commit>]] [--no-contains [<commit>]]
>   	   [--points-at <object>] [--format=<format>]
> +	   [(--forked <branch>)...]

Should this come before --format? I think it logically belongs with --merged and --contains which also filter the output.

>   	   [(-r|--remotes) | (-a|--all)]
>   	   [--list] [<pattern>...]
>   git branch [--track[=(direct|inherit)] | --no-track] [-f]
> @@ -199,6 +200,12 @@ This option is only applicable in non-verbose mode.
>   	Print the name of the current branch. In detached `HEAD` state,
>   	nothing is printed.
>   > +`--forked <branch>`::
> +	List only branches whose configured upstream matches
> +	_<branch>_. The argument can be a ref (e.g. `origin/main`,
> +	`master`) or a shell-style glob (e.g. `'origin/*'`). The
> +	option can be repeated to widen the filter.

This is fine but do we want to add a sentence to the DESCRIPTION as well where it talks about "--contains" and "--merged"?

>   `-v`::
>   `-vv`::
>   `--verbose`::
> diff --git a/builtin/branch.c b/builtin/branch.c
> index 1572a4f9ef..12711b29cf 100644
> --- a/builtin/branch.c
> +++ b/builtin/branch.c
> @@ -28,9 +28,10 @@
>   #include "help.h"
>   #include "advice.h"
>   #include "commit-reach.h"
> +#include "wildmatch.h"
>   >   static const char * const builtin_branch_usage[] = {
> -	N_("git branch [<options>] [-r | -a] [--merged] [--no-merged]"),
> +	N_("git branch [<options>] [-r | -a] [--merged] [--no-merged] [(--forked <branch>)...]"),
>   	N_("git branch [<options>] [-f] [--recurse-submodules] <branch-name> [<start-point>]"),
>   	N_("git branch [<options>] [-l] [<pattern>...]"),
>   	N_("git branch [<options>] [-r] (-d | -D) <branch-name>..."),
> @@ -442,8 +443,12 @@ static char *build_format(struct ref_filter *filter, int maxwidth, const char *r
>   	return strbuf_detach(&fmt, NULL);
>   }
>   > +static void filter_array_by_forked(struct ref_array *array,
> +				   const struct string_list *upstreams);

We try to avoid forward declarations unless they're really needed - can we add the new functions up here instead?

>   static void print_ref_list(struct ref_filter *filter, struct ref_sorting *sorting,
> -			   struct ref_format *format, struct string_list *output)
> +			   struct ref_format *format, struct string_list *output,
> +			   const struct string_list *forked_upstreams)
>   {
>   	int i;
>   	struct ref_array array;
> @@ -463,6 +468,9 @@ static void print_ref_list(struct ref_filter *filter, struct ref_sorting *sortin
>   >   	filter_refs(&array, filter, filter->kind);
>   > +	if (forked_upstreams->nr)
> +		filter_array_by_forked(&array, forked_upstreams);

This gets a bit messy below where free elements when we filter "array". It would be much nicer to do the filtering in apply_ref_filter() so that we don't have to allocate those in the first place. I think it would make it simpler to implement --prune-merged as collect_forked_set() would become a call to filter_refs() and we could support --forked in "git for-each-ref".

> +static int parse_one_forked_arg(const char *arg, struct upstream_pattern *out)
> +{
> +	struct object_id oid;
> +	char *full_ref = NULL;
> +
> +	if (has_glob_specials(arg)) {
> +		out->name = xstrdup(arg);
> +		out->is_wildcard = 1;
> +		return 0;
> +	}
> +
> +	if (repo_dwim_ref(the_repository, arg, strlen(arg), &oid,
> +			  &full_ref, 0) == 1 &&
> +	    (starts_with(full_ref, "refs/heads/") ||
> +	     starts_with(full_ref, "refs/remotes/"))) {
> +		out->name = xstrdup(short_upstream_name(full_ref));

I don't think abbreviating the refname here is a good idea as short names are inherently ambiguous - in principle you could have a remote tracking branch and a local branch with the same short name. It also means we end up reconstructing the full name in a later patch, instead we should just call short_upstream_name() where we need the abbreviated name.

> +static int upstream_matches(const char *short_upstream,
> +			    const struct upstream_pattern *patterns,
> +			    size_t nr)
> +{
> +	size_t i;
> +
> +	for (i = 0; i < nr; i++) {
> +		const struct upstream_pattern *p = &patterns[i];
> +		if (p->is_wildcard) {
> +			if (!wildmatch(p->name, short_upstream, WM_PATHNAME))
> +				return 1;
> +		} else if (!strcmp(p->name, short_upstream)) {
> +			return 1;
> +		}
> +	}

This is quadratic but maybe we can assume the user wont pass "--forked" too many times. If this ever becomes a problem we could use an strset for the exact matches and then we only need to loop over the wildmatch patterns but we probably don't need to worry about that now.

> +static int branch_upstream_matches(const char *full_refname,
> +				   const struct upstream_pattern *patterns,
> +				   size_t nr_patterns)
> +{
> +	const char *short_name;
> +	struct branch *branch;
> +	const char *upstream;
> +
> +	if (!skip_prefix(full_refname, "refs/heads/", &short_name))
> +		return 0;
> +	branch = branch_get(short_name);
> +	if (!branch)
> +		return 0;
> +	upstream = branch_get_upstream(branch, NULL);
> +	if (!upstream)
> +		return 0;
> +	return upstream_matches(short_upstream_name(upstream),

This would be simpler if we matched on full names.

> +static void filter_array_by_forked(struct ref_array *array,
> +				   const struct string_list *upstreams)
> +{
> +	struct upstream_pattern *patterns = NULL;
> +	size_t nr_patterns = 0;
> +	int i, kept = 0;
> +
> +	parse_forked_args(upstreams, &patterns, &nr_patterns);
> +
> +	for (i = 0; i < array->nr; i++) {
> +		struct ref_array_item *item = array->items[i];
> +		if (branch_upstream_matches(item->refname,
> +					    patterns, nr_patterns))
> +			array->items[kept++] = item;
> +		else
> +			free_ref_array_item(item);
> +	}
> +	array->nr = kept;

As I said above this would be nicer if it was implemented in apply_ref_filter().

> @@ -714,6 +847,7 @@ int cmd_branch(int argc,
>   	/* possible actions */
>   	int delete = 0, rename = 0, copy = 0, list = 0,
>   	    unset_upstream = 0, show_current = 0, edit_description = 0;
> +	struct string_list forked_upstreams = STRING_LIST_INIT_DUP;

Personally I'd use a strvec here as we don't need the "util" member of the string list but I'm probably biased as I don't really like the string list api.

I like the idea of making this just another filter to "--list". The basics of the implementation look reasonable - it should be straight forward to match on full refs and move the relavent code into filter-refs.c

Thanks

Phillip

>   	const char *new_upstream = NULL;
>   	int noncreate_actions = 0;
>   	/* possible options */
> @@ -767,6 +901,8 @@ int cmd_branch(int argc,
>   		OPT_BOOL(0, "create-reflog", &reflog, N_("create the branch's reflog")),
>   		OPT_BOOL(0, "edit-description", &edit_description,
>   			 N_("edit the description for the branch")),
> +		OPT_STRING_LIST(0, "forked", &forked_upstreams, N_("branch"),
> +			N_("list local branches whose upstream matches <branch> (repeatable)")),
>   		OPT__FORCE(&force, N_("force creation, move/rename, deletion"), PARSE_OPT_NOCOMPLETE),
>   		OPT_MERGED(&filter, N_("print only branches that are merged")),
>   		OPT_NO_MERGED(&filter, N_("print only branches that are not merged")),
> @@ -815,7 +951,8 @@ int cmd_branch(int argc,
>   		list = 1;
>   >   	if (filter.with_commit || filter.no_commit ||
> -	    filter.reachable_from || filter.unreachable_from || filter.points_at.nr)
> +	    filter.reachable_from || filter.unreachable_from ||
> +	    filter.points_at.nr || forked_upstreams.nr)
>   		list = 1;
>   >   	noncreate_actions = !!delete + !!rename + !!copy + !!new_upstream +
> @@ -880,7 +1017,8 @@ int cmd_branch(int argc,
>   		ref_sorting_set_sort_flags_all(sorting, REF_SORTING_ICASE, icase);
>   		ref_sorting_set_sort_flags_all(
>   			sorting, REF_SORTING_DETACHED_HEAD_FIRST, 1);
> -		print_ref_list(&filter, sorting, &format, &output);
> +		print_ref_list(&filter, sorting, &format, &output,
> +			       &forked_upstreams);
>   		print_columns(&output, colopts, NULL);
>   		string_list_clear(&output, 0);
>   		ref_sorting_release(sorting);
> @@ -1020,5 +1158,6 @@ int cmd_branch(int argc,
>   >   out:
>   	string_list_clear(&sorting_options, 0);
> +	string_list_clear(&forked_upstreams, 0);
>   	return ret;
>   }
> diff --git a/ref-filter.c b/ref-filter.c
> index 1da4c0e60d..65e7bc6785 100644
> --- a/ref-filter.c
> +++ b/ref-filter.c
> @@ -3035,7 +3035,7 @@ static int filter_one(const struct reference *ref, void *cb_data)
>   }
>   >   /*  Free memory allocated for a ref_array_item */
> -static void free_array_item(struct ref_array_item *item)
> +void free_ref_array_item(struct ref_array_item *item)
>   {
>   	free((char *)item->symref);
>   	if (item->value) {
> @@ -3078,7 +3078,7 @@ static int filter_and_format_one(const struct reference *ref, void *cb_data)
>   >   	strbuf_release(&output);
>   	strbuf_release(&err);
> -	free_array_item(item);
> +	free_ref_array_item(item);
>   >   	/*
>   	 * Increment the running count of refs that match the filter. If
> @@ -3098,7 +3098,7 @@ void ref_array_clear(struct ref_array *array)
>   	int i;
>   >   	for (i = 0; i < array->nr; i++)
> -		free_array_item(array->items[i]);
> +		free_ref_array_item(array->items[i]);
>   	FREE_AND_NULL(array->items);
>   	array->nr = array->alloc = 0;
>   > @@ -3171,7 +3171,7 @@ static void reach_filter(struct ref_array *array,
>   		if (is_merged == include_reached)
>   			array->items[array->nr++] = array->items[i];
>   		else
> -			free_array_item(item);
> +			free_ref_array_item(item);
>   	}
>   >   	clear_commit_marks_many(old_nr, to_clear, ALL_REV_FLAGS);
> @@ -3667,7 +3667,7 @@ void pretty_print_ref(const char *name, const struct object_id *oid,
>   >   	strbuf_release(&err);
>   	strbuf_release(&output);
> -	free_array_item(ref_item);
> +	free_ref_array_item(ref_item);
>   }
>   >   static int parse_sorting_atom(const char *atom)
> diff --git a/ref-filter.h b/ref-filter.h
> index 120221b47f..3883b9dc62 100644
> --- a/ref-filter.h
> +++ b/ref-filter.h
> @@ -155,6 +155,8 @@ void filter_and_format_refs(struct ref_filter *filter, unsigned int type,
>   			    struct ref_format *format);
>   /*  Clear all memory allocated to ref_array */
>   void ref_array_clear(struct ref_array *array);
> +/*  Free a single item from a ref_array */
> +void free_ref_array_item(struct ref_array_item *item);
>   /*  Used to verify if the given format is correct and to parse out the used atoms */
>   int verify_ref_format(struct ref_format *format);
>   /*  Sort the given ref_array as per the ref_sorting provided */
> diff --git a/t/t3200-branch.sh b/t/t3200-branch.sh
> index e7829c2c4b..4e7deddc04 100755
> --- a/t/t3200-branch.sh
> +++ b/t/t3200-branch.sh
> @@ -1717,4 +1717,96 @@ test_expect_success 'errors if given a bad branch name' '
>   	test_cmp expect actual
>   '
>   > +test_expect_success '--forked: setup' '
> +	test_create_repo forked-upstream &&
> +	test_commit -C forked-upstream base &&
> +	git -C forked-upstream branch one base &&
> +	git -C forked-upstream branch two base &&
> +
> +	test_create_repo forked-other &&
> +	test_commit -C forked-other other-base &&
> +	git -C forked-other branch foreign other-base &&
> +
> +	git clone forked-upstream forked &&
> +	git -C forked remote add other ../forked-other &&
> +	git -C forked fetch other &&
> +	git -C forked branch local-base &&
> +	git -C forked branch --track local-one origin/one &&
> +	git -C forked branch --track local-two origin/two &&
> +	git -C forked branch --track local-foreign other/foreign &&
> +	git -C forked branch detached &&
> +	git -C forked branch --track local-trunk local-base
> +'
> +
> +test_expect_success '--forked <upstream-tracking-branch> filters by upstream' '
> +	git -C forked branch --forked origin/one --format="%(refname:short)" >actual &&
> +	echo local-one >expect &&
> +	test_cmp expect actual
> +'
> +
> +test_expect_success '--forked <glob> filters by wildmatch' '
> +	git -C forked branch --forked "origin/*" --format="%(refname:short)" >actual &&
> +	cat >expect <<-\EOF &&
> +	local-one
> +	local-two
> +	main
> +	EOF
> +	test_cmp expect actual
> +'
> +
> +test_expect_success '--forked <local-branch> matches branches with local upstream' '
> +	git -C forked branch --forked local-base --format="%(refname:short)" >actual &&
> +	echo local-trunk >expect &&
> +	test_cmp expect actual
> +'
> +
> +test_expect_success '--forked can be repeated to widen the filter' '
> +	git -C forked branch --forked origin/one --forked other/foreign --format="%(refname:short)" >actual &&
> +	cat >expect <<-\EOF &&
> +	local-foreign
> +	local-one
> +	EOF
> +	test_cmp expect actual
> +'
> +
> +test_expect_success '--forked combines literal and glob arguments' '
> +	git -C forked branch --forked local-base --forked "other/*" --format="%(refname:short)" >actual &&
> +	cat >expect <<-\EOF &&
> +	local-foreign
> +	local-trunk
> +	EOF
> +	test_cmp expect actual
> +'
> +
> +test_expect_success '--forked "*/*" covers every remote-tracking upstream' '
> +	git -C forked branch --forked "*/*" --format="%(refname:short)" >actual &&
> +	cat >expect <<-\EOF &&
> +	local-foreign
> +	local-one
> +	local-two
> +	main
> +	EOF
> +	test_cmp expect actual
> +'
> +
> +test_expect_success '--forked composes with --no-merged' '
> +	test_when_finished "git -C forked checkout detached" &&
> +	git -C forked checkout local-one &&
> +	test_commit -C forked local-only &&
> +	git -C forked branch --forked "origin/*" --no-merged origin/one \
> +		--format="%(refname:short)" >actual &&
> +	echo local-one >expect &&
> +	test_cmp expect actual
> +'
> +
> +test_expect_success '--forked rejects unknown branch/pattern' '
> +	test_must_fail git -C forked branch --forked nope 2>err &&
> +	test_grep "not a valid branch or pattern" err
> +'
> +
> +test_expect_success '--forked requires a value' '
> +	test_must_fail git -C forked branch --forked 2>err &&
> +	test_grep "requires a value" err
> +'
> +
>   test_done

Hi Phillip!

Great points all around, I will take a look at implementing them. I'll
respond here instead of for each specific message, and then include
comments as part of the next version.

> > Add a --forked option to "git branch" list mode that keeps only
> > branches whose configured upstream matches <branch>. The argument
> > can be a ref (e.g. "origin/main", "master") or a shell-style
> > glob (e.g. "origin/*"). The option can be repeated to widen the
> > filter.
>
> Do we want to support a remote name as an alias for $remote/HEAD to
> match "git checkout -b $remote"?

I have been going back and forth on this, and while I like the bare
remote, it made the implementation a lot easier after it was removed,
as the arguments from some of the others made sense to me.


Harald

On Mon, May 4, 2026, at 20:27, Harald Nordgren via GitGitGadget wrote:
> From: Harald Nordgren <haraldnordgren@gmail.com>
>
> List local branches whose configured upstream falls within any of
> the given <remote> arguments. <remote> may be either a configured
> remote name (matching all of its remote-tracking refs) or a single
> remote-tracking ref. Multiple <remote> arguments are unioned.
>
> This is the building block for --prune-merged, which deletes the
> listed branches.
>
> Signed-off-by: Harald Nordgren <haraldnordgren@gmail.com>

s/remote-tracking refs/remote-tracking branches/g

Here and below and on the other patches.

> ---
>  Documentation/git-branch.adoc |  12 ++++
>  builtin/branch.c              | 110 +++++++++++++++++++++++++++++++++-
>  t/t3200-branch.sh             |  54 +++++++++++++++++
>  3 files changed, 174 insertions(+), 2 deletions(-)
>[snip]

Hi Harald

On 13/05/2026 20:34, Harald Nordgren via GitGitGadget wrote:
> From: Harald Nordgren <haraldnordgren@gmail.com>
> > +`--all-remotes`::
> +	With `--forked` or `--prune-merged`, act on every
> +	configured remote in addition to any explicit _<remote>_
> +	arguments.

Why do we except additional arguments if this option includes all the remotes?

Thanks

Phillip

>   `-v`::
>   `-vv`::
>   `--verbose`::
> diff --git a/builtin/branch.c b/builtin/branch.c
> index bc4f4a4a18..7d45bada45 100644
> --- a/builtin/branch.c
> +++ b/builtin/branch.c
> @@ -687,6 +687,13 @@ static void copy_or_rename_branch(const char *oldname, const char *newname, int
>   	free_worktrees(worktrees);
>   }
>   > +static int collect_remote_name(struct remote *remote, void *cb_data)
> +{
> +	struct string_list *remote_names = cb_data;
> +	string_list_insert(remote_names, remote->name);
> +	return 0;
> +}
> +
>   static void parse_forked_args(int argc, const char **argv,
>   			      struct string_list *remote_names,
>   			      struct string_list *tracking_refs)
> @@ -776,7 +783,7 @@ static void collect_default_branch_refs(const struct string_list *remote_names,
>   	}
>   }
>   > -static void collect_forked_set(int argc, const char **argv,
> +static void collect_forked_set(int argc, const char **argv, int all_remotes,
>   			       struct string_list *protected_default_refs,
>   			       struct string_list *out)
>   {
> @@ -789,6 +796,8 @@ static void collect_forked_set(int argc, const char **argv,
>   	};
>   >   	parse_forked_args(argc, argv, &remote_names, &tracking_refs);
> +	if (all_remotes)
> +		for_each_remote(collect_remote_name, &remote_names);
>   >   	refs_for_each_branch_ref(get_main_ref_store(the_repository),
>   				 collect_forked_branch, &cb);
> @@ -802,15 +811,15 @@ static void collect_forked_set(int argc, const char **argv,
>   	string_list_clear(&tracking_refs, 0);
>   }
>   > -static int list_forked_branches(int argc, const char **argv)
> +static int list_forked_branches(int argc, const char **argv, int all_remotes)
>   {
>   	struct string_list out = STRING_LIST_INIT_DUP;
>   	struct string_list_item *item;
>   > -	if (!argc)
> -		die(_("--forked requires at least one <remote>"));
> +	if (!argc && !all_remotes)
> +		die(_("--forked requires at least one <remote> or --all-remotes"));
>   > -	collect_forked_set(argc, argv, NULL, &out);
> +	collect_forked_set(argc, argv, all_remotes, NULL, &out);
>   	for_each_string_list_item(item, &out)
>   		puts(item->string);
>   > @@ -818,7 +827,8 @@ static int list_forked_branches(int argc, const char **argv)
>   	return 0;
>   }
>   > -static int prune_merged_branches(int argc, const char **argv, int quiet)
> +static int prune_merged_branches(int argc, const char **argv,
> +				 int all_remotes, int quiet)
>   {
>   	struct string_list candidates = STRING_LIST_INIT_DUP;
>   	struct string_list protected_default_refs = STRING_LIST_INIT_DUP;
> @@ -827,10 +837,11 @@ static int prune_merged_branches(int argc, const char **argv, int quiet)
>   	int n_not_merged = 0;
>   	int ret = 0;
>   > -	if (!argc)
> -		die(_("--prune-merged requires at least one <remote>"));
> +	if (!argc && !all_remotes)
> +		die(_("--prune-merged requires at least one <remote> or --all-remotes"));
>   > -	collect_forked_set(argc, argv, &protected_default_refs, &candidates);
> +	collect_forked_set(argc, argv, all_remotes, &protected_default_refs,
> +			   &candidates);
>   >   	for_each_string_list_item(item, &candidates) {
>   		const char *short_name = item->string;
> @@ -943,6 +954,7 @@ int cmd_branch(int argc,
>   	    unset_upstream = 0, show_current = 0, edit_description = 0;
>   	int forked = 0;
>   	int prune_merged = 0;
> +	int all_remotes = 0;
>   	const char *new_upstream = NULL;
>   	int noncreate_actions = 0;
>   	/* possible options */
> @@ -1000,6 +1012,9 @@ int cmd_branch(int argc,
>   			N_("list local branches forked from the given <remote>s")),
>   		OPT_BOOL(0, "prune-merged", &prune_merged,
>   			N_("delete local branches forked from the given <remote>s that are merged into their upstream")),
> +		OPT_BOOL_F(0, "all-remotes", &all_remotes,
> +			N_("with --forked or --prune-merged, act on every configured remote"),
> +			PARSE_OPT_NONEG),
>   		OPT__FORCE(&force, N_("force creation, move/rename, deletion"), PARSE_OPT_NOCOMPLETE),
>   		OPT_MERGED(&filter, N_("print only branches that are merged")),
>   		OPT_NO_MERGED(&filter, N_("print only branches that are not merged")),
> @@ -1043,6 +1058,10 @@ int cmd_branch(int argc,
>   	argc = parse_options(argc, argv, prefix, options, builtin_branch_usage,
>   			     0);
>   > +	if (all_remotes && !forked && !prune_merged)
> +		die(_("--all-remotes requires --forked or --prune-merged"));
> +
> +
>   	if (!delete && !rename && !copy && !edit_description && !new_upstream &&
>   	    !show_current && !unset_upstream && !forked && !prune_merged &&
>   	    argc == 0)
> @@ -1096,10 +1115,10 @@ int cmd_branch(int argc,
>   				      quiet, 0, NULL);
>   		goto out;
>   	} else if (forked) {
> -		ret = list_forked_branches(argc, argv);
> +		ret = list_forked_branches(argc, argv, all_remotes);
>   		goto out;
>   	} else if (prune_merged) {
> -		ret = prune_merged_branches(argc, argv, quiet);
> +		ret = prune_merged_branches(argc, argv, all_remotes, quiet);
>   		goto out;
>   	} else if (show_current) {
>   		print_current_branch_name();
> diff --git a/t/t3200-branch.sh b/t/t3200-branch.sh
> index 885a275e36..a36e5ee80a 100755
> --- a/t/t3200-branch.sh
> +++ b/t/t3200-branch.sh
> @@ -1771,6 +1771,27 @@ test_expect_success '--forked requires at least one <remote>' '
>   	test_grep "at least one <remote>" err
>   '
>   > +test_expect_success '--forked --all-remotes covers every configured remote' '
> +	git -C forked branch --forked --all-remotes >actual &&
> +	cat >expect <<-\EOF &&
> +	local-foreign
> +	local-one
> +	local-two
> +	main
> +	EOF
> +	test_cmp expect actual
> +'
> +
> +test_expect_success '--forked --all-remotes still validates explicit <remote>' '
> +	test_must_fail git -C forked branch --forked nope --all-remotes 2>err &&
> +	test_grep "neither a configured remote nor a remote-tracking branch" err
> +'
> +
> +test_expect_success '--all-remotes alone is rejected' '
> +	test_must_fail git -C forked branch --all-remotes 2>err &&
> +	test_grep "requires --forked or --prune-merged" err
> +'
> +
>   test_expect_success '--prune-merged: setup' '
>   	test_create_repo pm-upstream &&
>   	test_commit -C pm-upstream base &&
> @@ -1881,4 +1902,27 @@ test_expect_success 'branch -d still deletes a pruneMerged=false branch' '
>   	test_must_fail git -C pm-optout-d rev-parse --verify refs/heads/one
>   '
>   > +test_expect_success '--prune-merged --all-remotes covers every configured remote' '
> +	test_when_finished "rm -rf pm-allremotes pm-other" &&
> +	git clone pm-upstream pm-allremotes &&
> +	test_create_repo pm-other &&
> +	test_commit -C pm-other other-base &&
> +	git -C pm-other checkout -b stable &&
> +	test_commit -C pm-other foreign-commit &&
> +	git -C pm-other branch foreign HEAD &&
> +	git -C pm-other checkout main &&
> +
> +	git -C pm-allremotes remote add other ../pm-other &&
> +	git -C pm-allremotes fetch other &&
> +	git -C pm-allremotes branch one one-commit &&
> +	git -C pm-allremotes branch --set-upstream-to=origin/next one &&
> +	git -C pm-allremotes branch foreign other/foreign &&
> +	git -C pm-allremotes branch --set-upstream-to=other/stable foreign &&
> +
> +	git -C pm-allremotes branch --prune-merged --all-remotes &&
> +
> +	test_must_fail git -C pm-allremotes rev-parse --verify refs/heads/one &&
> +	test_must_fail git -C pm-allremotes rev-parse --verify refs/heads/foreign
> +'
> +
>   test_done

"Harald Nordgren via GitGitGadget" <gitgitgadget@gmail.com> writes:

> diff --git a/builtin/branch.c b/builtin/branch.c
> index 1572a4f9ef..1e24c95a69 100644
> --- a/builtin/branch.c
> +++ b/builtin/branch.c
> @@ -28,6 +28,7 @@
>  #include "help.h"
>  #include "advice.h"
>  #include "commit-reach.h"
> +#include "wildmatch.h"
>  
>  static const char * const builtin_branch_usage[] = {
>  	N_("git branch [<options>] [-r | -a] [--merged] [--no-merged]"),
> @@ -38,6 +39,7 @@ static const char * const builtin_branch_usage[] = {
>  	N_("git branch [<options>] (-c | -C) [<old-branch>] <new-branch>"),
>  	N_("git branch [<options>] [-r | -a] [--points-at]"),
>  	N_("git branch [<options>] [-r | -a] [--format]"),
> +	N_("git branch [<options>] --forked <branch>..."),
>  	NULL
>  };
>  
> @@ -191,7 +193,8 @@ static int branch_merged(int kind, const char *name,
>  
>  static int check_branch_commit(const char *branchname, const char *refname,
>  			       const struct object_id *oid, struct commit *head_rev,
> -			       int kinds, int force)
> +			       int kinds, int force, int warn_only,
> +			       int *n_not_merged)
>  {
>  	struct commit *rev = lookup_commit_reference(the_repository, oid);
>  	if (!force && !rev) {
> @@ -199,10 +202,18 @@ static int check_branch_commit(const char *branchname, const char *refname,
>  		return -1;
>  	}
>  	if (!force && !branch_merged(kinds, branchname, rev, head_rev)) {
> -		error(_("the branch '%s' is not fully merged"), branchname);
> -		advise_if_enabled(ADVICE_FORCE_DELETE_BRANCH,
> -				  _("If you are sure you want to delete it, "
> -				  "run 'git branch -D %s'"), branchname);
> +		if (warn_only) {
> +			warning(_("the branch '%s' is not fully merged"),
> +				branchname);
> +		} else {
> +			error(_("the branch '%s' is not fully merged"),
> +			      branchname);
> +			advise_if_enabled(ADVICE_FORCE_DELETE_BRANCH,
> +					  _("If you are sure you want to delete it, "
> +					  "run 'git branch -D %s'"), branchname);
> +		}
> +		if (n_not_merged)
> +			(*n_not_merged)++;
>  		return -1;
>  	}
>  	return 0;

This function originally was to see if "git branch -d <derived>" is
allowed to remove it by calling branch_merged(), which uses the
upstream association of <derived>, falling back to head_rev.  For
our purpose of "--forked" check, we are not deleting, so existing
calls to error() and the phrasing used in its messages that talks
about deletion are not appropriate.  Hence we introduce the
warn_only mode to just state the fact the branch is not fully merged
to its upstream.

It is inherited from the original code, and it is outside the scope
of this series, but after the dust settles, we may want to consider
saying what other branch this branch is expected to be merged to
(i.e. "not fully merged to %s").

It is unclear how n_not_merged would be useful.  Wouldn't the caller
be capable to count the failure returns from this function?

> @@ -218,7 +229,7 @@ static void delete_branch_config(const char *branchname)
>  }
>  
>  static int delete_branches(int argc, const char **argv, int force, int kinds,
> -			   int quiet)
> +			   int quiet, int warn_only, int *n_not_merged)

It is strange to see any need to touch delete_branches() when the
only thing you are adding is the "--forked" option.  For that
matter, the change to check_branch_commit() is also suspect.

In short, this does a lot more than necessary to add "--forked".
Why such a split in the series?

> +static void parse_forked_args(int argc, const char **argv,
> +			      struct string_list *upstream_patterns)
> +{
> +	int i;
> +
> +	for (i = 0; i < argc; i++) {
> +		const char *arg = argv[i];
> +		struct object_id oid;
> +		char *full_ref = NULL;
> +		const char *short_ref;
> +
> +		if (has_glob_specials(arg)) {
> +			string_list_insert(upstream_patterns, arg);
> +			continue;
> +		}
> +
> +		if (repo_dwim_ref(the_repository, arg, strlen(arg), &oid,
> +				  &full_ref, 0) == 1 &&
> +		    (skip_prefix(full_ref, "refs/heads/", &short_ref) ||
> +		     skip_prefix(full_ref, "refs/remotes/", &short_ref))) {
> +			string_list_insert(upstream_patterns, short_ref);
> +			free(full_ref);
> +			continue;
> +		}
> +		free(full_ref);
> +
> +		die(_("'%s' is not a valid branch or pattern"), arg);
> +	}
> +}

This one does look like very much relevant to "--forked".

> +struct forked_cb {
> +	const struct string_list *upstream_patterns;
> +	struct string_list *out;
> +};

So does this.

> +static int collect_forked_branch(const struct reference *ref, void *cb_data)
> +{
> +	struct forked_cb *cb = cb_data;
> +	struct branch *branch;
> +	const char *upstream, *short_upstream;
> +	const struct string_list_item *item;
> +
> +	if (ref->flags & REF_ISSYMREF)
> +		return 0;
> +	branch = branch_get(ref->name);
> +	if (!branch)
> +		return 0;
> +	upstream = branch_get_upstream(branch, NULL);
> +	if (!upstream)
> +		return 0;
> +	short_upstream = upstream;
> +	(void)(skip_prefix(short_upstream, "refs/heads/", &short_upstream) ||
> +	       skip_prefix(short_upstream, "refs/remotes/", &short_upstream));
> +
> +	for_each_string_list_item(item, cb->upstream_patterns)

Sholdn't each element of upstream_patterns remember if it is
suitable for wildmatch or not when it gets parsed in the earlier
function we saw, so that this loop can refrain from calling
wildmatch() for non-wildcard elements?

> +		if (!wildmatch(item->string, short_upstream, WM_PATHNAME)) {
> +			string_list_append(cb->out, ref->name)->util =
> +				xstrdup(upstream);
> +			return 0;
> +		}
> +	return 0;
> +}
> +
> +static void collect_forked_set(int argc, const char **argv,
> +			       struct string_list *out)
> +{
> +	struct string_list upstream_patterns = STRING_LIST_INIT_DUP;
> +	struct forked_cb cb = {
> +		.upstream_patterns = &upstream_patterns,
> +		.out = out,
> +	};
> +
> +	parse_forked_args(argc, argv, &upstream_patterns);
> +
> +	refs_for_each_branch_ref(get_main_ref_store(the_repository),
> +				 collect_forked_branch, &cb);
> +
> +	string_list_clear(&upstream_patterns, 0);
> +}
> +
> +static int list_forked_branches(int argc, const char **argv)
> +{
> +	struct string_list out = STRING_LIST_INIT_DUP;
> +	struct string_list_item *item;
> +
> +	if (!argc)
> +		die(_("--forked requires at least one <branch>"));
> +
> +	collect_forked_set(argc, argv, &out);
> +	for_each_string_list_item(item, &out)
> +		puts(item->string);
> +
> +	string_list_clear(&out, 1);
> +	return 0;
> +}

Up to point the changes are very much appropriate for adding the
"--forked" option.

> @@ -714,6 +822,7 @@ int cmd_branch(int argc,
>  	/* possible actions */
>  	int delete = 0, rename = 0, copy = 0, list = 0,
>  	    unset_upstream = 0, show_current = 0, edit_description = 0;
> +	int forked = 0;
>  	const char *new_upstream = NULL;
>  	int noncreate_actions = 0;
>  	/* possible options */
> @@ -767,6 +876,8 @@ int cmd_branch(int argc,
>  		OPT_BOOL(0, "create-reflog", &reflog, N_("create the branch's reflog")),
>  		OPT_BOOL(0, "edit-description", &edit_description,
>  			 N_("edit the description for the branch")),
> +		OPT_BOOL(0, "forked", &forked,
> +			N_("list local branches whose upstream matches the given <branch>...")),
>  		OPT__FORCE(&force, N_("force creation, move/rename, deletion"), PARSE_OPT_NOCOMPLETE),
>  		OPT_MERGED(&filter, N_("print only branches that are merged")),
>  		OPT_NO_MERGED(&filter, N_("print only branches that are not merged")),
> @@ -811,7 +922,7 @@ int cmd_branch(int argc,
>  			     0);
>  
>  	if (!delete && !rename && !copy && !edit_description && !new_upstream &&
> -	    !show_current && !unset_upstream && argc == 0)
> +	    !show_current && !unset_upstream && !forked && argc == 0)
>  		list = 1;
>  
>  	if (filter.with_commit || filter.no_commit ||
> @@ -820,7 +931,7 @@ int cmd_branch(int argc,
>  
>  	noncreate_actions = !!delete + !!rename + !!copy + !!new_upstream +
>  			    !!show_current + !!list + !!edit_description +
> -			    !!unset_upstream;
> +			    !!unset_upstream + !!forked;
>  	if (noncreate_actions > 1)
>  		usage_with_options(builtin_branch_usage, options);
>  
> @@ -858,7 +969,11 @@ int cmd_branch(int argc,
>  	if (delete) {
>  		if (!argc)
>  			die(_("branch name required"));
> -		ret = delete_branches(argc, argv, delete > 1, filter.kind, quiet);
> +		ret = delete_branches(argc, argv, delete > 1, filter.kind,
> +				      quiet, 0, NULL);
> +		goto out;

This does not belong to "--forked" as far as I can tell.

> +	} else if (forked) {
> +		ret = list_forked_branches(argc, argv);
>  		goto out;
>  	} else if (show_current) {
>  		print_current_branch_name();

Am 22.05.26 um 00:40 schrieb Harald Nordgren via GitGitGadget:
> diff --git a/Documentation/git-branch.adoc b/Documentation/git-branch.adoc
> index c0afddc424..3a421f6663 100644
> --- a/Documentation/git-branch.adoc
> +++ b/Documentation/git-branch.adoc
> @@ -24,6 +24,7 @@ git branch (-m|-M) [<old-branch>] <new-branch>
>  git branch (-c|-C) [<old-branch>] <new-branch>
>  git branch (-d|-D) [-r] <branch-name>...
>  git branch --edit-description [<branch-name>]
> +git branch --forked <branch>...

I would have preferred that this option is another filter of --list
mode, not its own mode of operation. Consequently, each --forked option
would take only a single argument (which can contain globs), and can be
given multiple times.

>  
>  DESCRIPTION
>  -----------
> @@ -199,6 +200,12 @@ This option is only applicable in non-verbose mode.
>  	Print the name of the current branch. In detached `HEAD` state,
>  	nothing is printed.
>  
> +`--forked`::
> +	List local branches whose configured upstream matches any
> +	of the given _<branch>_ arguments. Each argument is either
> +	a ref (e.g. `origin/master`, `master`) or a shell-style
> +	glob (e.g. `'origin/*'`). Multiple arguments are unioned.

So this could perhaps read:

`--forked`::
	List only branches whose configured upstream matches
	_<branch>_. The argument can contain a shell-style glob
	 (e.g. `'origin/*'`). The option can be repeated to
	widen the filter.

Note that there is no reason to say "local branches". ("... are unioned"
sounds strange, so this is may attempt to express the same in a
different way.)

The icing on the cake would now be that

    git branch --merged origin/main --forked origin/*

provides the list of branches forked from origin that have already been
integrated.

-- Hannes

Johannes Sixt <j6t@kdbg.org> writes:

> The icing on the cake would now be that
>
>     git branch --merged origin/main --forked origin/*
>
> provides the list of branches forked from origin that have already been
> integrated.

Yup, that is very nice.  Also with "--merged" replaced with
"--not-merged", i.e., "our work building on top of origin's, and
still need to be finished", would give us a good list to work on.

> Johannes Sixt <j6t@kdbg.org> writes:
>
> > The icing on the cake would now be that
> >
> >     git branch --merged origin/main --forked origin/*
> >
> > provides the list of branches forked from origin that have already been
> > integrated.
>
> Yup, that is very nice.  Also with "--merged" replaced with
> "--not-merged", i.e., "our work building on top of origin's, and
> still need to be finished", would give us a good list to work on.

This is nice, but I think this would require an overhaul of other
infra as well, maybe better to do as a follow-up?


Harald

Am 22.05.26 um 12:49 schrieb Harald Nordgren:
>> Johannes Sixt <j6t@kdbg.org> writes:
>>
>>> The icing on the cake would now be that
>>>
>>>     git branch --merged origin/main --forked origin/*
>>>
>>> provides the list of branches forked from origin that have already been
>>> integrated.
>>
>> Yup, that is very nice.  Also with "--merged" replaced with
>> "--not-merged", i.e., "our work building on top of origin's, and
>> still need to be finished", would give us a good list to work on.
> 
> This is nice, but I think this would require an overhaul of other
> infra as well, maybe better to do as a follow-up?
This can certainly be done as an extension in a follow-up patch. But the
UI must still be planned accordingly, i.e., --forked can only take a
single argument. For example, in

    git branch --forked foo bar

'bar' is the pattern of branches to show. The "list" is filtered
according to '--forked foo'. That is, if 'bar' was not forked from
'foo', the output is empty.

You would have to require

    git branch --forked foo --forked bar

to list all branches forked from 'foo' or 'bar'.

In the first implementation, you can restrict uses of other options with
--forked or even with a branch pattern. But you cannot be loose by
accepting multiple branch patterns with one --forked option, because
that would later clash with --list mode.

-- Hannes

Hi Harald

On 03/06/2026 10:04, Harald Nordgren via GitGitGadget wrote:
> From: Harald Nordgren <haraldnordgren@gmail.com>
> > 	git branch --prune-merged <branch>...

I'm not sure that synopsis is correct anymore as you need to repeat "--prune-merged". As --prune-merged now takes an argument there is no reason to forbid positional arguments so I think we should support

	git branch --prune-merged origin/master 'feature*'

to delete all the branches beginning with "feature" that have the upstream "origin/master" and have been merged.

I wonder about the name - the other options that delete branches are called "delete", not "prune". Also "--prune-merged" does not delete the branches listed by "--merged" so maybe "--delete-forked" would be better?

I've not commented in detail on the code as it will need to change a bit once we match on full refnames and do the filtering in apply_ref_filter() but I think the basics are sound.

I'll stop here - I did quickly scan the next two patches and they both looked like sensible ideas.

Thanks

Phillip

> deletes the local branches that "--forked <branch>" would list,
> restricted to those whose tip is reachable from their configured
> upstream: the work has already landed on the upstream they track,
> so the local copy is no longer needed.
> > Reachability is read from local refs; nothing is fetched. Users
> who want fresh upstream refs run "git fetch" first.
> > Three classes of branches are spared:
> >    * any branch checked out in any worktree;
>    * any branch whose upstream no longer resolves locally (its
>      disappearance is not, on its own, evidence of integration);
>    * any branch whose push destination equals its upstream
>      (<branch>@{push} == <branch>@{upstream}). Such a branch
>      cannot be distinguished from a freshly pulled trunk that
>      just looks "fully merged", e.g. local "main" tracking and
>      pushing to "origin/main" right after a pull. Only branches
>      that push somewhere other than their upstream (typically
>      topics in a fork-based workflow) are treated as candidates.
> > Deletion goes through the existing delete_branches() in warn-only
> mode and with the HEAD-fallback disabled: a branch that is not
> yet fully merged to its upstream is reported as a one-line warning
> and skipped, so a single un-mergeable topic does not abort the
> whole sweep. We only act on upstream-merged status.
> > Signed-off-by: Harald Nordgren <haraldnordgren@gmail.com>
> ---
>   Documentation/git-branch.adoc |  23 +++++
>   builtin/branch.c              | 117 +++++++++++++++++++--
>   t/t3200-branch.sh             | 188 ++++++++++++++++++++++++++++++++++
>   3 files changed, 318 insertions(+), 10 deletions(-)
> > diff --git a/Documentation/git-branch.adoc b/Documentation/git-branch.adoc
> index 8002d7f38c..f7942fcd7d 100644
> --- a/Documentation/git-branch.adoc
> +++ b/Documentation/git-branch.adoc
> @@ -25,6 +25,7 @@ git branch (-m|-M) [<old-branch>] <new-branch>
>   git branch (-c|-C) [<old-branch>] <new-branch>
>   git branch (-d|-D) [-r] <branch-name>...
>   git branch --edit-description [<branch-name>]
> +git branch (--prune-merged <branch>)...
>   >   DESCRIPTION
>   -----------
> @@ -206,6 +207,28 @@ This option is only applicable in non-verbose mode.
>   	`master`) or a shell-style glob (e.g. `'origin/*'`). The
>   	option can be repeated to widen the filter.
>   > +`--prune-merged <branch>`::
> +	Delete the local branches that `--forked` would list for the
> +	same _<branch>_, but only those whose tip is reachable from
> +	their configured upstream. In other words, the work on the
> +	branch has already landed on the upstream it tracks, so the
> +	local copy is no longer needed. May be given more than once to
> +	union the matches; positional arguments are not accepted.
> ++
> +Reachability is checked against whatever the upstream refs say
> +locally; nothing is fetched. Run `git fetch` first if you want
> +the upstream refs refreshed.
> ++
> +A branch is left alone if any of the following holds:
> +its upstream no longer resolves locally; it is checked out in any
> +worktree; or its push destination (`<branch>@{push}`) equals its
> +upstream (`<branch>@{upstream}`), so it cannot be distinguished
> +from a freshly pulled trunk that just looks "fully merged".
> ++
> +Branches refused by the "fully merged" safety check are listed as
> +warnings and skipped; pass them to `git branch -D` explicitly if
> +you want them gone.
> +
>   `-v`::
>   `-vv`::
>   `--verbose`::
> diff --git a/builtin/branch.c b/builtin/branch.c
> index 09afdd9257..736480b002 100644
> --- a/builtin/branch.c
> +++ b/builtin/branch.c
> @@ -39,6 +39,7 @@ static const char * const builtin_branch_usage[] = {
>   	N_("git branch [<options>] (-c | -C) [<old-branch>] <new-branch>"),
>   	N_("git branch [<options>] [-r | -a] [--points-at]"),
>   	N_("git branch [<options>] [-r | -a] [--format]"),
> +	N_("git branch [<options>] (--prune-merged <branch>)..."),
>   	NULL
>   };
>   > @@ -782,17 +783,13 @@ static int upstream_matches(const char *short_upstream,
>   	return 0;
>   }
>   > -static int branch_upstream_matches(const char *full_refname,
> +static int branch_upstream_matches(const char *short_branch_name,
>   				   const struct upstream_pattern *patterns,
>   				   size_t nr_patterns)
>   {
> -	const char *short_name;
> -	struct branch *branch;
> +	struct branch *branch = branch_get(short_branch_name);
>   	const char *upstream;
>   > -	if (!skip_prefix(full_refname, "refs/heads/", &short_name))
> -		return 0;
> -	branch = branch_get(short_name);
>   	if (!branch)
>   		return 0;
>   	upstream = branch_get_upstream(branch, NULL);
> @@ -813,8 +810,9 @@ static void filter_array_by_forked(struct ref_array *array,
>   >   	for (i = 0; i < array->nr; i++) {
>   		struct ref_array_item *item = array->items[i];
> -		if (branch_upstream_matches(item->refname,
> -					    patterns, nr_patterns))
> +		const char *short_name;
> +		if (skip_prefix(item->refname, "refs/heads/", &short_name) &&
> +		    branch_upstream_matches(short_name, patterns, nr_patterns))
>   			array->items[kept++] = item;
>   		else
>   			free_ref_array_item(item);
> @@ -824,6 +822,94 @@ static void filter_array_by_forked(struct ref_array *array,
>   	upstream_pattern_list_clear(patterns, nr_patterns);
>   }
>   > +struct forked_cb {
> +	const struct upstream_pattern *patterns;
> +	size_t nr_patterns;
> +	struct string_list *out;
> +};
> +
> +static int collect_forked_branch(const struct reference *ref, void *cb_data)
> +{
> +	struct forked_cb *cb = cb_data;
> +
> +	if (ref->flags & REF_ISSYMREF)
> +		return 0;
> +	if (branch_upstream_matches(ref->name, cb->patterns, cb->nr_patterns))
> +		string_list_append(cb->out, ref->name);
> +	return 0;
> +}
> +
> +static void collect_forked_set(const struct string_list *upstreams,
> +			       struct string_list *out)
> +{
> +	struct upstream_pattern *patterns = NULL;
> +	size_t nr_patterns = 0;
> +	struct forked_cb cb;
> +
> +	parse_forked_args(upstreams, &patterns, &nr_patterns);
> +	cb.patterns = patterns;
> +	cb.nr_patterns = nr_patterns;
> +	cb.out = out;
> +
> +	refs_for_each_branch_ref(get_main_ref_store(the_repository),
> +				 collect_forked_branch, &cb);
> +
> +	string_list_sort(out);
> +
> +	upstream_pattern_list_clear(patterns, nr_patterns);
> +}
> +
> +static int prune_merged_branches(const struct string_list *upstreams,
> +				 int quiet)
> +{
> +	struct ref_store *refs = get_main_ref_store(the_repository);
> +	struct string_list candidates = STRING_LIST_INIT_DUP;
> +	struct strvec deletable = STRVEC_INIT;
> +	struct string_list_item *item;
> +	int ret = 0;
> +
> +	if (!upstreams->nr)
> +		die(_("--prune-merged requires at least one <branch>"));
> +
> +	collect_forked_set(upstreams, &candidates);
> +
> +	for_each_string_list_item(item, &candidates) {
> +		const char *short_name = item->string;
> +		struct branch *branch = branch_get(short_name);
> +		const char *upstream, *push;
> +		struct strbuf full = STRBUF_INIT;
> +		int skip;
> +
> +		strbuf_addf(&full, "refs/heads/%s", short_name);
> +		skip = !!branch_checked_out(full.buf);
> +		strbuf_release(&full);
> +		if (skip)
> +			continue;
> +
> +		upstream = branch ? branch_get_upstream(branch, NULL) : NULL;
> +		if (!upstream || !refs_ref_exists(refs, upstream))
> +			continue;
> +		push = branch ? branch_get_push(branch, NULL) : NULL;
> +		if (!push || !strcmp(push, upstream))
> +			continue;
> +
> +		strvec_push(&deletable, short_name);
> +	}
> +
> +	if (deletable.nr)
> +		ret = delete_branches(deletable.nr, deletable.v,
> +				      0, /* force */
> +				      FILTER_REFS_BRANCHES,
> +				      quiet,
> +				      1, /* warn_only */
> +				      1, /* no_head_fallback */
> +				      0  /* dry_run */);
> +
> +	strvec_clear(&deletable);
> +	string_list_clear(&candidates, 0);
> +	return ret;
> +}
> +
>   static GIT_PATH_FUNC(edit_description, "EDIT_DESCRIPTION")
>   >   static int edit_branch_description(const char *branch_name)
> @@ -866,6 +952,7 @@ int cmd_branch(int argc,
>   	int delete = 0, rename = 0, copy = 0, list = 0,
>   	    unset_upstream = 0, show_current = 0, edit_description = 0;
>   	struct string_list forked_upstreams = STRING_LIST_INIT_DUP;
> +	struct string_list prune_merged_upstreams = STRING_LIST_INIT_DUP;
>   	const char *new_upstream = NULL;
>   	int noncreate_actions = 0;
>   	/* possible options */
> @@ -921,6 +1008,8 @@ int cmd_branch(int argc,
>   			 N_("edit the description for the branch")),
>   		OPT_STRING_LIST(0, "forked", &forked_upstreams, N_("branch"),
>   			N_("list local branches whose upstream matches <branch> (repeatable)")),
> +		OPT_STRING_LIST(0, "prune-merged", &prune_merged_upstreams, N_("branch"),
> +			N_("delete local branches whose upstream matches <branch> and is merged (repeatable)")),
>   		OPT__FORCE(&force, N_("force creation, move/rename, deletion"), PARSE_OPT_NOCOMPLETE),
>   		OPT_MERGED(&filter, N_("print only branches that are merged")),
>   		OPT_NO_MERGED(&filter, N_("print only branches that are not merged")),
> @@ -965,7 +1054,8 @@ int cmd_branch(int argc,
>   			     0);
>   >   	if (!delete && !rename && !copy && !edit_description && !new_upstream &&
> -	    !show_current && !unset_upstream && argc == 0)
> +	    !show_current && !unset_upstream && !prune_merged_upstreams.nr &&
> +	    argc == 0)
>   		list = 1;
>   >   	if (filter.with_commit || filter.no_commit ||
> @@ -975,7 +1065,7 @@ int cmd_branch(int argc,
>   >   	noncreate_actions = !!delete + !!rename + !!copy + !!new_upstream +
>   			    !!show_current + !!list + !!edit_description +
> -			    !!unset_upstream;
> +			    !!unset_upstream + !!prune_merged_upstreams.nr;
>   	if (noncreate_actions > 1)
>   		usage_with_options(builtin_branch_usage, options);
>   > @@ -1016,6 +1106,12 @@ int cmd_branch(int argc,
>   		ret = delete_branches(argc, argv, delete > 1, filter.kind,
>   				      quiet, 0, 0, 0);
>   		goto out;
> +	} else if (prune_merged_upstreams.nr) {
> +		if (argc)
> +			die(_("--prune-merged does not take positional arguments; "
> +			      "repeat --prune-merged for each <branch>"));
> +		ret = prune_merged_branches(&prune_merged_upstreams, quiet);
> +		goto out;
>   	} else if (show_current) {
>   		print_current_branch_name();
>   		ret = 0;
> @@ -1178,5 +1274,6 @@ int cmd_branch(int argc,
>   out:
>   	string_list_clear(&sorting_options, 0);
>   	string_list_clear(&forked_upstreams, 0);
> +	string_list_clear(&prune_merged_upstreams, 0);
>   	return ret;
>   }
> diff --git a/t/t3200-branch.sh b/t/t3200-branch.sh
> index 4e7deddc04..beb86987ad 100755
> --- a/t/t3200-branch.sh
> +++ b/t/t3200-branch.sh
> @@ -1809,4 +1809,192 @@ test_expect_success '--forked requires a value' '
>   	test_grep "requires a value" err
>   '
>   > +test_expect_success '--prune-merged: setup' '
> +	test_create_repo pm-upstream &&
> +	test_commit -C pm-upstream base &&
> +	git -C pm-upstream checkout -b next &&
> +	test_commit -C pm-upstream one-commit &&
> +	test_commit -C pm-upstream two-commit &&
> +	git -C pm-upstream branch one HEAD~ &&
> +	git -C pm-upstream branch two HEAD &&
> +	git -C pm-upstream branch wip main &&
> +	git -C pm-upstream checkout main &&
> +	test_create_repo pm-fork
> +'
> +
> +test_expect_success '--prune-merged deletes branches integrated into upstream' '
> +	test_when_finished "rm -rf pm-merged" &&
> +	git clone pm-upstream pm-merged &&
> +	git -C pm-merged remote add fork ../pm-fork &&
> +	test_config -C pm-merged remote.pushDefault fork &&
> +	test_config -C pm-merged push.default current &&
> +	git -C pm-merged branch one one-commit &&
> +	git -C pm-merged branch --set-upstream-to=origin/next one &&
> +	git -C pm-merged branch two two-commit &&
> +	git -C pm-merged branch --set-upstream-to=origin/next two &&
> +
> +	git -C pm-merged branch --prune-merged "origin/*" &&
> +
> +	test_must_fail git -C pm-merged rev-parse --verify refs/heads/one &&
> +	test_must_fail git -C pm-merged rev-parse --verify refs/heads/two
> +'
> +
> +test_expect_success '--prune-merged accepts a literal upstream' '
> +	test_when_finished "rm -rf pm-literal" &&
> +	git clone pm-upstream pm-literal &&
> +	git -C pm-literal remote add fork ../pm-fork &&
> +	test_config -C pm-literal remote.pushDefault fork &&
> +	test_config -C pm-literal push.default current &&
> +	git -C pm-literal branch one one-commit &&
> +	git -C pm-literal branch --set-upstream-to=origin/next one &&
> +
> +	git -C pm-literal branch --prune-merged origin/next &&
> +
> +	test_must_fail git -C pm-literal rev-parse --verify refs/heads/one
> +'
> +
> +test_expect_success '--prune-merged unions multiple <branch> arguments' '
> +	test_when_finished "rm -rf pm-union" &&
> +	git clone pm-upstream pm-union &&
> +	git -C pm-union remote add fork ../pm-fork &&
> +	test_config -C pm-union remote.pushDefault fork &&
> +	test_config -C pm-union push.default current &&
> +	git -C pm-union branch one one-commit &&
> +	git -C pm-union branch --set-upstream-to=origin/next one &&
> +	git -C pm-union branch two base &&
> +	git -C pm-union branch --set-upstream-to=origin/main two &&
> +	git -C pm-union checkout --detach &&
> +
> +	git -C pm-union branch --prune-merged origin/next --prune-merged origin/main &&
> +
> +	test_must_fail git -C pm-union rev-parse --verify refs/heads/one &&
> +	test_must_fail git -C pm-union rev-parse --verify refs/heads/two
> +'
> +
> +test_expect_success '--prune-merged accepts a local upstream' '
> +	test_when_finished "rm -rf pm-local" &&
> +	git clone pm-upstream pm-local &&
> +	git -C pm-local remote add fork ../pm-fork &&
> +	test_config -C pm-local remote.pushDefault fork &&
> +	test_config -C pm-local push.default current &&
> +	git -C pm-local checkout -b trunk &&
> +	git -C pm-local branch one one-commit &&
> +	git -C pm-local branch --set-upstream-to=trunk one &&
> +	git -C pm-local merge --ff-only one-commit &&
> +
> +	git -C pm-local branch --prune-merged trunk &&
> +
> +	test_must_fail git -C pm-local rev-parse --verify refs/heads/one
> +'
> +
> +test_expect_success '--prune-merged warns instead of erroring on un-integrated commits' '
> +	test_when_finished "rm -rf pm-unmerged" &&
> +	git clone pm-upstream pm-unmerged &&
> +	git -C pm-unmerged remote add fork ../pm-fork &&
> +	test_config -C pm-unmerged remote.pushDefault fork &&
> +	test_config -C pm-unmerged push.default current &&
> +	git -C pm-unmerged checkout -b wip origin/wip &&
> +	git -C pm-unmerged branch --set-upstream-to=origin/next wip &&
> +	test_commit -C pm-unmerged local-only &&
> +	git -C pm-unmerged checkout - &&
> +
> +	git -C pm-unmerged branch --prune-merged "origin/*" 2>err &&
> +	test_grep "not fully merged" err &&
> +	test_grep ! "If you are sure you want to delete it" err &&
> +	git -C pm-unmerged rev-parse --verify refs/heads/wip
> +'
> +
> +test_expect_success '--prune-merged is silent about not-merged-to-HEAD' '
> +	test_when_finished "rm -rf pm-nohead" &&
> +	git clone pm-upstream pm-nohead &&
> +	git -C pm-nohead remote add fork ../pm-fork &&
> +	test_config -C pm-nohead remote.pushDefault fork &&
> +	test_config -C pm-nohead push.default current &&
> +	git -C pm-nohead branch topic one-commit &&
> +	git -C pm-nohead branch --set-upstream-to=origin/next topic &&
> +
> +	git -C pm-nohead branch --prune-merged "origin/*" 2>err &&
> +
> +	test_grep ! "not yet merged to HEAD" err &&
> +	test_must_fail git -C pm-nohead rev-parse --verify refs/heads/topic
> +'
> +
> +test_expect_success '--prune-merged skips branches whose upstream is gone' '
> +	test_when_finished "rm -rf pm-upstream-gone" &&
> +	git clone pm-upstream pm-upstream-gone &&
> +	git -C pm-upstream-gone remote add fork ../pm-fork &&
> +	test_config -C pm-upstream-gone remote.pushDefault fork &&
> +	test_config -C pm-upstream-gone push.default current &&
> +	git -C pm-upstream-gone branch one one-commit &&
> +	git -C pm-upstream-gone branch --set-upstream-to=origin/next one &&
> +
> +	git -C pm-upstream-gone update-ref -d refs/remotes/origin/next &&
> +	git -C pm-upstream-gone branch --prune-merged "origin/*" &&
> +
> +	git -C pm-upstream-gone rev-parse --verify refs/heads/one
> +'
> +
> +test_expect_success '--prune-merged never deletes the checked-out branch' '
> +	test_when_finished "rm -rf pm-head" &&
> +	git clone pm-upstream pm-head &&
> +	git -C pm-head remote add fork ../pm-fork &&
> +	test_config -C pm-head remote.pushDefault fork &&
> +	test_config -C pm-head push.default current &&
> +	git -C pm-head checkout -b one one-commit &&
> +	git -C pm-head branch --set-upstream-to=origin/next one &&
> +
> +	git -C pm-head branch --prune-merged "origin/*" &&
> +
> +	git -C pm-head rev-parse --verify refs/heads/one
> +'
> +
> +test_expect_success '--prune-merged spares branches that push back to their upstream' '
> +	test_when_finished "rm -rf pm-push-eq" &&
> +	git clone pm-upstream pm-push-eq &&
> +	git -C pm-push-eq checkout --detach &&
> +
> +	git -C pm-push-eq branch --prune-merged "origin/*" &&
> +
> +	git -C pm-push-eq rev-parse --verify refs/heads/main
> +'
> +
> +test_expect_success '--prune-merged spares a per-branch pushRemote==upstream remote' '
> +	test_when_finished "rm -rf pm-push-branch" &&
> +	git clone pm-upstream pm-push-branch &&
> +	git -C pm-push-branch remote add fork ../pm-fork &&
> +	test_config -C pm-push-branch remote.pushDefault fork &&
> +	test_config -C pm-push-branch push.default current &&
> +	test_config -C pm-push-branch branch.main.pushRemote origin &&
> +	git -C pm-push-branch checkout --detach &&
> +
> +	git -C pm-push-branch branch --prune-merged "origin/*" &&
> +
> +	git -C pm-push-branch rev-parse --verify refs/heads/main
> +'
> +
> +test_expect_success '--prune-merged prunes when @{push} differs from @{upstream}' '
> +	test_when_finished "rm -rf pm-push-diff" &&
> +	git clone pm-upstream pm-push-diff &&
> +	git -C pm-push-diff remote add fork ../pm-fork &&
> +	test_config -C pm-push-diff remote.pushDefault fork &&
> +	test_config -C pm-push-diff push.default current &&
> +	git -C pm-push-diff branch topic one-commit &&
> +	git -C pm-push-diff branch --set-upstream-to=origin/next topic &&
> +	git -C pm-push-diff checkout --detach &&
> +
> +	git -C pm-push-diff branch --prune-merged "origin/*" &&
> +
> +	test_must_fail git -C pm-push-diff rev-parse --verify refs/heads/topic
> +'
> +
> +test_expect_success '--prune-merged requires a value' '
> +	test_must_fail git -C forked branch --prune-merged 2>err &&
> +	test_grep "requires a value" err
> +'
> +
> +test_expect_success '--prune-merged rejects positional arguments' '
> +	test_must_fail git -C forked branch --prune-merged origin/one other/foreign 2>err &&
> +	test_grep "does not take positional arguments" err
> +'
> +
>   test_done

On 05/06/2026 14:50, Phillip Wood wrote:
> > I wonder about the name - the other options that delete branches are > called "delete", not "prune". Also "--prune-merged" does not delete the > branches listed by "--merged" so maybe "--delete-forked" would be better?

"delete-forked" doesn't capture the fact the branch has been merged though - I wonder if anyone has a better idea

Thanks

Phillip
> I've not commented in detail on the code as it will need to change a bit > once we match on full refnames and do the filtering in > apply_ref_filter() but I think the basics are sound.
> > I'll stop here - I did quickly scan the next two patches and they both > looked like sensible ideas.
> > Thanks
> > Phillip
> >> deletes the local branches that "--forked <branch>" would list,
>> restricted to those whose tip is reachable from their configured
>> upstream: the work has already landed on the upstream they track,
>> so the local copy is no longer needed.
>>
>> Reachability is read from local refs; nothing is fetched. Users
>> who want fresh upstream refs run "git fetch" first.
>>
>> Three classes of branches are spared:
>>
>>    * any branch checked out in any worktree;
>>    * any branch whose upstream no longer resolves locally (its
>>      disappearance is not, on its own, evidence of integration);
>>    * any branch whose push destination equals its upstream
>>      (<branch>@{push} == <branch>@{upstream}). Such a branch
>>      cannot be distinguished from a freshly pulled trunk that
>>      just looks "fully merged", e.g. local "main" tracking and
>>      pushing to "origin/main" right after a pull. Only branches
>>      that push somewhere other than their upstream (typically
>>      topics in a fork-based workflow) are treated as candidates.
>>
>> Deletion goes through the existing delete_branches() in warn-only
>> mode and with the HEAD-fallback disabled: a branch that is not
>> yet fully merged to its upstream is reported as a one-line warning
>> and skipped, so a single un-mergeable topic does not abort the
>> whole sweep. We only act on upstream-merged status.
>>
>> Signed-off-by: Harald Nordgren <haraldnordgren@gmail.com>
>> ---
>>   Documentation/git-branch.adoc |  23 +++++
>>   builtin/branch.c              | 117 +++++++++++++++++++--
>>   t/t3200-branch.sh             | 188 ++++++++++++++++++++++++++++++++++
>>   3 files changed, 318 insertions(+), 10 deletions(-)
>>
>> diff --git a/Documentation/git-branch.adoc b/Documentation/git- >> branch.adoc
>> index 8002d7f38c..f7942fcd7d 100644
>> --- a/Documentation/git-branch.adoc
>> +++ b/Documentation/git-branch.adoc
>> @@ -25,6 +25,7 @@ git branch (-m|-M) [<old-branch>] <new-branch>
>>   git branch (-c|-C) [<old-branch>] <new-branch>
>>   git branch (-d|-D) [-r] <branch-name>...
>>   git branch --edit-description [<branch-name>]
>> +git branch (--prune-merged <branch>)...
>>   DESCRIPTION
>>   -----------
>> @@ -206,6 +207,28 @@ This option is only applicable in non-verbose mode.
>>       `master`) or a shell-style glob (e.g. `'origin/*'`). The
>>       option can be repeated to widen the filter.
>> +`--prune-merged <branch>`::
>> +    Delete the local branches that `--forked` would list for the
>> +    same _<branch>_, but only those whose tip is reachable from
>> +    their configured upstream. In other words, the work on the
>> +    branch has already landed on the upstream it tracks, so the
>> +    local copy is no longer needed. May be given more than once to
>> +    union the matches; positional arguments are not accepted.
>> ++
>> +Reachability is checked against whatever the upstream refs say
>> +locally; nothing is fetched. Run `git fetch` first if you want
>> +the upstream refs refreshed.
>> ++
>> +A branch is left alone if any of the following holds:
>> +its upstream no longer resolves locally; it is checked out in any
>> +worktree; or its push destination (`<branch>@{push}`) equals its
>> +upstream (`<branch>@{upstream}`), so it cannot be distinguished
>> +from a freshly pulled trunk that just looks "fully merged".
>> ++
>> +Branches refused by the "fully merged" safety check are listed as
>> +warnings and skipped; pass them to `git branch -D` explicitly if
>> +you want them gone.
>> +
>>   `-v`::
>>   `-vv`::
>>   `--verbose`::
>> diff --git a/builtin/branch.c b/builtin/branch.c
>> index 09afdd9257..736480b002 100644
>> --- a/builtin/branch.c
>> +++ b/builtin/branch.c
>> @@ -39,6 +39,7 @@ static const char * const builtin_branch_usage[] = {
>>       N_("git branch [<options>] (-c | -C) [<old-branch>] <new-branch>"),
>>       N_("git branch [<options>] [-r | -a] [--points-at]"),
>>       N_("git branch [<options>] [-r | -a] [--format]"),
>> +    N_("git branch [<options>] (--prune-merged <branch>)..."),
>>       NULL
>>   };
>> @@ -782,17 +783,13 @@ static int upstream_matches(const char >> *short_upstream,
>>       return 0;
>>   }
>> -static int branch_upstream_matches(const char *full_refname,
>> +static int branch_upstream_matches(const char *short_branch_name,
>>                      const struct upstream_pattern *patterns,
>>                      size_t nr_patterns)
>>   {
>> -    const char *short_name;
>> -    struct branch *branch;
>> +    struct branch *branch = branch_get(short_branch_name);
>>       const char *upstream;
>> -    if (!skip_prefix(full_refname, "refs/heads/", &short_name))
>> -        return 0;
>> -    branch = branch_get(short_name);
>>       if (!branch)
>>           return 0;
>>       upstream = branch_get_upstream(branch, NULL);
>> @@ -813,8 +810,9 @@ static void filter_array_by_forked(struct >> ref_array *array,
>>       for (i = 0; i < array->nr; i++) {
>>           struct ref_array_item *item = array->items[i];
>> -        if (branch_upstream_matches(item->refname,
>> -                        patterns, nr_patterns))
>> +        const char *short_name;
>> +        if (skip_prefix(item->refname, "refs/heads/", &short_name) &&
>> +            branch_upstream_matches(short_name, patterns, nr_patterns))
>>               array->items[kept++] = item;
>>           else
>>               free_ref_array_item(item);
>> @@ -824,6 +822,94 @@ static void filter_array_by_forked(struct >> ref_array *array,
>>       upstream_pattern_list_clear(patterns, nr_patterns);
>>   }
>> +struct forked_cb {
>> +    const struct upstream_pattern *patterns;
>> +    size_t nr_patterns;
>> +    struct string_list *out;
>> +};
>> +
>> +static int collect_forked_branch(const struct reference *ref, void >> *cb_data)
>> +{
>> +    struct forked_cb *cb = cb_data;
>> +
>> +    if (ref->flags & REF_ISSYMREF)
>> +        return 0;
>> +    if (branch_upstream_matches(ref->name, cb->patterns, cb- >> >nr_patterns))
>> +        string_list_append(cb->out, ref->name);
>> +    return 0;
>> +}
>> +
>> +static void collect_forked_set(const struct string_list *upstreams,
>> +                   struct string_list *out)
>> +{
>> +    struct upstream_pattern *patterns = NULL;
>> +    size_t nr_patterns = 0;
>> +    struct forked_cb cb;
>> +
>> +    parse_forked_args(upstreams, &patterns, &nr_patterns);
>> +    cb.patterns = patterns;
>> +    cb.nr_patterns = nr_patterns;
>> +    cb.out = out;
>> +
>> +    refs_for_each_branch_ref(get_main_ref_store(the_repository),
>> +                 collect_forked_branch, &cb);
>> +
>> +    string_list_sort(out);
>> +
>> +    upstream_pattern_list_clear(patterns, nr_patterns);
>> +}
>> +
>> +static int prune_merged_branches(const struct string_list *upstreams,
>> +                 int quiet)
>> +{
>> +    struct ref_store *refs = get_main_ref_store(the_repository);
>> +    struct string_list candidates = STRING_LIST_INIT_DUP;
>> +    struct strvec deletable = STRVEC_INIT;
>> +    struct string_list_item *item;
>> +    int ret = 0;
>> +
>> +    if (!upstreams->nr)
>> +        die(_("--prune-merged requires at least one <branch>"));
>> +
>> +    collect_forked_set(upstreams, &candidates);
>> +
>> +    for_each_string_list_item(item, &candidates) {
>> +        const char *short_name = item->string;
>> +        struct branch *branch = branch_get(short_name);
>> +        const char *upstream, *push;
>> +        struct strbuf full = STRBUF_INIT;
>> +        int skip;
>> +
>> +        strbuf_addf(&full, "refs/heads/%s", short_name);
>> +        skip = !!branch_checked_out(full.buf);
>> +        strbuf_release(&full);
>> +        if (skip)
>> +            continue;
>> +
>> +        upstream = branch ? branch_get_upstream(branch, NULL) : NULL;
>> +        if (!upstream || !refs_ref_exists(refs, upstream))
>> +            continue;
>> +        push = branch ? branch_get_push(branch, NULL) : NULL;
>> +        if (!push || !strcmp(push, upstream))
>> +            continue;
>> +
>> +        strvec_push(&deletable, short_name);
>> +    }
>> +
>> +    if (deletable.nr)
>> +        ret = delete_branches(deletable.nr, deletable.v,
>> +                      0, /* force */
>> +                      FILTER_REFS_BRANCHES,
>> +                      quiet,
>> +                      1, /* warn_only */
>> +                      1, /* no_head_fallback */
>> +                      0  /* dry_run */);
>> +
>> +    strvec_clear(&deletable);
>> +    string_list_clear(&candidates, 0);
>> +    return ret;
>> +}
>> +
>>   static GIT_PATH_FUNC(edit_description, "EDIT_DESCRIPTION")
>>   static int edit_branch_description(const char *branch_name)
>> @@ -866,6 +952,7 @@ int cmd_branch(int argc,
>>       int delete = 0, rename = 0, copy = 0, list = 0,
>>           unset_upstream = 0, show_current = 0, edit_description = 0;
>>       struct string_list forked_upstreams = STRING_LIST_INIT_DUP;
>> +    struct string_list prune_merged_upstreams = STRING_LIST_INIT_DUP;
>>       const char *new_upstream = NULL;
>>       int noncreate_actions = 0;
>>       /* possible options */
>> @@ -921,6 +1008,8 @@ int cmd_branch(int argc,
>>                N_("edit the description for the branch")),
>>           OPT_STRING_LIST(0, "forked", &forked_upstreams, N_("branch"),
>>               N_("list local branches whose upstream matches <branch> >> (repeatable)")),
>> +        OPT_STRING_LIST(0, "prune-merged", &prune_merged_upstreams, >> N_("branch"),
>> +            N_("delete local branches whose upstream matches <branch> >> and is merged (repeatable)")),
>>           OPT__FORCE(&force, N_("force creation, move/rename, >> deletion"), PARSE_OPT_NOCOMPLETE),
>>           OPT_MERGED(&filter, N_("print only branches that are merged")),
>>           OPT_NO_MERGED(&filter, N_("print only branches that are not >> merged")),
>> @@ -965,7 +1054,8 @@ int cmd_branch(int argc,
>>                    0);
>>       if (!delete && !rename && !copy && !edit_description && ! >> new_upstream &&
>> -        !show_current && !unset_upstream && argc == 0)
>> +        !show_current && !unset_upstream && ! >> prune_merged_upstreams.nr &&
>> +        argc == 0)
>>           list = 1;
>>       if (filter.with_commit || filter.no_commit ||
>> @@ -975,7 +1065,7 @@ int cmd_branch(int argc,
>>       noncreate_actions = !!delete + !!rename + !!copy + !!new_upstream +
>>                   !!show_current + !!list + !!edit_description +
>> -                !!unset_upstream;
>> +                !!unset_upstream + !!prune_merged_upstreams.nr;
>>       if (noncreate_actions > 1)
>>           usage_with_options(builtin_branch_usage, options);
>> @@ -1016,6 +1106,12 @@ int cmd_branch(int argc,
>>           ret = delete_branches(argc, argv, delete > 1, filter.kind,
>>                         quiet, 0, 0, 0);
>>           goto out;
>> +    } else if (prune_merged_upstreams.nr) {
>> +        if (argc)
>> +            die(_("--prune-merged does not take positional arguments; "
>> +                  "repeat --prune-merged for each <branch>"));
>> +        ret = prune_merged_branches(&prune_merged_upstreams, quiet);
>> +        goto out;
>>       } else if (show_current) {
>>           print_current_branch_name();
>>           ret = 0;
>> @@ -1178,5 +1274,6 @@ int cmd_branch(int argc,
>>   out:
>>       string_list_clear(&sorting_options, 0);
>>       string_list_clear(&forked_upstreams, 0);
>> +    string_list_clear(&prune_merged_upstreams, 0);
>>       return ret;
>>   }
>> diff --git a/t/t3200-branch.sh b/t/t3200-branch.sh
>> index 4e7deddc04..beb86987ad 100755
>> --- a/t/t3200-branch.sh
>> +++ b/t/t3200-branch.sh
>> @@ -1809,4 +1809,192 @@ test_expect_success '--forked requires a value' '
>>       test_grep "requires a value" err
>>   '
>> +test_expect_success '--prune-merged: setup' '
>> +    test_create_repo pm-upstream &&
>> +    test_commit -C pm-upstream base &&
>> +    git -C pm-upstream checkout -b next &&
>> +    test_commit -C pm-upstream one-commit &&
>> +    test_commit -C pm-upstream two-commit &&
>> +    git -C pm-upstream branch one HEAD~ &&
>> +    git -C pm-upstream branch two HEAD &&
>> +    git -C pm-upstream branch wip main &&
>> +    git -C pm-upstream checkout main &&
>> +    test_create_repo pm-fork
>> +'
>> +
>> +test_expect_success '--prune-merged deletes branches integrated into >> upstream' '
>> +    test_when_finished "rm -rf pm-merged" &&
>> +    git clone pm-upstream pm-merged &&
>> +    git -C pm-merged remote add fork ../pm-fork &&
>> +    test_config -C pm-merged remote.pushDefault fork &&
>> +    test_config -C pm-merged push.default current &&
>> +    git -C pm-merged branch one one-commit &&
>> +    git -C pm-merged branch --set-upstream-to=origin/next one &&
>> +    git -C pm-merged branch two two-commit &&
>> +    git -C pm-merged branch --set-upstream-to=origin/next two &&
>> +
>> +    git -C pm-merged branch --prune-merged "origin/*" &&
>> +
>> +    test_must_fail git -C pm-merged rev-parse --verify refs/heads/one &&
>> +    test_must_fail git -C pm-merged rev-parse --verify refs/heads/two
>> +'
>> +
>> +test_expect_success '--prune-merged accepts a literal upstream' '
>> +    test_when_finished "rm -rf pm-literal" &&
>> +    git clone pm-upstream pm-literal &&
>> +    git -C pm-literal remote add fork ../pm-fork &&
>> +    test_config -C pm-literal remote.pushDefault fork &&
>> +    test_config -C pm-literal push.default current &&
>> +    git -C pm-literal branch one one-commit &&
>> +    git -C pm-literal branch --set-upstream-to=origin/next one &&
>> +
>> +    git -C pm-literal branch --prune-merged origin/next &&
>> +
>> +    test_must_fail git -C pm-literal rev-parse --verify refs/heads/one
>> +'
>> +
>> +test_expect_success '--prune-merged unions multiple <branch> >> arguments' '
>> +    test_when_finished "rm -rf pm-union" &&
>> +    git clone pm-upstream pm-union &&
>> +    git -C pm-union remote add fork ../pm-fork &&
>> +    test_config -C pm-union remote.pushDefault fork &&
>> +    test_config -C pm-union push.default current &&
>> +    git -C pm-union branch one one-commit &&
>> +    git -C pm-union branch --set-upstream-to=origin/next one &&
>> +    git -C pm-union branch two base &&
>> +    git -C pm-union branch --set-upstream-to=origin/main two &&
>> +    git -C pm-union checkout --detach &&
>> +
>> +    git -C pm-union branch --prune-merged origin/next --prune-merged >> origin/main &&
>> +
>> +    test_must_fail git -C pm-union rev-parse --verify refs/heads/one &&
>> +    test_must_fail git -C pm-union rev-parse --verify refs/heads/two
>> +'
>> +
>> +test_expect_success '--prune-merged accepts a local upstream' '
>> +    test_when_finished "rm -rf pm-local" &&
>> +    git clone pm-upstream pm-local &&
>> +    git -C pm-local remote add fork ../pm-fork &&
>> +    test_config -C pm-local remote.pushDefault fork &&
>> +    test_config -C pm-local push.default current &&
>> +    git -C pm-local checkout -b trunk &&
>> +    git -C pm-local branch one one-commit &&
>> +    git -C pm-local branch --set-upstream-to=trunk one &&
>> +    git -C pm-local merge --ff-only one-commit &&
>> +
>> +    git -C pm-local branch --prune-merged trunk &&
>> +
>> +    test_must_fail git -C pm-local rev-parse --verify refs/heads/one
>> +'
>> +
>> +test_expect_success '--prune-merged warns instead of erroring on un- >> integrated commits' '
>> +    test_when_finished "rm -rf pm-unmerged" &&
>> +    git clone pm-upstream pm-unmerged &&
>> +    git -C pm-unmerged remote add fork ../pm-fork &&
>> +    test_config -C pm-unmerged remote.pushDefault fork &&
>> +    test_config -C pm-unmerged push.default current &&
>> +    git -C pm-unmerged checkout -b wip origin/wip &&
>> +    git -C pm-unmerged branch --set-upstream-to=origin/next wip &&
>> +    test_commit -C pm-unmerged local-only &&
>> +    git -C pm-unmerged checkout - &&
>> +
>> +    git -C pm-unmerged branch --prune-merged "origin/*" 2>err &&
>> +    test_grep "not fully merged" err &&
>> +    test_grep ! "If you are sure you want to delete it" err &&
>> +    git -C pm-unmerged rev-parse --verify refs/heads/wip
>> +'
>> +
>> +test_expect_success '--prune-merged is silent about not-merged-to- >> HEAD' '
>> +    test_when_finished "rm -rf pm-nohead" &&
>> +    git clone pm-upstream pm-nohead &&
>> +    git -C pm-nohead remote add fork ../pm-fork &&
>> +    test_config -C pm-nohead remote.pushDefault fork &&
>> +    test_config -C pm-nohead push.default current &&
>> +    git -C pm-nohead branch topic one-commit &&
>> +    git -C pm-nohead branch --set-upstream-to=origin/next topic &&
>> +
>> +    git -C pm-nohead branch --prune-merged "origin/*" 2>err &&
>> +
>> +    test_grep ! "not yet merged to HEAD" err &&
>> +    test_must_fail git -C pm-nohead rev-parse --verify refs/heads/topic
>> +'
>> +
>> +test_expect_success '--prune-merged skips branches whose upstream is >> gone' '
>> +    test_when_finished "rm -rf pm-upstream-gone" &&
>> +    git clone pm-upstream pm-upstream-gone &&
>> +    git -C pm-upstream-gone remote add fork ../pm-fork &&
>> +    test_config -C pm-upstream-gone remote.pushDefault fork &&
>> +    test_config -C pm-upstream-gone push.default current &&
>> +    git -C pm-upstream-gone branch one one-commit &&
>> +    git -C pm-upstream-gone branch --set-upstream-to=origin/next one &&
>> +
>> +    git -C pm-upstream-gone update-ref -d refs/remotes/origin/next &&
>> +    git -C pm-upstream-gone branch --prune-merged "origin/*" &&
>> +
>> +    git -C pm-upstream-gone rev-parse --verify refs/heads/one
>> +'
>> +
>> +test_expect_success '--prune-merged never deletes the checked-out >> branch' '
>> +    test_when_finished "rm -rf pm-head" &&
>> +    git clone pm-upstream pm-head &&
>> +    git -C pm-head remote add fork ../pm-fork &&
>> +    test_config -C pm-head remote.pushDefault fork &&
>> +    test_config -C pm-head push.default current &&
>> +    git -C pm-head checkout -b one one-commit &&
>> +    git -C pm-head branch --set-upstream-to=origin/next one &&
>> +
>> +    git -C pm-head branch --prune-merged "origin/*" &&
>> +
>> +    git -C pm-head rev-parse --verify refs/heads/one
>> +'
>> +
>> +test_expect_success '--prune-merged spares branches that push back to >> their upstream' '
>> +    test_when_finished "rm -rf pm-push-eq" &&
>> +    git clone pm-upstream pm-push-eq &&
>> +    git -C pm-push-eq checkout --detach &&
>> +
>> +    git -C pm-push-eq branch --prune-merged "origin/*" &&
>> +
>> +    git -C pm-push-eq rev-parse --verify refs/heads/main
>> +'
>> +
>> +test_expect_success '--prune-merged spares a per-branch >> pushRemote==upstream remote' '
>> +    test_when_finished "rm -rf pm-push-branch" &&
>> +    git clone pm-upstream pm-push-branch &&
>> +    git -C pm-push-branch remote add fork ../pm-fork &&
>> +    test_config -C pm-push-branch remote.pushDefault fork &&
>> +    test_config -C pm-push-branch push.default current &&
>> +    test_config -C pm-push-branch branch.main.pushRemote origin &&
>> +    git -C pm-push-branch checkout --detach &&
>> +
>> +    git -C pm-push-branch branch --prune-merged "origin/*" &&
>> +
>> +    git -C pm-push-branch rev-parse --verify refs/heads/main
>> +'
>> +
>> +test_expect_success '--prune-merged prunes when @{push} differs from >> @{upstream}' '
>> +    test_when_finished "rm -rf pm-push-diff" &&
>> +    git clone pm-upstream pm-push-diff &&
>> +    git -C pm-push-diff remote add fork ../pm-fork &&
>> +    test_config -C pm-push-diff remote.pushDefault fork &&
>> +    test_config -C pm-push-diff push.default current &&
>> +    git -C pm-push-diff branch topic one-commit &&
>> +    git -C pm-push-diff branch --set-upstream-to=origin/next topic &&
>> +    git -C pm-push-diff checkout --detach &&
>> +
>> +    git -C pm-push-diff branch --prune-merged "origin/*" &&
>> +
>> +    test_must_fail git -C pm-push-diff rev-parse --verify refs/heads/ >> topic
>> +'
>> +
>> +test_expect_success '--prune-merged requires a value' '
>> +    test_must_fail git -C forked branch --prune-merged 2>err &&
>> +    test_grep "requires a value" err
>> +'
>> +
>> +test_expect_success '--prune-merged rejects positional arguments' '
>> +    test_must_fail git -C forked branch --prune-merged origin/one >> other/foreign 2>err &&
>> +    test_grep "does not take positional arguments" err
>> +'
>> +
>>   test_done
> 

Hi Harald

On 09/06/2026 11:11, Harald Nordgren via GitGitGadget wrote:
> From: Harald Nordgren <haraldnordgren@gmail.com>
> > 	git branch --prune-merged <branch>...

Please see my comments on the previous version about the naming of this option. I really think we need to start a discussion to find a better name for this option as the other options to delete a branch are named "delete" rather than "prune" and this does not remove the branches listed by "--merge"

> deletes the local branches that "--forked <branch>" would list,
> keeping only those whose tip is reachable from their configured
> upstream: the work has already landed on the upstream they track,
> so the local copy is no longer needed.
> > Reachability is read from local refs; nothing is fetched. Run
> "git fetch" first if you want fresh upstream refs.

I don't  think this sentence adds anything - git never fetches unless the user explicitly asks it to.

> > Three kinds of branches are spared:
> >    * any branch checked out in any worktree;
>    * any branch whose upstream no longer resolves locally, since a
>      missing upstream is not by itself a sign of integration;
>    * any branch whose push destination equals its upstream
>      (<branch>@{push} is the same as <branch>@{upstream}), such as
>      a local "main" that tracks and pushes to "origin/main". Right
>      after a pull it just looks "fully merged", so it is left
>      alone. Only branches that push somewhere other than their
>      upstream, typically topics in a fork workflow, are candidates.
> > Branches that are not yet merged into their upstream are reported
> as a short warning and skipped, so one unmerged topic does not
> abort the whole sweep.

I'm not sure about this warning - the user has asked us to delete the branches whose upstreams match those passed on the commandline and that have been merged so do they really want to hear about the ones that have not been merged? It might be useful to have a way to list those that have not been merged in the future.

> Signed-off-by: Harald Nordgren <haraldnordgren@gmail.com>
> ---
>   Documentation/git-branch.adoc |  24 ++++
>   builtin/branch.c              |  67 +++++++++++-
>   t/t3200-branch.sh             | 201 ++++++++++++++++++++++++++++++++++
>   3 files changed, 290 insertions(+), 2 deletions(-)
> > diff --git a/Documentation/git-branch.adoc b/Documentation/git-branch.adoc
> index 62ebab6051..fdaccc9662 100644
> --- a/Documentation/git-branch.adoc
> +++ b/Documentation/git-branch.adoc
> @@ -25,6 +25,7 @@ git branch (-m|-M) [<old-branch>] <new-branch>
>   git branch (-c|-C) [<old-branch>] <new-branch>
>   git branch (-d|-D) [-r] <branch-name>...
>   git branch --edit-description [<branch-name>]
> +git branch --prune-merged <branch>...
>   >   DESCRIPTION
>   -----------
> @@ -201,6 +202,29 @@ This option is only applicable in non-verbose mode.
>   	Print the name of the current branch. In detached `HEAD` state,
>   	nothing is printed.
>   > +`--prune-merged <branch>...`::
> +	Delete the local branches that `--forked` would list for the
> +	given _<branch>_ arguments, but only those whose tip is
> +	reachable from their configured upstream. In other words, the
> +	work on the branch has already landed on the upstream it
> +	tracks, so the local copy is no longer needed. Several
> +	_<branch>_ patterns may be given, e.g. `git branch
> +	--prune-merged origin/main 'feature*'`.
> ++
> +Reachability is checked against whatever the upstream refs say
> +locally; nothing is fetched. Run `git fetch` first if you want
> +the upstream refs refreshed.
Maybe

Reachability is checked against the remote-tracking branch. Run `git fetch` first if you want update the remote-tracking branch.

> ++
> +A branch is left alone if any of the following holds:

s/left alone/not deleted/

> +its upstream no longer resolves locally; it is checked out in any

s/upstream no longer resolves locally/upstream remote-tracking branch no longer exists/

> +worktree; or its push destination (`<branch>@{push}`) equals its
> +upstream (`<branch>@{upstream}`), so it cannot be distinguished
> +from a freshly pulled trunk that just looks "fully merged".

What's a "freshly pulled trunk"? "trunk" does not appear in gitglossary(7)

> ++
> +Branches refused by the "fully merged" safety check are listed as
> +warnings and skipped; pass them to `git branch -D` explicitly if
> +you want them gone.

s/them gone/to delete them/

> +
>   `-v`::
>   `-vv`::
>   `--verbose`::
> diff --git a/builtin/branch.c b/builtin/branch.c
> index 2cc5a8cde0..af37a0ceb7 100644
> --- a/builtin/branch.c
> +++ b/builtin/branch.c
> @@ -38,6 +38,7 @@ static const char * const builtin_branch_usage[] = {
>   	N_("git branch [<options>] (-c | -C) [<old-branch>] <new-branch>"),
>   	N_("git branch [<options>] [-r | -a] [--points-at]"),
>   	N_("git branch [<options>] [-r | -a] [--format]"),
> +	N_("git branch [<options>] --prune-merged <branch>..."),
>   	NULL
>   };
>   > @@ -715,6 +716,61 @@ static int parse_opt_forked(const struct option *opt, const char *arg, int unset
>   	return 0;
>   }
>   > +static int prune_merged_branches(int argc, const char **argv,
> +				 int quiet)
> +{
> +	struct ref_store *refs = get_main_ref_store(the_repository);
> +	struct ref_filter filter = REF_FILTER_INIT;
> +	struct ref_array candidates;
> +	struct strvec deletable = STRVEC_INIT;
> +	int i, ret = 0;
> +
> +	if (!argc)
> +		die(_("--prune-merged requires at least one <branch>"));
> +
> +	for (i = 0; i < argc; i++)
> +		if (ref_filter_forked_add(&filter, argv[i]) < 0)
> +			die(_("'%s' is not a valid branch or pattern"), argv[i]);
> +
> +	filter.kind = FILTER_REFS_BRANCHES;
> +	memset(&candidates, 0, sizeof(candidates));

It would be nicer to add "= { 0 }" to the declaration of candidates above.

> +	filter_refs(&candidates, &filter, filter.kind);
> +
> +	for (i = 0; i < candidates.nr; i++) {
> +		const char *full_name = candidates.items[i]->refname;
> +		const char *short_name;
> +		struct branch *branch;
> +		const char *upstream, *push;
> +
> +		if (!skip_prefix(full_name, "refs/heads/", &short_name))
> +			continue;

If we've set filter.kind = FILTER_REFS_BRANCHS how can this condition fail?

> +		if (branch_checked_out(full_name))
> +			continue;
> +
> +		branch = branch_get(short_name);
> +		upstream = branch ? branch_get_upstream(branch, NULL) : NULL;

How can branch be NULL? Don't we require branch_get() to succeed in order to filter it?

> +		if (!upstream || !refs_ref_exists(refs, upstream))
> +			continue;
> +		push = branch ? branch_get_push(branch, NULL) : NULL;
> +		if (!push || !strcmp(push, upstream))
> +			continue;

By the time we've reached this point we know that branch@{upstream}exists and does not match branch@{push} - good

> +		strvec_push(&deletable, short_name);
> +	}
> +
> +	if (deletable.nr)
> +		ret = delete_branches(deletable.nr, deletable.v,
> +				      FILTER_REFS_BRANCHES,
> +				      DELETE_BRANCH_WARN_ONLY |
> +				      DELETE_BRANCH_NO_HEAD_FALLBACK |
> +				      (quiet ? DELETE_BRANCH_QUIET : 0));

Here we delete the branches - good.
> +		OPT_BOOL(0, "prune-merged", &prune_merged,
> +			N_("delete local branches whose upstream matches <branch> and is merged")),

s/is/are/

Sorry I didn't get round to reviewing these last week, I'll try and take a look at the tests and the other patches tomorrow

Thanks

Phillip

> diff --git a/t/t3200-branch.sh b/t/t3200-branch.sh
> index 4e7deddc04..27ea1319bb 100755
> --- a/t/t3200-branch.sh
> +++ b/t/t3200-branch.sh
> @@ -1809,4 +1809,205 @@ test_expect_success '--forked requires a value' '
>   	test_grep "requires a value" err
>   '
>   > +test_expect_success '--prune-merged: setup' '
> +	test_create_repo pm-upstream &&
> +	test_commit -C pm-upstream base &&
> +	git -C pm-upstream checkout -b next &&
> +	test_commit -C pm-upstream one-commit &&
> +	test_commit -C pm-upstream two-commit &&
> +	git -C pm-upstream branch one HEAD~ &&
> +	git -C pm-upstream branch two HEAD &&
> +	git -C pm-upstream branch wip main &&
> +	git -C pm-upstream checkout main &&
> +	test_create_repo pm-fork
> +'
> +
> +test_expect_success '--prune-merged deletes branches integrated into upstream' '
> +	test_when_finished "rm -rf pm-merged" &&
> +	git clone pm-upstream pm-merged &&
> +	git -C pm-merged remote add fork ../pm-fork &&
> +	test_config -C pm-merged remote.pushDefault fork &&
> +	test_config -C pm-merged push.default current &&
> +	git -C pm-merged branch one one-commit &&
> +	git -C pm-merged branch --set-upstream-to=origin/next one &&
> +	git -C pm-merged branch two two-commit &&
> +	git -C pm-merged branch --set-upstream-to=origin/next two &&
> +
> +	git -C pm-merged branch --prune-merged "origin/*" &&
> +
> +	test_must_fail git -C pm-merged rev-parse --verify refs/heads/one &&
> +	test_must_fail git -C pm-merged rev-parse --verify refs/heads/two
> +'
> +
> +test_expect_success '--prune-merged accepts a literal upstream' '
> +	test_when_finished "rm -rf pm-literal" &&
> +	git clone pm-upstream pm-literal &&
> +	git -C pm-literal remote add fork ../pm-fork &&
> +	test_config -C pm-literal remote.pushDefault fork &&
> +	test_config -C pm-literal push.default current &&
> +	git -C pm-literal branch one one-commit &&
> +	git -C pm-literal branch --set-upstream-to=origin/next one &&
> +
> +	git -C pm-literal branch --prune-merged origin/next &&
> +
> +	test_must_fail git -C pm-literal rev-parse --verify refs/heads/one
> +'
> +
> +test_expect_success '--prune-merged unions multiple <branch> arguments' '
> +	test_when_finished "rm -rf pm-union" &&
> +	git clone pm-upstream pm-union &&
> +	git -C pm-union remote add fork ../pm-fork &&
> +	test_config -C pm-union remote.pushDefault fork &&
> +	test_config -C pm-union push.default current &&
> +	git -C pm-union branch one one-commit &&
> +	git -C pm-union branch --set-upstream-to=origin/next one &&
> +	git -C pm-union branch two base &&
> +	git -C pm-union branch --set-upstream-to=origin/main two &&
> +	git -C pm-union checkout --detach &&
> +
> +	git -C pm-union branch --prune-merged origin/next origin/main &&
> +
> +	test_must_fail git -C pm-union rev-parse --verify refs/heads/one &&
> +	test_must_fail git -C pm-union rev-parse --verify refs/heads/two
> +'
> +
> +test_expect_success '--prune-merged accepts a local upstream' '
> +	test_when_finished "rm -rf pm-local" &&
> +	git clone pm-upstream pm-local &&
> +	git -C pm-local remote add fork ../pm-fork &&
> +	test_config -C pm-local remote.pushDefault fork &&
> +	test_config -C pm-local push.default current &&
> +	git -C pm-local checkout -b trunk &&
> +	git -C pm-local branch one one-commit &&
> +	git -C pm-local branch --set-upstream-to=trunk one &&
> +	git -C pm-local merge --ff-only one-commit &&
> +
> +	git -C pm-local branch --prune-merged trunk &&
> +
> +	test_must_fail git -C pm-local rev-parse --verify refs/heads/one
> +'
> +
> +test_expect_success '--prune-merged warns instead of erroring on un-integrated commits' '
> +	test_when_finished "rm -rf pm-unmerged" &&
> +	git clone pm-upstream pm-unmerged &&
> +	git -C pm-unmerged remote add fork ../pm-fork &&
> +	test_config -C pm-unmerged remote.pushDefault fork &&
> +	test_config -C pm-unmerged push.default current &&
> +	git -C pm-unmerged checkout -b wip origin/wip &&
> +	git -C pm-unmerged branch --set-upstream-to=origin/next wip &&
> +	test_commit -C pm-unmerged local-only &&
> +	git -C pm-unmerged checkout - &&
> +
> +	git -C pm-unmerged branch --prune-merged "origin/*" 2>err &&
> +	test_grep "not fully merged" err &&
> +	test_grep ! "If you are sure you want to delete it" err &&
> +	git -C pm-unmerged rev-parse --verify refs/heads/wip
> +'
> +
> +test_expect_success '--prune-merged is silent about not-merged-to-HEAD' '
> +	test_when_finished "rm -rf pm-nohead" &&
> +	git clone pm-upstream pm-nohead &&
> +	git -C pm-nohead remote add fork ../pm-fork &&
> +	test_config -C pm-nohead remote.pushDefault fork &&
> +	test_config -C pm-nohead push.default current &&
> +	git -C pm-nohead branch topic one-commit &&
> +	git -C pm-nohead branch --set-upstream-to=origin/next topic &&
> +
> +	git -C pm-nohead branch --prune-merged "origin/*" 2>err &&
> +
> +	test_grep ! "not yet merged to HEAD" err &&
> +	test_must_fail git -C pm-nohead rev-parse --verify refs/heads/topic
> +'
> +
> +test_expect_success '--prune-merged skips branches whose upstream is gone' '
> +	test_when_finished "rm -rf pm-upstream-gone" &&
> +	git clone pm-upstream pm-upstream-gone &&
> +	git -C pm-upstream-gone remote add fork ../pm-fork &&
> +	test_config -C pm-upstream-gone remote.pushDefault fork &&
> +	test_config -C pm-upstream-gone push.default current &&
> +	git -C pm-upstream-gone branch one one-commit &&
> +	git -C pm-upstream-gone branch --set-upstream-to=origin/next one &&
> +
> +	git -C pm-upstream-gone update-ref -d refs/remotes/origin/next &&
> +	git -C pm-upstream-gone branch --prune-merged "origin/*" &&
> +
> +	git -C pm-upstream-gone rev-parse --verify refs/heads/one
> +'
> +
> +test_expect_success '--prune-merged never deletes the checked-out branch' '
> +	test_when_finished "rm -rf pm-head" &&
> +	git clone pm-upstream pm-head &&
> +	git -C pm-head remote add fork ../pm-fork &&
> +	test_config -C pm-head remote.pushDefault fork &&
> +	test_config -C pm-head push.default current &&
> +	git -C pm-head checkout -b one one-commit &&
> +	git -C pm-head branch --set-upstream-to=origin/next one &&
> +
> +	git -C pm-head branch --prune-merged "origin/*" &&
> +
> +	git -C pm-head rev-parse --verify refs/heads/one
> +'
> +
> +test_expect_success '--prune-merged spares branches that push back to their upstream' '
> +	test_when_finished "rm -rf pm-push-eq" &&
> +	git clone pm-upstream pm-push-eq &&
> +	git -C pm-push-eq checkout --detach &&
> +
> +	git -C pm-push-eq branch --prune-merged "origin/*" &&
> +
> +	git -C pm-push-eq rev-parse --verify refs/heads/main
> +'
> +
> +test_expect_success '--prune-merged spares a per-branch pushRemote==upstream remote' '
> +	test_when_finished "rm -rf pm-push-branch" &&
> +	git clone pm-upstream pm-push-branch &&
> +	git -C pm-push-branch remote add fork ../pm-fork &&
> +	test_config -C pm-push-branch remote.pushDefault fork &&
> +	test_config -C pm-push-branch push.default current &&
> +	test_config -C pm-push-branch branch.main.pushRemote origin &&
> +	git -C pm-push-branch checkout --detach &&
> +
> +	git -C pm-push-branch branch --prune-merged "origin/*" &&
> +
> +	git -C pm-push-branch rev-parse --verify refs/heads/main
> +'
> +
> +test_expect_success '--prune-merged prunes when @{push} differs from @{upstream}' '
> +	test_when_finished "rm -rf pm-push-diff" &&
> +	git clone pm-upstream pm-push-diff &&
> +	git -C pm-push-diff remote add fork ../pm-fork &&
> +	test_config -C pm-push-diff remote.pushDefault fork &&
> +	test_config -C pm-push-diff push.default current &&
> +	git -C pm-push-diff branch topic one-commit &&
> +	git -C pm-push-diff branch --set-upstream-to=origin/next topic &&
> +	git -C pm-push-diff checkout --detach &&
> +
> +	git -C pm-push-diff branch --prune-merged "origin/*" &&
> +
> +	test_must_fail git -C pm-push-diff rev-parse --verify refs/heads/topic
> +'
> +
> +test_expect_success '--prune-merged requires at least one <branch>' '
> +	test_must_fail git -C forked branch --prune-merged 2>err &&
> +	test_grep "requires at least one <branch>" err
> +'
> +
> +test_expect_success '--prune-merged takes positional <branch> arguments' '
> +	test_when_finished "rm -rf pm-positional" &&
> +	git clone pm-upstream pm-positional &&
> +	git -C pm-positional remote add fork ../pm-fork &&
> +	test_config -C pm-positional remote.pushDefault fork &&
> +	test_config -C pm-positional push.default current &&
> +	git -C pm-positional branch one one-commit &&
> +	git -C pm-positional branch --set-upstream-to=origin/next one &&
> +	git -C pm-positional branch two base &&
> +	git -C pm-positional branch --set-upstream-to=origin/main two &&
> +	git -C pm-positional checkout --detach &&
> +
> +	git -C pm-positional branch --prune-merged origin/next origin/main &&
> +
> +	test_must_fail git -C pm-positional rev-parse --verify refs/heads/one &&
> +	test_must_fail git -C pm-positional rev-parse --verify refs/heads/two
> +'
> +
>   test_done

Hi Harald

On 09/06/2026 11:11, Harald Nordgren via GitGitGadget wrote:
> From: Harald Nordgren <haraldnordgren@gmail.com>
> > With --dry-run, --prune-merged prints the local branches it would
> delete, one "Would delete branch <name>" line each, and exits
> without touching any ref. The same filtering applies, so the output
> is exactly the set that the real run would delete.

I can see this being very useful.

> diff --git a/builtin/branch.c b/builtin/branch.c
> index 52a0371292..7c52a88af2 100644
> --- a/builtin/branch.c
> +++ b/builtin/branch.c
> @@ -717,7 +717,7 @@ static int parse_opt_forked(const struct option *opt, const char *arg, int unset
>   }
>   >   static int prune_merged_branches(int argc, const char **argv,
> -				 int quiet)
> +				 int quiet, int dry_run)

Let's not start adding multiple boolean augments - use a flags argument like we do for delete_branches() - if you get feedback on one patch you should think about whether it applies later in the series as well. The rest of the implementation looks good.

> diff --git a/t/t3200-branch.sh b/t/t3200-branch.sh
> index 3f7b1fc3d6..305c0141fc 100755
> --- a/t/t3200-branch.sh
> +++ b/t/t3200-branch.sh
> @@ -2040,4 +2040,48 @@ test_expect_success 'branch -d still deletes a pruneMerged=false branch' '
>   	test_must_fail git -C pm-optout-d rev-parse --verify refs/heads/one
>   '
>   > +test_expect_success '--prune-merged --dry-run lists but does not delete' '

A good way to test --dry-run would be to add it to an existing test before calling --prune-merged without --dry-run.

Thanks

Phillip

> +	test_when_finished "rm -rf pm-dry" &&
> +	git clone pm-upstream pm-dry &&
> +	git -C pm-dry remote add fork ../pm-fork &&
> +	test_config -C pm-dry remote.pushDefault fork &&
> +	test_config -C pm-dry push.default current &&
> +	git -C pm-dry branch one one-commit &&
> +	git -C pm-dry branch --set-upstream-to=origin/next one &&
> +	git -C pm-dry branch two two-commit &&
> +	git -C pm-dry branch --set-upstream-to=origin/next two &&
> +
> +	git -C pm-dry branch --dry-run --prune-merged "origin/*" >actual &&
> +	test_grep "Would delete branch one " actual &&
> +	test_grep "Would delete branch two " actual &&
> +
> +	git -C pm-dry rev-parse --verify refs/heads/one &&
> +	git -C pm-dry rev-parse --verify refs/heads/two
> +'
> +
> +test_expect_success '--prune-merged --dry-run only lists branches the live run would delete' '
> +	test_when_finished "rm -rf pm-dry-mixed" &&
> +	git clone pm-upstream pm-dry-mixed &&
> +	git -C pm-dry-mixed remote add fork ../pm-fork &&
> +	test_config -C pm-dry-mixed remote.pushDefault fork &&
> +	test_config -C pm-dry-mixed push.default current &&
> +	git -C pm-dry-mixed checkout -b wip origin/next &&
> +	git -C pm-dry-mixed branch --set-upstream-to=origin/next wip &&
> +	test_commit -C pm-dry-mixed local-only &&
> +	git -C pm-dry-mixed checkout - &&
> +	git -C pm-dry-mixed branch merged one-commit &&
> +	git -C pm-dry-mixed branch --set-upstream-to=origin/next merged &&
> +
> +	git -C pm-dry-mixed branch --dry-run --prune-merged "origin/*" >out &&
> +	test_grep "Would delete branch merged" out &&
> +	test_grep ! "Would delete branch wip" out &&
> +	git -C pm-dry-mixed rev-parse --verify refs/heads/wip &&
> +	git -C pm-dry-mixed rev-parse --verify refs/heads/merged
> +'
> +
> +test_expect_success '--dry-run without --prune-merged is rejected' '
> +	test_must_fail git -C forked branch --dry-run 2>err &&
> +	test_grep "requires --prune-merged" err
> +'
> +
>   test_done

> > With --dry-run, --prune-merged prints the local branches it would
> > delete, one "Would delete branch <name>" line each, and exits
> > without touching any ref. The same filtering applies, so the output
> > is exactly the set that the real run would delete.
>
> I can see this being very useful.

Great to hear and thanks for taking the time to review this! Much appreciated!

> >   static int prune_merged_branches(int argc, const char **argv,
> > -                              int quiet)
> > +                              int quiet, int dry_run)
>
> Let's not start adding multiple boolean augments - use a flags argument
> like we do for delete_branches() - if you get feedback on one patch you
> should think about whether it applies later in the series as well. The
> rest of the implementation looks good.

I'm trying to generalize all feedback, but sometimes I miss things.
Thanks for pointing it out!


Harald

Hi Harald

On 09/06/2026 11:11, Harald Nordgren via GitGitGadget wrote:

Carrying on where I left off yesterday ...

> diff --git a/t/t3200-branch.sh b/t/t3200-branch.sh
> index 4e7deddc04..27ea1319bb 100755
> --- a/t/t3200-branch.sh
> +++ b/t/t3200-branch.sh
> @@ -1809,4 +1809,205 @@ test_expect_success '--forked requires a value' '
>   	test_grep "requires a value" err
>   '
>   > +test_expect_success '--prune-merged: setup' '
> +	test_create_repo pm-upstream &&

The rest of this test would be easier to read if we did

	(
		cd pm-upstream &&
		...
	)

rather than prefixing every command with "-C pm-upstream"

> +	test_commit -C pm-upstream base &&
> +	git -C pm-upstream checkout -b next &&
> +	test_commit -C pm-upstream one-commit &&
> +	test_commit -C pm-upstream two-commit &&
> +	git -C pm-upstream branch one HEAD~ &&
> +	git -C pm-upstream branch two HEAD &&
> +	git -C pm-upstream branch wip main &&
> +	git -C pm-upstream checkout main &&
> +	test_create_repo pm-fork
> +'
> +
> +test_expect_success '--prune-merged deletes branches integrated into upstream' '
> +	test_when_finished "rm -rf pm-merged" &&
> +	git clone pm-upstream pm-merged &&
> +	git -C pm-merged remote add fork ../pm-fork &&
> +	test_config -C pm-merged remote.pushDefault fork &&
> +	test_config -C pm-merged push.default current &&

So we clone upstream and add fork as the default push remote. I find the pm- prefixes rather distracting. It would be clearer to me if we just called the repositories "upstream", "fork" and "repo"

> +	git -C pm-merged branch one one-commit &&
> +	git -C pm-merged branch --set-upstream-to=origin/next one &&
> +	git -C pm-merged branch two two-commit &&
> +	git -C pm-merged branch --set-upstream-to=origin/next two &&

Now we set up a couple of local branches with no local commits that track origin/next which seems a bit odd. Why don't we create local branches based one origin/next (and origin/main if we're using a wildcard below) with some local commits like a user would?

> +	git -C pm-merged branch --prune-merged "origin/*" &&

Here we delete all the branches whose upstream is on origin - which is all the branches that we've created so we're not really testing the safety features.

> +	test_must_fail git -C pm-merged rev-parse --verify refs/heads/one &&
> +	test_must_fail git -C pm-merged rev-parse --verify refs/heads/two

This verifies that the branches are deleted. It would be a good idea to check the output of command above to check --prune-merged prints what we expect it to and that it leaves branches with other upstreams.

> +test_expect_success '--prune-merged accepts a literal upstream' '
> +	test_when_finished "rm -rf pm-literal" &&
> +	git clone pm-upstream pm-literal &&

let's not litter the test directory with a hundred repositories - just call it "repo" and add remove it with test_when_finished in each test, or reuse it so we don't waste time cloning and setting up the config each time (that would mean not using test_config).

> +	git -C pm-literal remote add fork ../pm-fork &&
> +	test_config -C pm-literal remote.pushDefault fork &&
> +	test_config -C pm-literal push.default current &&
> +	git -C pm-literal branch one one-commit &&
> +	git -C pm-literal branch --set-upstream-to=origin/next one &&
> +
> +	git -C pm-literal branch --prune-merged origin/next &&
> +
> +	test_must_fail git -C pm-literal rev-parse --verify refs/heads/one

Again we're not testing that nothing else is deleted.

> +'
> +
> +test_expect_success '--prune-merged unions multiple <branch> arguments' '
> +	test_when_finished "rm -rf pm-union" &&
> +	git clone pm-upstream pm-union &&
> +	git -C pm-union remote add fork ../pm-fork &&
> +	test_config -C pm-union remote.pushDefault fork &&
> +	test_config -C pm-union push.default current &&
> +	git -C pm-union branch one one-commit &&
> +	git -C pm-union branch --set-upstream-to=origin/next one &&
> +	git -C pm-union branch two base &&
> +	git -C pm-union branch --set-upstream-to=origin/main two &&
> +	git -C pm-union checkout --detach &&
> +
> +	git -C pm-union branch --prune-merged origin/next origin/main &&

This is more interesting - we don't need the test for a single literal upstream if we're doing this. Again we need to test the safety features. As these are integration tests you can do that at the same time as testing that some branches are removed - you don't need so many separate (expensive) tests.

> +	test_must_fail git -C pm-union rev-parse --verify refs/heads/one &&
> +	test_must_fail git -C pm-union rev-parse --verify refs/heads/two
> +'
> +
> +test_expect_success '--prune-merged accepts a local upstream' '
> +	test_when_finished "rm -rf pm-local" &&
> +	git clone pm-upstream pm-local &&
> +	git -C pm-local remote add fork ../pm-fork &&
> +	test_config -C pm-local remote.pushDefault fork &&
> +	test_config -C pm-local push.default current &&
> +	git -C pm-local checkout -b trunk &&
> +	git -C pm-local branch one one-commit &&
> +	git -C pm-local branch --set-upstream-to=trunk one &&
> +	git -C pm-local merge --ff-only one-commit &&
> +
> +	git -C pm-local branch --prune-merged trunk &&

Can't we test a local upstream at the same time as a remote upstream and save a test case?

> +	test_must_fail git -C pm-local rev-parse --verify refs/heads/one
> +'
> +
> +test_expect_success '--prune-merged warns instead of erroring on un-integrated commits' '
> +	test_when_finished "rm -rf pm-unmerged" &&
> +	git clone pm-upstream pm-unmerged &&
> +	git -C pm-unmerged remote add fork ../pm-fork &&
> +	test_config -C pm-unmerged remote.pushDefault fork &&
> +	test_config -C pm-unmerged push.default current &&
> +	git -C pm-unmerged checkout -b wip origin/wip &&
> +	git -C pm-unmerged branch --set-upstream-to=origin/next wip &&
> +	test_commit -C pm-unmerged local-only &&
> +	git -C pm-unmerged checkout - &&
> +
> +	git -C pm-unmerged branch --prune-merged "origin/*" 2>err &&
> +	test_grep "not fully merged" err &&
> +	test_grep ! "If you are sure you want to delete it" err &&

I'm always suspicious of test_grep when we know what the output should look like - it might be better to use test_cmp. This test does not check that we also delete branches that are merged when we see one that isn't.

I'm going to stop here - the tests I've read seem to me to be too much like unit tests checking one aspect of the implementation in isolation rather than checking that the whole feature works as expected.

Thanks

Phillip

> +	git -C pm-unmerged rev-parse --verify refs/heads/wip
> +'
> +
> +test_expect_success '--prune-merged is silent about not-merged-to-HEAD' '
> +	test_when_finished "rm -rf pm-nohead" &&
> +	git clone pm-upstream pm-nohead &&
> +	git -C pm-nohead remote add fork ../pm-fork &&
> +	test_config -C pm-nohead remote.pushDefault fork &&
> +	test_config -C pm-nohead push.default current &&
> +	git -C pm-nohead branch topic one-commit &&
> +	git -C pm-nohead branch --set-upstream-to=origin/next topic &&
> +
> +	git -C pm-nohead branch --prune-merged "origin/*" 2>err &&
> +
> +	test_grep ! "not yet merged to HEAD" err &&
> +	test_must_fail git -C pm-nohead rev-parse --verify refs/heads/topic
> +'
> +
> +test_expect_success '--prune-merged skips branches whose upstream is gone' '
> +	test_when_finished "rm -rf pm-upstream-gone" &&
> +	git clone pm-upstream pm-upstream-gone &&
> +	git -C pm-upstream-gone remote add fork ../pm-fork &&
> +	test_config -C pm-upstream-gone remote.pushDefault fork &&
> +	test_config -C pm-upstream-gone push.default current &&
> +	git -C pm-upstream-gone branch one one-commit &&
> +	git -C pm-upstream-gone branch --set-upstream-to=origin/next one &&
> +
> +	git -C pm-upstream-gone update-ref -d refs/remotes/origin/next &&
> +	git -C pm-upstream-gone branch --prune-merged "origin/*" &&
> +
> +	git -C pm-upstream-gone rev-parse --verify refs/heads/one
> +'
> +
> +test_expect_success '--prune-merged never deletes the checked-out branch' '
> +	test_when_finished "rm -rf pm-head" &&
> +	git clone pm-upstream pm-head &&
> +	git -C pm-head remote add fork ../pm-fork &&
> +	test_config -C pm-head remote.pushDefault fork &&
> +	test_config -C pm-head push.default current &&
> +	git -C pm-head checkout -b one one-commit &&
> +	git -C pm-head branch --set-upstream-to=origin/next one &&
> +
> +	git -C pm-head branch --prune-merged "origin/*" &&
> +
> +	git -C pm-head rev-parse --verify refs/heads/one
> +'
> +
> +test_expect_success '--prune-merged spares branches that push back to their upstream' '
> +	test_when_finished "rm -rf pm-push-eq" &&
> +	git clone pm-upstream pm-push-eq &&
> +	git -C pm-push-eq checkout --detach &&
> +
> +	git -C pm-push-eq branch --prune-merged "origin/*" &&
> +
> +	git -C pm-push-eq rev-parse --verify refs/heads/main
> +'
> +
> +test_expect_success '--prune-merged spares a per-branch pushRemote==upstream remote' '
> +	test_when_finished "rm -rf pm-push-branch" &&
> +	git clone pm-upstream pm-push-branch &&
> +	git -C pm-push-branch remote add fork ../pm-fork &&
> +	test_config -C pm-push-branch remote.pushDefault fork &&
> +	test_config -C pm-push-branch push.default current &&
> +	test_config -C pm-push-branch branch.main.pushRemote origin &&
> +	git -C pm-push-branch checkout --detach &&
> +
> +	git -C pm-push-branch branch --prune-merged "origin/*" &&
> +
> +	git -C pm-push-branch rev-parse --verify refs/heads/main
> +'
> +
> +test_expect_success '--prune-merged prunes when @{push} differs from @{upstream}' '
> +	test_when_finished "rm -rf pm-push-diff" &&
> +	git clone pm-upstream pm-push-diff &&
> +	git -C pm-push-diff remote add fork ../pm-fork &&
> +	test_config -C pm-push-diff remote.pushDefault fork &&
> +	test_config -C pm-push-diff push.default current &&
> +	git -C pm-push-diff branch topic one-commit &&
> +	git -C pm-push-diff branch --set-upstream-to=origin/next topic &&
> +	git -C pm-push-diff checkout --detach &&
> +
> +	git -C pm-push-diff branch --prune-merged "origin/*" &&
> +
> +	test_must_fail git -C pm-push-diff rev-parse --verify refs/heads/topic
> +'
> +
> +test_expect_success '--prune-merged requires at least one <branch>' '
> +	test_must_fail git -C forked branch --prune-merged 2>err &&
> +	test_grep "requires at least one <branch>" err
> +'
> +
> +test_expect_success '--prune-merged takes positional <branch> arguments' '
> +	test_when_finished "rm -rf pm-positional" &&
> +	git clone pm-upstream pm-positional &&
> +	git -C pm-positional remote add fork ../pm-fork &&
> +	test_config -C pm-positional remote.pushDefault fork &&
> +	test_config -C pm-positional push.default current &&
> +	git -C pm-positional branch one one-commit &&
> +	git -C pm-positional branch --set-upstream-to=origin/next one &&
> +	git -C pm-positional branch two base &&
> +	git -C pm-positional branch --set-upstream-to=origin/main two &&
> +	git -C pm-positional checkout --detach &&
> +
> +	git -C pm-positional branch --prune-merged origin/next origin/main &&
> +
> +	test_must_fail git -C pm-positional rev-parse --verify refs/heads/one &&
> +	test_must_fail git -C pm-positional rev-parse --verify refs/heads/two
> +'
> +
>   test_done

> > diff --git a/t/t3200-branch.sh b/t/t3200-branch.sh
> > index 4e7deddc04..27ea1319bb 100755
> > --- a/t/t3200-branch.sh
> > +++ b/t/t3200-branch.sh
> > @@ -1809,4 +1809,205 @@ test_expect_success '--forked requires a value' '
> >       test_grep "requires a value" err
> >   '
> >
> > +test_expect_success '--prune-merged: setup' '
> > +     test_create_repo pm-upstream &&
>
> The rest of this test would be easier to read if we did
>
>         (
>                 cd pm-upstream &&
>                 ...
>         )
>
> rather than prefixing every command with "-C pm-upstream"

I feel like the discussion to nest or not to nest has come up many
times in other topics as well. I don't feel strongly about either way,
but I just want to flag that if I change it now, another reviewer
might ask me to change it back later.

Should the rules be to nest inside of setup functions (and helpers?)
but not inside the actual tests?

> > +     test_commit -C pm-upstream base &&
> > +     git -C pm-upstream checkout -b next &&
> > +     test_commit -C pm-upstream one-commit &&
> > +     test_commit -C pm-upstream two-commit &&
> > +     git -C pm-upstream branch one HEAD~ &&
> > +     git -C pm-upstream branch two HEAD &&
> > +     git -C pm-upstream branch wip main &&
> > +     git -C pm-upstream checkout main &&
> > +     test_create_repo pm-fork
> > +'
> > +
> > +test_expect_success '--prune-merged deletes branches integrated into upstream' '
> > +     test_when_finished "rm -rf pm-merged" &&
> > +     git clone pm-upstream pm-merged &&
> > +     git -C pm-merged remote add fork ../pm-fork &&
> > +     test_config -C pm-merged remote.pushDefault fork &&
> > +     test_config -C pm-merged push.default current &&
>
> So we clone upstream and add fork as the default push remote. I find the
> pm- prefixes rather distracting. It would be clearer to me if we just
> called the repositories "upstream", "fork" and "repo"

Good point.

> > +     test_must_fail git -C pm-local rev-parse --verify refs/heads/one
> > +'
> > +
> > +test_expect_success '--prune-merged warns instead of erroring on un-integrated commits' '
> > +     test_when_finished "rm -rf pm-unmerged" &&
> > +     git clone pm-upstream pm-unmerged &&
> > +     git -C pm-unmerged remote add fork ../pm-fork &&
> > +     test_config -C pm-unmerged remote.pushDefault fork &&
> > +     test_config -C pm-unmerged push.default current &&
> > +     git -C pm-unmerged checkout -b wip origin/wip &&
> > +     git -C pm-unmerged branch --set-upstream-to=origin/next wip &&
> > +     test_commit -C pm-unmerged local-only &&
> > +     git -C pm-unmerged checkout - &&
> > +
> > +     git -C pm-unmerged branch --prune-merged "origin/*" 2>err &&
> > +     test_grep "not fully merged" err &&
> > +     test_grep ! "If you are sure you want to delete it" err &&
>
> I'm always suspicious of test_grep when we know what the output should
> look like - it might be better to use test_cmp. This test does not check
> that we also delete branches that are merged when we see one that isn't.
>
> I'm going to stop here - the tests I've read seem to me to be too much
> like unit tests checking one aspect of the implementation in isolation
> rather than checking that the whole feature works as expected.

I'll respond to the rest here: Excellent points regarding the testing
aboce, I will take a look at doing this.


Harald

"Harald Nordgren via GitGitGadget" <gitgitgadget@gmail.com> writes:

> +`--prune-merged`::
> +	Delete the local branches that `--forked` would list for
> +	the same _<remote>_ arguments, but only when the branch's
> +	push destination remote-tracking branch (the branch `git push`
> +	would update; see `branch_get_push` semantics) no longer
> +	resolves locally.

I thought the thing you were aiming for is this scenario:

    git fetch origin
    git checkout -t -b hn/topic origin/next
    ... work work work ...
    git push origin
    ... the above pushes the current hn/topic to update their next
    git checkout master ;# or anywhere other than hn/topic
    git fetch origin
    git branch --prune-merged origin

The last step notices that our local hn/topic has been merged at the
remote to the target branch 'next', and the second-to-last fetch
makes us notice that origin/next now has our hn/topic merged, so we
no longer have a reason to keep hn/topic around.

But the above description uses quite different condition.  You want
to notice that _they_ removed 'next' (for that, the second-to-last
fetch may need to be run with --prune) and then remove our local
hn/topic, but to me, that sounds nonsense for two reasons.

 (1) Their 'next' is something contributors may fork from to work
     on.  You exactly did that with hn/topic branch of your own.
     Why would we even expect that to go away?

 (2) When disappearance of their 'next' is fetched to our
     remote-tracking namespace, we would not even know if hn/topic
     that used to fork from has been already integrated and stashed
     safely on some other branch on the remote.  It sounds very
     unsafe to remove it based on disappearance of origin/next
     remote-tracking branch.

> In other words: the branch was pushed
> +	under some name on _<remote>_, and that name has since
> +	been pruned upstream.
> ++
> +As a safety check, branches with commits not yet integrated into
> +their upstream remote-tracking branch are refused; if the upstream
> +itself is gone, the remote's default branch is consulted instead.

Again, this is as nonsense as our example in an earlier iteration of
having a topic forked from my 'todo' branch while the HEAD is
pointing at the default branch that is 'master'.  If the upstream
itself is gone, removing anything based on some other criteria
cannot by definition a "safety check".  I'd suggest rethinking the
logic.

> @@ -171,7 +197,7 @@ static int branch_merged(int kind, const char *name,
>  	 * any of the following code, but during the transition period,
>  	 * a gentle reminder is in order.
>  	 */
> -	if (head_rev != reference_rev) {
> +	if (!no_head_fallback && head_rev != reference_rev) {

I somehow thought that the necessary check at the lowest level can
reuse most of the "branch -d" protection logic, except that it needs
to pass NULL for head_rev from check_branch_commit() down to
branch_merged() when doing "branch --prune-merged".  Do we really
need an extra no_head_fallback parameter?

> But the above description uses quite different condition.  You want
> to notice that _they_ removed 'next' (for that, the second-to-last
> fetch may need to be run with --prune) and then remove our local
> hn/topic, but to me, that sounds nonsense for two reasons.

I wanted to be able to be aggresice with deleting, but maybe this went a
bit overboard. Would still be nice to have a nuclear option.


Harald